src/lexer.c

   1 /* A lexical scanner generated by flex */
   2
   3 /* Scanner skeleton version:
   4  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
   5  */
   6
   7 #define FLEX_SCANNER
   8 #define YY_FLEX_MAJOR_VERSION 2
   9 #define YY_FLEX_MINOR_VERSION 5
  10
  11 #include <stdio.h>
  12 #include <unistd.h>
  13
  14
  15 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  16 #ifdef c_plusplus
  17 #ifndef __cplusplus
  18 #define __cplusplus
  19 #endif
  20 #endif
  21
  22
  23 #ifdef __cplusplus
  24
  25 #include <stdlib.h>
  26
  27 /* Use prototypes in function declarations. */
  28 #define YY_USE_PROTOS
  29
  30 /* The "const" storage-class-modifier is valid. */
  31 #define YY_USE_CONST
  32
  33 #else   /* ! __cplusplus */
  34
  35 #if __STDC__
  36
  37 #define YY_USE_PROTOS
  38 #define YY_USE_CONST
  39
  40 #endif  /* __STDC__ */
  41 #endif  /* ! __cplusplus */
  42
  43 #ifdef __TURBOC__
  44  #pragma warn -rch
  45  #pragma warn -use
  46 #include <io.h>
  47 #include <stdlib.h>
  48 #define YY_USE_CONST
  49 #define YY_USE_PROTOS
  50 #endif
  51
  52 #ifdef YY_USE_CONST
  53 #define yyconst const
  54 #else
  55 #define yyconst
  56 #endif
  57
  58
  59 #ifdef YY_USE_PROTOS
  60 #define YY_PROTO(proto) proto
  61 #else
  62 #define YY_PROTO(proto) ()
  63 #endif
  64
  65 /* Returned upon end-of-file. */
  66 #define YY_NULL 0
  67
  68 /* Promotes a possibly negative, possibly signed char to an unsigned
  69  * integer for use as an array index.  If the signed char is negative,
  70  * we want to instead treat it as an 8-bit unsigned char, hence the
  71  * double cast.
  72  */
  73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74
  75 /* Enter a start condition.  This macro really ought to take a parameter,
  76  * but we do it the disgusting crufty way forced on us by the ()-less
  77  * definition of BEGIN.
  78  */
  79 #define BEGIN yy_start = 1 + 2 *
  80
  81 /* Translate the current start state into a value that can be later handed
  82  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83  * compatibility.
  84  */
  85 #define YY_START ((yy_start - 1) / 2)
  86 #define YYSTATE YY_START
  87
  88 /* Action number for EOF rule of a given start state. */
  89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90
  91 /* Special action meaning "start processing a new file". */
  92 #define YY_NEW_FILE yyrestart( yyin )
  93
  94 #define YY_END_OF_BUFFER_CHAR 0
  95
  96 /* Size of default input buffer. */
  97 #define YY_BUF_SIZE 16384
  98
  99 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 100
 101 extern int yyleng;
 102 extern FILE *yyin, *yyout;
 103
 104 #define EOB_ACT_CONTINUE_SCAN 0
 105 #define EOB_ACT_END_OF_FILE 1
 106 #define EOB_ACT_LAST_MATCH 2
 107
 108 /* The funky do-while in the following #define is used to turn the definition
 109  * int a single C statement (which needs a semi-colon terminator).  This
 110  * avoids problems with code like:
 111  *
 112  *      if ( condition_holds )
 113  *              yyless( 5 );
 114  *      else
 115  *              do_something_else();
 116  *
 117  * Prior to using the do-while the compiler would get upset at the
 118  * "else" because it interpreted the "if" statement as being all
 119  * done when it reached the ';' after the yyless() call.
 120  */
 121
 122 /* Return all but the first 'n' matched characters back to the input stream. */
 123
 124 #define yyless(n) \
 125         do \
 126                 { \
 127                 /* Undo effects of setting up yytext. */ \
 128                 *yy_cp = yy_hold_char; \
 129                 YY_RESTORE_YY_MORE_OFFSET \
 130                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 131                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 132                 } \
 133         while ( 0 )
 134
 135 #define unput(c) yyunput( c, yytext_ptr )
 136
 137 /* The following is because we cannot portably get our hands on size_t
 138  * (without autoconf's help, which isn't available because we want
 139  * flex-generated scanners to compile on their own).
 140  */
 141 typedef unsigned int yy_size_t;
 142
 143
 144 struct yy_buffer_state
 145         {
 146         FILE *yy_input_file;
 147
 148         char *yy_ch_buf;                /* input buffer */
 149         char *yy_buf_pos;               /* current position in input buffer */
 150
 151         /* Size of input buffer in bytes, not including room for EOB
 152          * characters.
 153          */
 154         yy_size_t yy_buf_size;
 155
 156         /* Number of characters read into yy_ch_buf, not including EOB
 157          * characters.
 158          */
 159         int yy_n_chars;
 160
 161         /* Whether we "own" the buffer - i.e., we know we created it,
 162          * and can realloc() it to grow it, and should free() it to
 163          * delete it.
 164          */
 165         int yy_is_our_buffer;
 166
 167         /* Whether this is an "interactive" input source; if so, and
 168          * if we're using stdio for input, then we want to use getc()
 169          * instead of fread(), to make sure we stop fetching input after
 170          * each newline.
 171          */
 172         int yy_is_interactive;
 173
 174         /* Whether we're considered to be at the beginning of a line.
 175          * If so, '^' rules will be active on the next match, otherwise
 176          * not.
 177          */
 178         int yy_at_bol;
 179
 180         /* Whether to try to fill the input buffer when we reach the
 181          * end of it.
 182          */
 183         int yy_fill_buffer;
 184
 185         int yy_buffer_status;
 186 #define YY_BUFFER_NEW 0
 187 #define YY_BUFFER_NORMAL 1
 188         /* When an EOF's been seen but there's still some text to process
 189          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 190          * shouldn't try reading from the input source any more.  We might
 191          * still have a bunch of tokens to match, though, because of
 192          * possible backing-up.
 193          *
 194          * When we actually see the EOF, we change the status to "new"
 195          * (via yyrestart()), so that the user can continue scanning by
 196          * just pointing yyin at a new input file.
 197          */
 198 #define YY_BUFFER_EOF_PENDING 2
 199         };
 200
 201 static YY_BUFFER_STATE yy_current_buffer = 0;
 202
 203 /* We provide macros for accessing buffer states in case in the
 204  * future we want to put the buffer states in a more general
 205  * "scanner state".
 206  */
 207 #define YY_CURRENT_BUFFER yy_current_buffer
 208
 209
 210 /* yy_hold_char holds the character lost when yytext is formed. */
 211 static char yy_hold_char;
 212
 213 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 214
 215
 216 int yyleng;
 217
 218 /* Points to current character in buffer. */
 219 static char *yy_c_buf_p = (char *) 0;
 220 static int yy_init = 1;         /* whether we need to initialize */
 221 static int yy_start = 0;        /* start state number */
 222
 223 /* Flag which is used to allow yywrap()'s to do buffer switches
 224  * instead of setting up a fresh yyin.  A bit of a hack ...
 225  */
 226 static int yy_did_buffer_switch_on_eof;
 227
 228 void yyrestart YY_PROTO(( FILE *input_file ));
 229
 230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 231 void yy_load_buffer_state YY_PROTO(( void ));
 232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 237
 238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 241
 242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 244 static void yy_flex_free YY_PROTO(( void * ));
 245
 246 #define yy_new_buffer yy_create_buffer
 247
 248 #define yy_set_interactive(is_interactive) \
 249         { \
 250         if ( ! yy_current_buffer ) \
 251                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 252         yy_current_buffer->yy_is_interactive = is_interactive; \
 253         }
 254
 255 #define yy_set_bol(at_bol) \
 256         { \
 257         if ( ! yy_current_buffer ) \
 258                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 259         yy_current_buffer->yy_at_bol = at_bol; \
 260         }
 261
 262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 263
 264
 265 #define YY_USES_REJECT
 266 typedef unsigned char YY_CHAR;
 267 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 268 typedef int yy_state_type;
 269 extern char *yytext;
 270 #define yytext_ptr yytext
 271
 272 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 273 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 274 static int yy_get_next_buffer YY_PROTO(( void ));
 275 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 276
 277 /* Done after the current pattern has been matched and before the
 278  * corresponding action - sets up yytext.
 279  */
 280 #define YY_DO_BEFORE_ACTION \
 281         yytext_ptr = yy_bp; \
 282         yyleng = (int) (yy_cp - yy_bp); \
 283         yy_hold_char = *yy_cp; \
 284         *yy_cp = '\0'; \
 285         yy_c_buf_p = yy_cp;
 286
 287 #define YY_NUM_RULES 88
 288 #define YY_END_OF_BUFFER 89
 289 static yyconst short int yy_acclist[401] =
 290     {   0,
 291        89,   86,   88,   85,   86,   88,    1,   87,   88,   86,
 292        87,   88,   86,   88,   86,   88,   85,   86,   88,   86,
 293        88,   86,   88,   26,   86,   88,    1,   27,   87,   88,
 294        26,   86,   87,   88,   26,   86,   88,   26,   86,   88,
 295        49,   86,   88,    1,   50,   87,   88,   49,   86,   87,
 296        88,   42,   49,   86,   88,   49,   86,   88,   49,   86,
 297        88,   49,   86,   88,   47,   49,   86,   88,   48,   49,
 298        86,   88,   49,   86,   88,   49,   86,   88,   45,   86,
 299        88,    1,   46,   87,   88,   45,   86,   87,   88,   44,
 300        45,   86,   88,   45,   86,   88,   86,   88,   86,   88,
 301
 302        77,   86,   88,   77,   86,   88,   86,   88,   80,   86,
 303        88,   80,   86,   88,   80,   86,   88,   80,   86,   88,
 304        82,   86,   88,   86,   88,   86,   88,   86,   88,   80,
 305        86,   88,   80,   86,   88,   80,   86,   88,   80,   86,
 306        88,   80,   86,   88,   80,   86,   88,   80,   86,   88,
 307        80,   86,   88,   80,   86,   88,   80,   86,   88,   80,
 308        86,   88,   80,   86,   88,   83,   86,   88,   84,   86,
 309        88,    9,   86,   88,    9,   86,   87,   88,    9,   86,
 310        88,    9,   86,   88,    9,   86,   88,   14,   86,   88,
 311        14,   86,   87,   88,   14,   86,   88,   14,   86,   88,
 312
 313        14,   86,   88,   17,   86,   88,   17,   86,   87,   88,
 314        17,   86,   88,   21,   33,   25,   22,   41,   34,   43,
 315        77,   23,   77,   77,   79,   80,   78,   80,   80,   80,
 316        24,   81,   80,   80,   80,   80,   80,   80,   80,   80,
 317        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
 318         8,    6,   13,   10,   12,   11,   13,   16,   15,    3,
 319        28,   32,   39,   35,   37,   18,   77,   19,   77,   77,
 320        79,   79,   78,   80,   80,   80,   68,   20,   80,   80,
 321        80,   80,   80,   80,   80,   63,   80,   80,   80,   80,
 322        80,   80,   80,   80,   80,   80,   80,   80,   80,   11,
 323
 324        29,   30,   31,   40,   36,   38,   79,   80,   54,   80,
 325        53,   80,    5,   80,   66,   80,   80,   80,   80,   58,
 326        80,   80,   61,   80,   80,   80,   80,   80,   80,   80,
 327        80,   80,   80,   80,   55,   80,    7,   51,   80,   53,
 328        80,   67,   80,   80,   64,   80,   80,   80,   80,   80,
 329        62,   80,   80,   80,   80,   57,   80,   80,   80,   80,
 330        80,   65,   80,   80,   80,   80,   69,   80,   75,   80,
 331        59,   80,   56,   80,   80,   80,   80,   80,   80,   70,
 332        80,   80,   80,   74,   80,   73,   80,   80,   76,   80,
 333        80,   60,   80,   72,   80,   71,   80,    2,    4,   52
 334
 335     } ;
 336
 337 static yyconst short int yy_accept[359] =
 338     {   0,
 339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 340         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
 341         4,    7,   10,   13,   15,   17,   20,   22,   24,   27,
 342        31,   35,   38,   41,   44,   48,   52,   56,   59,   62,
 343        65,   69,   73,   76,   79,   82,   86,   90,   94,   97,
 344        99,  101,  104,  107,  109,  112,  115,  118,  121,  124,
 345       126,  128,  130,  133,  136,  139,  142,  145,  148,  151,
 346       154,  157,  160,  163,  166,  169,  172,  175,  179,  182,
 347       185,  188,  191,  195,  198,  201,  204,  207,  211,  214,
 348       215,  215,  215,  215,  215,  215,  215,  215,  216,  216,
 349
 350       217,  217,  217,  217,  217,  217,  218,  218,  219,  219,
 351       219,  220,  221,  222,  223,  223,  223,  224,  224,  224,
 352       225,  226,  227,  228,  229,  230,  231,  231,  232,  232,
 353       232,  232,  233,  234,  235,  236,  237,  238,  239,  240,
 354       241,  242,  243,  244,  245,  246,  247,  248,  249,  250,
 355       251,  252,  252,  252,  252,  253,  253,  254,  254,  254,
 356       254,  255,  256,  256,  258,  259,  260,  260,  261,  261,
 357       261,  261,  262,  262,  262,  263,  263,  263,  263,  263,
 358       264,  264,  264,  264,  265,  266,  266,  267,  267,  268,
 359       268,  269,  270,  271,  272,  273,  274,  275,  276,  277,
 360
 361       278,  278,  278,  279,  279,  279,  280,  281,  282,  283,
 362       284,  285,  286,  288,  289,  290,  291,  292,  293,  294,
 363       295,  296,  297,  298,  299,  300,  300,  301,  301,  301,
 364       302,  302,  303,  304,  304,  304,  304,  305,  306,  307,
 365       307,  308,  309,  311,  313,  313,  314,  315,  317,  318,
 366       319,  320,  322,  323,  325,  326,  327,  328,  329,  330,
 367       331,  332,  333,  334,  335,  337,  337,  338,  338,  338,
 368       339,  339,  339,  339,  339,  339,  339,  340,  342,  344,
 369       345,  347,  348,  349,  350,  351,  353,  354,  355,  356,
 370       358,  359,  360,  360,  360,  360,  360,  360,  360,  361,
 371
 372       362,  364,  365,  366,  367,  369,  371,  373,  375,  376,
 373       377,  377,  377,  377,  377,  377,  378,  379,  380,  382,
 374       383,  384,  386,  386,  386,  386,  386,  386,  388,  389,
 375       391,  392,  394,  394,  394,  394,  394,  394,  394,  396,
 376       398,  398,  398,  398,  399,  399,  399,  399,  399,  400,
 377       400,  400,  400,  400,  400,  400,  401,  401
 378     } ;
 379
 380 static yyconst int yy_ec[256] =
 381     {   0,
 382         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 383         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
 384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 385         1,    5,    1,    6,    7,    1,    8,    1,    9,   10,
 386        11,   12,    1,    1,    1,   13,   14,   15,   16,   17,
 387        17,   17,   17,   17,   17,   18,   18,   19,    1,   20,
 388         1,   21,    1,    1,   22,   22,   22,   22,   23,   22,
 389        24,   24,   25,   24,   24,   24,   24,   24,   24,   24,
 390        24,   26,   27,   24,   24,   24,   24,   24,   24,   24,
 391        28,   29,   30,    1,   24,    1,   31,   32,   33,   34,
 392
 393        35,   36,   37,   38,   39,   24,   24,   40,   41,   42,
 394        43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 395        24,   24,   53,    1,   54,    1,    1,    1,    1,    1,
 396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 403
 404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 409         1,    1,    1,    1,    1
 410     } ;
 411
 412 static yyconst int yy_meta[55] =
 413     {   0,
 414         1,    2,    3,    1,    2,    1,    1,    1,    1,    1,
 415         1,    1,    1,    1,    4,    4,    4,    4,    5,    1,
 416         1,    6,    6,    7,    7,    7,    7,    1,    1,    8,
 417         6,    6,    6,    6,    6,    6,    7,    7,    7,    7,
 418         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
 419         7,    7,    1,    1
 420     } ;
 421
 422 static yyconst short int yy_base[384] =
 423     {   0,
 424         0,    4,    7,   13,   17,   69,   24,   36,  123,    0,
 425       165,    0,   31,   52,   48,   77,   55,   81,  848,  849,
 426       849,  849,  849,    1,  807,   42,   56,  811,  849,  849,
 427       849,  831,  817,  849,  849,  849,  849,   57,   10,    0,
 428       849,  849,   27,  789,  849,  849,  849,  849,    0,   86,
 429        78,  168,   99,    0,  823,   22,   49,   80,  849,  174,
 430        93,  206,   50,  187,   78,  161,  176,  169,  183,  163,
 431       188,  209,  175,  210,  849,  849,  849,  849,  827,  230,
 432       236,  849,  849,  826,  249,  253,  836,  835,  105,  849,
 433       834,  805,  238,  800,  220,  211,  206,  849,  789,  849,
 434
 435         0,  824,  225,  823,  822,  849,  827,  849,  261,  787,
 436       849,  849,  254,  849,  825,  259,  270,  276,    0,  286,
 437       808,  807,  806,   17,  262,  243,  811,  811,  819,  280,
 438       791,  792,  271,   30,  214,  287,  288,  290,  292,   26,
 439       294,  293,  295,  178,  297,  296,  298,  302,  299,  303,
 440       849,  318,  322,  345,  849,  349,  849,  341,  353,  357,
 441       849,  361,  805,  849,  849,  849,  815,  849,  770,  776,
 442       762,  849,  783,  760,  849,  759,  772,  761,  783,  849,
 443       799,  798,  797,  849,  849,  802,  849,  771,  353,  800,
 444       849,  357,    0,  783,  782,  781,  338,   72,  342,  849,
 445
 446       374,  796,  849,  768,  365,  359,  365,  367,  368,  300,
 447       369,  371,  778,  372,  373,  374,  375,  377,  379,  378,
 448       380,  384,  382,  385,  388,  429,  849,  749,  278,  849,
 449       761,  849,  849,  744,  754,  767,  849,  849,  849,  751,
 450       771,  381,  770,  769,  433,  849,  399,  768,  394,  397,
 451       386,  767,  411,  766,  393,  418,  423,  424,  425,  431,
 452        87,  427,  428,  432,  765,  450,  849,  465,  469,  849,
 453       740,  747,  750,  734,    0,  730,  441,  435,  759,  442,
 454       758,  456,  437,  445,  460,  757,  461,  463,  464,  756,
 455       468,  469,  725,  715,  698,  710,  716,  686,  471,  470,
 456
 457       678,  472,  473,  475,  664,  651,  643,  580,  479,  477,
 458       451,  563,  550,  586,  560,  483,  484,  486,  575,  492,
 459       488,  574,  549,  553,  514,  508,  527,  570,  501,  559,
 460       496,  549,  522,  519,  532,  523,  540,  522,  534,  516,
 461       502,  546,  554,  849,  539,  423,  558,  546,  849,  371,
 462       564,  234,  568,  585,  541,  849,  849,  603,  611,  619,
 463       627,  635,  643,  651,  659,  667,  670,  674,  678,  686,
 464       694,  702,  710,  715,  718,  722,  729,  734,  741,  745,
 465       751,  758,  766
 466     } ;
 467
 468 static yyconst short int yy_def[384] =
 469     {   0,
 470       358,  358,  359,  359,  360,  360,  361,  361,  357,    9,
 471         9,   11,  362,  362,  363,  363,  364,  364,  357,  357,
 472       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 473       357,  357,  357,  357,  357,  357,  357,  357,  357,  365,
 474       357,  357,  357,  357,  357,  357,  357,  357,  366,  357,
 475       357,  357,  357,  367,  368,  368,  368,  368,  357,  357,
 476       357,  369,  368,  368,  368,  368,  368,  368,  368,  368,
 477       368,  368,  368,  368,  357,  357,  357,  357,  357,  357,
 478       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 479       370,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 480
 481       371,  357,  357,  357,  357,  357,  372,  357,  357,  357,
 482       357,  357,  357,  357,  373,  357,  357,  357,  374,  357,
 483       375,  368,  376,  368,  368,  368,  357,  357,  377,  357,
 484       378,  357,  368,  368,  368,  368,  368,  368,  368,  368,
 485       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
 486       357,  357,  357,  357,  357,  379,  357,  357,  357,  357,
 487       357,  357,  357,  357,  357,  357,  370,  357,  357,  357,
 488       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 489       357,  357,  357,  357,  357,  372,  357,  357,  357,  373,
 490       357,  357,  374,  375,  380,  376,  368,  368,  368,  357,
 491
 492       357,  377,  357,  378,  369,  368,  368,  368,  368,  368,
 493       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
 494       368,  368,  368,  368,  368,  381,  357,  357,  357,  357,
 495       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 496       380,  368,  368,  368,  357,  357,  368,  368,  368,  368,
 497       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
 498       368,  368,  368,  368,  368,  357,  357,  381,  357,  357,
 499       357,  357,  357,  357,  382,  357,  368,  368,  368,  368,
 500       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
 501       368,  368,  357,  357,  357,  357,  357,  357,  368,  368,
 502
 503       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
 504       357,  357,  357,  357,  357,  368,  368,  368,  368,  368,
 505       368,  368,  357,  357,  357,  357,  357,  368,  368,  368,
 506       368,  368,  357,  357,  357,  357,  357,  357,  368,  368,
 507       357,  357,  357,  357,  383,  357,  357,  383,  357,  357,
 508       357,  357,  357,  357,  357,  357,    0,  357,  357,  357,
 509       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 510       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 511       357,  357,  357
 512     } ;
 513
 514 static yyconst short int yy_nxt[904] =
 515     {   0,
 516       357,   21,   22,   23,   21,   26,   22,   23,   26,   30,
 517        31,   27,   90,   24,   91,   30,   31,   24,   32,   35,
 518        36,  106,   37,  107,   32,   38,   46,   47,  109,   48,
 519        39,  109,   25,   22,   78,  123,   25,   33,   46,   47,
 520       123,   48,   79,   93,  123,   40,   93,  197,  123,   28,
 521        22,   83,   49,   80,   22,   78,   80,   22,   88,   84,
 522       207,  124,  102,   81,   49,  110,   89,  123,  123,   41,
 523        42,   35,   36,  213,   37,   43,   44,   38,   85,   22,
 524        83,   85,   39,   22,   88,  103,   95,   94,   86,  114,
 525       123,  115,   89,   96,  125,  133,  123,   40,  123,   97,
 526
 527       113,  113,  113,  113,  128,  123,  129,  165,   98,  104,
 528       105,  116,  243,  120,  120,  120,  120,  126,  166,  289,
 529       137,   41,   42,   20,   21,   22,   23,   21,   20,   20,
 530        20,   20,   20,   20,   20,   50,   51,   52,   53,   53,
 531        53,   54,   20,   20,   55,   55,   55,   55,   55,   55,
 532        20,   20,   20,   55,   55,   56,   55,   55,   57,   55,
 533        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
 534        58,   55,   55,   55,   55,   59,   20,   60,   61,  123,
 535       116,  123,  117,  117,  117,  118,  127,  123,  113,  113,
 536       113,  113,   62,  123,  123,   63,  123,   64,   65,   66,
 537
 538        67,  123,  138,   68,   69,  123,  123,   70,   71,  218,
 539       140,   72,  142,   73,   74,  139,  148,   75,   76,  119,
 540       130,  130,  130,  130,  134,  141,  135,  123,  123,  136,
 541       181,  152,  123,  143,  152,  132,  144,  154,  155,   93,
 542       156,  153,   93,  176,  208,  173,  145,  146,  149,  151,
 543       158,  177,  150,  158,  160,  161,  147,  162,  174,  170,
 544       159,  123,  109,  175,  163,  109,  164,  171,  189,  189,
 545       189,  189,  172,  192,  192,  192,  192,  182,  183,  176,
 546       123,  199,  116,   94,  117,  117,  117,  118,  116,  123,
 547       118,  118,  118,  118,  130,  130,  130,  130,  116,  110,
 548
 549       120,  120,  120,  120,  198,  123,  123,  206,  123,  132,
 550       123,  123,  123,  123,  123,  123,  123,  123,  123,  152,
 551       123,  123,  152,  154,  155,  271,  156,  215,  209,  153,
 552       172,  251,  220,  216,  212,  214,  210,  217,  211,  219,
 553       222,  225,  158,  221,  224,  158,  154,  155,  223,  154,
 554       154,  155,  159,  154,  160,  161,  123,  162,  160,  161,
 555       123,  160,  160,  161,  163,  160,  227,  189,  189,  189,
 556       189,  192,  192,  192,  192,  245,  246,  123,  245,  130,
 557       130,  130,  130,  123,  242,  123,  123,  123,  244,  123,
 558       123,  123,  123,  123,  132,  123,  123,  123,  123,  123,
 559
 560       123,  253,  123,  123,  123,  352,  123,  247,  254,  252,
 561       248,  123,  123,  249,  250,  123,  258,  123,  255,  260,
 562       263,  265,  257,  256,  259,  280,  262,  244,  261,  123,
 563       266,  267,  264,  266,  245,  246,  123,  245,  282,  277,
 564       278,  123,  123,  123,  279,  123,  123,  269,  283,  123,
 565       123,  266,  267,  123,  266,  123,  350,  284,  281,  123,
 566       123,  287,  285,  123,  291,  288,  266,  267,  290,  266,
 567       266,  267,  286,  266,  123,  299,  301,  304,  123,  123,
 568       292,  123,  123,  269,  303,  300,  123,  123,  123,  123,
 569       123,  123,  305,  123,  302,  123,  307,  123,  323,  310,
 570
 571       306,  123,  123,  175,  123,  318,  123,  319,  317,  309,
 572       123,  308,  316,  321,  123,  335,  322,  329,  335,  123,
 573       330,  332,  320,  336,  337,  337,  331,  345,  338,  340,
 574       328,  338,  346,  335,  123,  339,  335,  343,  343,  343,
 575       343,  345,  355,  356,  349,  355,  342,  342,  342,  342,
 576       344,  349,  123,  341,  343,  343,  343,  343,  347,  349,
 577       342,  342,  342,  342,  344,  174,  349,  123,  343,  343,
 578       343,  343,  351,  351,  351,  351,  353,  123,  351,  351,
 579       351,  351,  354,  354,  354,  354,  355,  356,  123,  355,
 580       334,  333,  123,  123,  327,  326,  325,  324,  123,  354,
 581
 582       354,  354,  354,   20,   20,   20,   20,   20,   20,   20,
 583        20,   29,   29,   29,   29,   29,   29,   29,   29,   34,
 584        34,   34,   34,   34,   34,   34,   34,   45,   45,   45,
 585        45,   45,   45,   45,   45,   77,   77,   77,   77,   77,
 586        77,   77,   77,   82,   82,   82,   82,   82,   82,   82,
 587        82,   87,   87,   87,   87,   87,   87,   87,   87,  108,
 588       108,  123,  108,  108,  108,  108,  108,  112,  112,  123,
 589       112,  112,  112,  112,  112,  121,  121,  122,  122,  122,
 590       122,  131,  123,  131,  131,  131,  167,  167,  167,  167,
 591       167,  167,  167,  167,  179,  179,  123,  179,  179,  179,
 592
 593       179,  179,  186,  186,  186,  186,  186,  186,  186,  186,
 594       190,  190,  190,  190,  190,  190,  190,  190,  193,  315,
 595       193,  194,  194,  194,  194,  196,  196,  196,  196,  202,
 596       202,  202,  202,  202,  202,  202,  202,  204,  314,  204,
 597       204,  204,  226,  226,  313,  312,  226,  226,  241,  241,
 598       241,  241,  268,  268,  268,  268,  268,  268,  297,  297,
 599       311,  297,  297,  297,  297,  297,  348,  348,  171,  348,
 600       348,  348,  348,  348,  123,  123,  123,  123,  298,  296,
 601       295,  294,  293,  123,  123,  123,  123,  123,  123,  195,
 602       276,  275,  274,  273,  272,  270,  123,  132,  203,  123,
 603
 604       195,  195,  191,  240,  187,  239,  238,  237,  236,  235,
 605       234,  233,  232,  231,  230,  229,  228,  168,  227,  205,
 606       132,  203,  201,  200,  123,  123,  195,  191,  188,  187,
 607       185,  184,  180,  178,   99,  169,  168,  165,  165,  157,
 608       151,  123,  111,  101,  100,   99,   92,  357,   19,  357,
 609       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 610       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 611       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 612       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 613       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 614
 615       357,  357,  357
 616     } ;
 617
 618 static yyconst short int yy_chk[904] =
 619     {   0,
 620         0,    1,    1,    1,    1,    2,    2,    2,    2,    3,
 621         3,    2,   24,    1,   24,    4,    4,    2,    3,    5,
 622         5,   39,    5,   39,    4,    5,    7,    7,   43,    7,
 623         5,   43,    1,   13,   13,  124,    2,    4,    8,    8,
 624        56,    8,   13,   26,  140,    5,   26,  124,  134,    2,
 625        15,   15,    7,   14,   14,   14,   14,   17,   17,   15,
 626       134,   56,   38,   14,    8,   43,   17,   57,   63,    5,
 627         5,    6,    6,  140,    6,    6,    6,    6,   16,   16,
 628        16,   16,    6,   18,   18,   38,   27,   26,   16,   51,
 629       198,   51,   18,   27,   57,   63,   65,    6,   58,   27,
 630
 631        50,   50,   50,   50,   61,  261,   61,   89,   27,   38,
 632        38,   53,  198,   53,   53,   53,   53,   58,   89,  261,
 633        65,    6,    6,    9,    9,    9,    9,    9,    9,    9,
 634         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 635         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 636         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 637         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 638         9,    9,    9,    9,    9,    9,    9,   11,   11,   66,
 639        52,   70,   52,   52,   52,   52,   60,   68,   60,   60,
 640        60,   60,   11,   73,   67,   11,  144,   11,   11,   11,
 641
 642        11,   69,   66,   11,   11,   64,   71,   11,   11,  144,
 643        68,   11,   70,   11,   11,   67,   73,   11,   11,   52,
 644        62,   62,   62,   62,   64,   69,   64,   72,   74,   64,
 645       103,   80,  135,   71,   80,   62,   71,   81,   81,   93,
 646        81,   80,   93,   97,  135,   96,   72,   72,   74,   81,
 647        85,   97,   74,   85,   86,   86,   72,   86,   96,   95,
 648        85,  126,  109,   96,   86,  109,   86,   95,  113,  113,
 649       113,  113,   95,  116,  116,  116,  116,  103,  103,  352,
 650       125,  126,  117,   93,  117,  117,  117,  117,  118,  133,
 651       118,  118,  118,  118,  130,  130,  130,  130,  120,  109,
 652
 653       120,  120,  120,  120,  125,  136,  137,  133,  138,  130,
 654       139,  142,  141,  143,  146,  145,  147,  149,  210,  152,
 655       148,  150,  152,  153,  153,  229,  153,  142,  136,  152,
 656       229,  210,  146,  143,  139,  141,  137,  143,  138,  145,
 657       148,  150,  158,  147,  149,  158,  154,  154,  148,  154,
 658       156,  156,  158,  156,  159,  159,  197,  159,  160,  160,
 659       199,  160,  162,  162,  159,  162,  159,  189,  189,  189,
 660       189,  192,  192,  192,  192,  201,  201,  206,  201,  205,
 661       205,  205,  205,  207,  197,  208,  209,  211,  199,  212,
 662       214,  215,  216,  217,  205,  218,  220,  219,  221,  242,
 663
 664       223,  212,  222,  224,  251,  350,  225,  206,  214,  211,
 665       207,  255,  249,  208,  209,  250,  218,  247,  215,  220,
 666       223,  225,  217,  216,  219,  251,  222,  242,  221,  253,
 667       226,  226,  224,  226,  245,  245,  256,  245,  255,  247,
 668       249,  257,  258,  259,  250,  262,  263,  226,  256,  260,
 669       264,  266,  266,  278,  266,  283,  346,  257,  253,  277,
 670       280,  260,  258,  284,  263,  260,  268,  268,  262,  268,
 671       269,  269,  259,  269,  282,  277,  280,  284,  285,  287,
 672       264,  288,  289,  268,  283,  278,  291,  292,  300,  299,
 673       302,  303,  285,  304,  282,  310,  288,  309,  311,  292,
 674
 675       287,  316,  317,  311,  318,  302,  321,  303,  300,  291,
 676       320,  289,  299,  309,  331,  325,  310,  317,  325,  329,
 677       318,  321,  304,  326,  326,  326,  320,  338,  327,  331,
 678       316,  327,  341,  335,  340,  329,  335,  336,  336,  336,
 679       336,  338,  355,  355,  345,  355,  335,  335,  335,  335,
 680       337,  348,  339,  334,  337,  337,  337,  337,  342,  345,
 681       342,  342,  342,  342,  343,  333,  348,  332,  343,  343,
 682       343,  343,  347,  347,  347,  347,  351,  330,  351,  351,
 683       351,  351,  353,  353,  353,  353,  354,  354,  328,  354,
 684       324,  323,  322,  319,  315,  314,  313,  312,  308,  354,
 685
 686       354,  354,  354,  358,  358,  358,  358,  358,  358,  358,
 687       358,  359,  359,  359,  359,  359,  359,  359,  359,  360,
 688       360,  360,  360,  360,  360,  360,  360,  361,  361,  361,
 689       361,  361,  361,  361,  361,  362,  362,  362,  362,  362,
 690       362,  362,  362,  363,  363,  363,  363,  363,  363,  363,
 691       363,  364,  364,  364,  364,  364,  364,  364,  364,  365,
 692       365,  307,  365,  365,  365,  365,  365,  366,  366,  306,
 693       366,  366,  366,  366,  366,  367,  367,  368,  368,  368,
 694       368,  369,  305,  369,  369,  369,  370,  370,  370,  370,
 695       370,  370,  370,  370,  371,  371,  301,  371,  371,  371,
 696
 697       371,  371,  372,  372,  372,  372,  372,  372,  372,  372,
 698       373,  373,  373,  373,  373,  373,  373,  373,  374,  298,
 699       374,  375,  375,  375,  375,  376,  376,  376,  376,  377,
 700       377,  377,  377,  377,  377,  377,  377,  378,  297,  378,
 701       378,  378,  379,  379,  296,  295,  379,  379,  380,  380,
 702       380,  380,  381,  381,  381,  381,  381,  381,  382,  382,
 703       294,  382,  382,  382,  382,  382,  383,  383,  293,  383,
 704       383,  383,  383,  383,  290,  286,  281,  279,  276,  274,
 705       273,  272,  271,  265,  254,  252,  248,  244,  243,  241,
 706       240,  236,  235,  234,  231,  228,  213,  204,  202,  196,
 707
 708       195,  194,  190,  188,  186,  183,  182,  181,  179,  178,
 709       177,  176,  174,  173,  171,  170,  169,  167,  163,  132,
 710       131,  129,  128,  127,  123,  122,  121,  115,  110,  107,
 711       105,  104,  102,   99,   94,   92,   91,   88,   87,   84,
 712        79,   55,   44,   33,   32,   28,   25,   19,  357,  357,
 713       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 714       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 715       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 716       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 717       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
 718
 719       357,  357,  357
 720     } ;
 721
 722 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
 723 static char *yy_full_match;
 724 static int yy_lp;
 725 #define REJECT \
 726 { \
 727 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
 728 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
 729 ++yy_lp; \
 730 goto find_rule; \
 731 }
 732 #define yymore() yymore_used_but_not_detected
 733 #define YY_MORE_ADJ 0
 734 #define YY_RESTORE_YY_MORE_OFFSET
 735 char *yytext;
 736 #line 1 "lexer.l"
 737 #define INITIAL 0
 738 /* GOB C Preprocessor
 739  * Copyright (C) 1999 the Free Software Foundation.
 740  *
 741  * Author: George Lebl
 742  *
 743  * This program is free software; you can redistribute it and/or modify
 744  * it under the terms of the GNU General Public License as published by
 745  * the Free Software Foundation; either version 2 of the License, or
 746  * (at your option) any later version.
 747  *
 748  * This program is distributed in the hope that it will be useful,
 749  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 750  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 751  * GNU General Public License for more details.
 752  *
 753  * You should have received a copy of the GNU General Public License
 754  * along with this program; if not, write to the  Free Software
 755  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 756  * USA.
 757  */
 758 #line 22 "lexer.l"
 759
 760 #include "config.h"
 761 #include <glib.h>
 762 #include <string.h>
 763
 764 #include "treefuncs.h"
 765 #include "parse.h"
 766 #include "main.h"
 767 #include "util.h"
 768
 769 static int parenth_depth = 0;
 770 static int before_comment = INITIAL;
 771 static gboolean class_after_c = FALSE;
 772 static int code_type = CCODE;
 773
 774 /* GTK+ doc stuff */
 775 static char *gtk_doc_func = NULL; /* current gtk-doc func */
 776 GHashTable *gtk_doc_hash = NULL;
 777
 778 static GString *cbuf = NULL;
 779 int ccode_line = 1;
 780
 781 GList *include_files = NULL;
 782 /* 0 no, 1 means yes, 2+ means don't even start looking anymore */
 783 static int look_for_includes = 0;
 784
 785 int line_no = 1;
 786
 787 static void
 788 clear_cbuf(void)
 789 {
 790         if(!cbuf) {
 791                 cbuf = g_string_new(NULL);
 792         } else {
 793                 cbuf = g_string_assign(cbuf, "");
 794         }
 795 }
 796
 797 static void
 798 add_to_cbuf(char *s)
 799 {
 800         if(!cbuf) {
 801                 cbuf = g_string_new(s);
 802         } else {
 803                 cbuf = g_string_append(cbuf,s);
 804         }
 805 }
 806
 807 static void
 808 add_gtk_doc_func(void)
 809 {
 810         if(!gtk_doc_func)
 811                 return;
 812
 813         if(!gtk_doc_hash)
 814                 gtk_doc_hash = g_hash_table_new(g_str_hash, g_str_equal);
 815         g_hash_table_insert(gtk_doc_hash, gtk_doc_func, g_strdup(cbuf->str));
 816         clear_cbuf();
 817
 818         gtk_doc_func = NULL;
 819 }
 820
 821 /* Ugly warning avoiding */
 822 #ifdef FLEX_SCANNER
 823 int yylex(void);
 824 #endif
 825
 826 #define COMMENT 1
 827
 828 #define C_CODE 2
 829
 830 #define C_CODE_STRING 3
 831
 832 #define CLASS_CODE 4
 833
 834 #define CLASS_CODE_I 5
 835
 836 #define GTK_DOC_BEFORE_NAME 6
 837
 838 #define GTK_DOC 7
 839
 840 #define GTK_DOC_LINE 8
 841
 842 #line 843 "lex.yy.c"
 843
 844 /* Macros after this point can all be overridden by user definitions in
 845  * section 1.
 846  */
 847
 848 #ifndef YY_SKIP_YYWRAP
 849 #ifdef __cplusplus
 850 extern "C" int yywrap YY_PROTO(( void ));
 851 #else
 852 extern int yywrap YY_PROTO(( void ));
 853 #endif
 854 #endif
 855
 856 #ifndef YY_NO_UNPUT
 857 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 858 #endif
 859
 860 #ifndef yytext_ptr
 861 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 862 #endif
 863
 864 #ifdef YY_NEED_STRLEN
 865 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 866 #endif
 867
 868 #ifndef YY_NO_INPUT
 869 #ifdef __cplusplus
 870 static int yyinput YY_PROTO(( void ));
 871 #else
 872 static int input YY_PROTO(( void ));
 873 #endif
 874 #endif
 875
 876 #if YY_STACK_USED
 877 static int yy_start_stack_ptr = 0;
 878 static int yy_start_stack_depth = 0;
 879 static int *yy_start_stack = 0;
 880 #ifndef YY_NO_PUSH_STATE
 881 static void yy_push_state YY_PROTO(( int new_state ));
 882 #endif
 883 #ifndef YY_NO_POP_STATE
 884 static void yy_pop_state YY_PROTO(( void ));
 885 #endif
 886 #ifndef YY_NO_TOP_STATE
 887 static int yy_top_state YY_PROTO(( void ));
 888 #endif
 889
 890 #else
 891 #define YY_NO_PUSH_STATE 1
 892 #define YY_NO_POP_STATE 1
 893 #define YY_NO_TOP_STATE 1
 894 #endif
 895
 896 #ifdef YY_MALLOC_DECL
 897 YY_MALLOC_DECL
 898 #else
 899 #if __STDC__
 900 #ifndef __cplusplus
 901 #include <stdlib.h>
 902 #endif
 903 #else
 904 /* Just try to get by without declaring the routines.  This will fail
 905  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 906  * or sizeof(void*) != sizeof(int).
 907  */
 908 #endif
 909 #endif
 910
 911 /* Amount of stuff to slurp up with each read. */
 912 #ifndef YY_READ_BUF_SIZE
 913 #define YY_READ_BUF_SIZE 8192
 914 #endif
 915
 916 /* Copy whatever the last rule matched to the standard output. */
 917
 918 #ifndef ECHO
 919 /* This used to be an fputs(), but since the string might contain NUL's,
 920  * we now use fwrite().
 921  */
 922 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 923 #endif
 924
 925 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 926  * is returned in "result".
 927  */
 928 #ifndef YY_INPUT
 929 #define YY_INPUT(buf,result,max_size) \
 930         if ( yy_current_buffer->yy_is_interactive ) \
 931                 { \
 932                 int c = '*', n; \
 933                 for ( n = 0; n < max_size && \
 934                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 935                         buf[n] = (char) c; \
 936                 if ( c == '\n' ) \
 937                         buf[n++] = (char) c; \
 938                 if ( c == EOF && ferror( yyin ) ) \
 939                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 940                 result = n; \
 941                 } \
 942         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 943                   && ferror( yyin ) ) \
 944                 YY_FATAL_ERROR( "input in flex scanner failed" );
 945 #endif
 946
 947 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 948  * we don't want an extra ';' after the "return" because that will cause
 949  * some compilers to complain about unreachable statements.
 950  */
 951 #ifndef yyterminate
 952 #define yyterminate() return YY_NULL
 953 #endif
 954
 955 /* Number of entries by which start-condition stack grows. */
 956 #ifndef YY_START_STACK_INCR
 957 #define YY_START_STACK_INCR 25
 958 #endif
 959
 960 /* Report a fatal error. */
 961 #ifndef YY_FATAL_ERROR
 962 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 963 #endif
 964
 965 /* Default declaration of generated scanner - a define so the user can
 966  * easily add parameters.
 967  */
 968 #ifndef YY_DECL
 969 #define YY_DECL int yylex YY_PROTO(( void ))
 970 #endif
 971
 972 /* Code executed at the beginning of each rule, after yytext and yyleng
 973  * have been set up.
 974  */
 975 #ifndef YY_USER_ACTION
 976 #define YY_USER_ACTION
 977 #endif
 978
 979 /* Code executed at the end of each rule. */
 980 #ifndef YY_BREAK
 981 #define YY_BREAK break;
 982 #endif
 983
 984 #define YY_RULE_SETUP \
 985         if ( yyleng > 0 ) \
 986                 yy_current_buffer->yy_at_bol = \
 987                                 (yytext[yyleng - 1] == '\n'); \
 988         YY_USER_ACTION
 989
 990 YY_DECL
 991         {
 992         register yy_state_type yy_current_state;
 993         register char *yy_cp = NULL, *yy_bp = NULL;
 994         register int yy_act;
 995
 996 #line 102 "lexer.l"
 997
 998
 999 #line 1000 "lex.yy.c"
1000
1001         if ( yy_init )
1002                 {
1003                 yy_init = 0;
1004
1005 #ifdef YY_USER_INIT
1006                 YY_USER_INIT;
1007 #endif
1008
1009                 if ( ! yy_start )
1010                         yy_start = 1;   /* first start state */
1011
1012                 if ( ! yyin )
1013                         yyin = stdin;
1014
1015                 if ( ! yyout )
1016                         yyout = stdout;
1017
1018                 if ( ! yy_current_buffer )
1019                         yy_current_buffer =
1020                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1021
1022                 yy_load_buffer_state();
1023                 }
1024
1025         while ( 1 )             /* loops until end-of-file is reached */
1026                 {
1027                 yy_cp = yy_c_buf_p;
1028
1029                 /* Support of yytext. */
1030                 *yy_cp = yy_hold_char;
1031
1032                 /* yy_bp points to the position in yy_ch_buf of the start of
1033                  * the current run.
1034                  */
1035                 yy_bp = yy_cp;
1036
1037                 yy_current_state = yy_start;
1038                 yy_current_state += YY_AT_BOL();
1039                 yy_state_ptr = yy_state_buf;
1040                 *yy_state_ptr++ = yy_current_state;
1041 yy_match:
1042                 do
1043                         {
1044                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1045                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1046                                 {
1047                                 yy_current_state = (int) yy_def[yy_current_state];
1048                                 if ( yy_current_state >= 358 )
1049                                         yy_c = yy_meta[(unsigned int) yy_c];
1050                                 }
1051                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1052                         *yy_state_ptr++ = yy_current_state;
1053                         ++yy_cp;
1054                         }
1055                 while ( yy_base[yy_current_state] != 849 );
1056
1057 yy_find_action:
1058                 yy_current_state = *--yy_state_ptr;
1059                 yy_lp = yy_accept[yy_current_state];
1060 find_rule: /* we branch to this label when backing up */
1061                 for ( ; ; ) /* until we find what rule we matched */
1062                         {
1063                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1064                                 {
1065                                 yy_act = yy_acclist[yy_lp];
1066                                         {
1067                                         yy_full_match = yy_cp;
1068                                         break;
1069                                         }
1070                                 }
1071                         --yy_cp;
1072                         yy_current_state = *--yy_state_ptr;
1073                         yy_lp = yy_accept[yy_current_state];
1074                         }
1075
1076                 YY_DO_BEFORE_ACTION;
1077
1078
1079 do_action:      /* This label is used only to access EOF actions. */
1080
1081
1082                 switch ( yy_act )
1083         { /* beginning of action switch */
1084 case 1:
1085 YY_RULE_SETUP
1086 #line 104 "lexer.l"
1087 { line_no++; REJECT; }
1088         YY_BREAK
1089 case 2:
1090 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1091 yy_c_buf_p = yy_cp -= 1;
1092 YY_DO_BEFORE_ACTION; /* set up yytext again */
1093 YY_RULE_SETUP
1094 #line 106 "lexer.l"
1095 {
1096 /* Thy evil easter egg */
1097 #define QQ(x) long x
1098 #define KK(x) =atoi(__(&,,x,))
1099 #define MM(x,a) {QQ(i);for(i=2;i<x;i++){a}}
1100 #define PP(Q) (P%Q)==0
1101 #define ___(x,y,z) if(x z y)
1102 #define __(a,x,y,z) a(yytext[y] x z)
1103 #define O__O(a,b) fprintf(stderr,"%s is %s!\n",a,b)
1104 QQ(m)=1;___(__(,==,2,'P'),__(,==,5,'M'),&&
1105 ){QQ(P)KK(8);MM(P,___(PP(i),,)m=0;)}__(,=,
1106 7,0);___(,,m){O__O(__( &,,8,),__(&,,2,));}
1107 #undef QQ
1108 #undef KK
1109 #undef MM
1110 #undef PP
1111 #undef ___
1112 #undef __
1113 #undef O__O
1114 REJECT;
1115 }
1116         YY_BREAK
1117 case 3:
1118 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1119 yy_c_buf_p = yy_cp -= 1;
1120 YY_DO_BEFORE_ACTION; /* set up yytext again */
1121 YY_RULE_SETUP
1122 #line 128 "lexer.l"
1123 { ; /*comment, ignore*/ }
1124         YY_BREAK
1125 case 4:
1126 YY_RULE_SETUP
1127 #line 129 "lexer.l"
1128 {
1129         if(look_for_includes==1) {
1130                 char *p;
1131                 char *file;
1132                 char *str = g_strdup(yytext);
1133                 file = strchr(str,'"');
1134                 if(!file) file = strchr(str,'<');
1135                 file++;
1136                 p = strchr(file,'"');
1137                 if(!p) p = strchr(file,'>');
1138                 *p = '\0';
1139                 include_files = g_list_prepend(include_files,g_strdup(file));
1140                 g_free(str);
1141         }
1142         REJECT;
1143 }
1144         YY_BREAK
1145 case 5:
1146 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1147 yy_c_buf_p = yy_cp -= 1;
1148 YY_DO_BEFORE_ACTION; /* set up yytext again */
1149 YY_RULE_SETUP
1150 #line 146 "lexer.l"
1151 {
1152                         /* eat out gtk doc stuff */
1153                         BEGIN(GTK_DOC_BEFORE_NAME);
1154                         clear_cbuf();
1155                 }
1156         YY_BREAK
1157 case 6:
1158 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1159 yy_c_buf_p = yy_cp -= 1;
1160 YY_DO_BEFORE_ACTION; /* set up yytext again */
1161 YY_RULE_SETUP
1162 #line 151 "lexer.l"
1163 {
1164                         /* empty doc lines */
1165                         ;
1166                 }
1167         YY_BREAK
1168 case 7:
1169 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1170 yy_c_buf_p = yy_cp -= 1;
1171 YY_DO_BEFORE_ACTION; /* set up yytext again */
1172 YY_RULE_SETUP
1173 #line 155 "lexer.l"
1174 {
1175                         char *p;
1176                         BEGIN(GTK_DOC);
1177                         p = strchr(yytext, '*');
1178                         g_free(gtk_doc_func);
1179                         gtk_doc_func = g_strdup(p+2);
1180                         p = strchr(gtk_doc_func, ':');
1181                         if(p) *p='\0';
1182                         g_strstrip(gtk_doc_func);
1183                 }
1184         YY_BREAK
1185 case 8:
1186 YY_RULE_SETUP
1187 #line 165 "lexer.l"
1188 {
1189                         BEGIN(CLASS_CODE_I);
1190                 }
1191         YY_BREAK
1192 case 9:
1193 YY_RULE_SETUP
1194 #line 168 "lexer.l"
1195 {
1196                         BEGIN(COMMENT);
1197                         before_comment = CLASS_CODE_I;
1198                 }
1199         YY_BREAK
1200 case 10:
1201 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1202 yy_c_buf_p = yy_cp -= 1;
1203 YY_DO_BEFORE_ACTION; /* set up yytext again */
1204 YY_RULE_SETUP
1205 #line 172 "lexer.l"
1206 {
1207                         /* empty doc lines */
1208                         add_to_cbuf(" *\n");
1209                 }
1210         YY_BREAK
1211 case 11:
1212 YY_RULE_SETUP
1213 #line 176 "lexer.l"
1214 {
1215                         BEGIN(CLASS_CODE_I);
1216                         add_gtk_doc_func();
1217                 }
1218         YY_BREAK
1219 case 12:
1220 YY_RULE_SETUP
1221 #line 180 "lexer.l"
1222 {
1223                         fflush(stdout);
1224                         add_to_cbuf(" * ");
1225                         BEGIN(GTK_DOC_LINE);
1226                 }
1227         YY_BREAK
1228 case 13:
1229 YY_RULE_SETUP
1230 #line 185 "lexer.l"
1231 {
1232                         BEGIN(CLASS_CODE_I);
1233                 }
1234         YY_BREAK
1235 case 14:
1236 YY_RULE_SETUP
1237 #line 188 "lexer.l"
1238 {
1239                         BEGIN(COMMENT);
1240                         before_comment = CLASS_CODE_I;
1241                 }
1242         YY_BREAK
1243 case 15:
1244 YY_RULE_SETUP
1245 #line 192 "lexer.l"
1246 {
1247                         BEGIN(CLASS_CODE_I);
1248                         add_to_cbuf("\n");
1249                         add_gtk_doc_func();
1250                 }
1251         YY_BREAK
1252 case 16:
1253 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1254 yy_c_buf_p = yy_cp -= 1;
1255 YY_DO_BEFORE_ACTION; /* set up yytext again */
1256 YY_RULE_SETUP
1257 #line 197 "lexer.l"
1258 {
1259                         BEGIN(GTK_DOC);
1260                         add_to_cbuf(yytext);
1261                         add_to_cbuf("\n");
1262                 }
1263         YY_BREAK
1264 case 17:
1265 YY_RULE_SETUP
1266 #line 202 "lexer.l"
1267 {
1268                         fflush(stdout);
1269                         add_to_cbuf(yytext);
1270                 }
1271         YY_BREAK
1272 case 18:
1273 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1274 yy_c_buf_p = yy_cp -= 1;
1275 YY_DO_BEFORE_ACTION; /* set up yytext again */
1276 YY_RULE_SETUP
1277 #line 207 "lexer.l"
1278 { add_to_cbuf(yytext); /*comment, ignore*/ }
1279         YY_BREAK
1280 case 19:
1281 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1282 yy_c_buf_p = yy_cp -= 1;
1283 YY_DO_BEFORE_ACTION; /* set up yytext again */
1284 YY_RULE_SETUP
1285 #line 208 "lexer.l"
1286 { ; /*comment, ignore*/ }
1287         YY_BREAK
1288 case 20:
1289 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1290 yy_c_buf_p = yy_cp -= 1;
1291 YY_DO_BEFORE_ACTION; /* set up yytext again */
1292 YY_RULE_SETUP
1293 #line 209 "lexer.l"
1294 { ; /*comment, ignore*/ }
1295         YY_BREAK
1296 case 21:
1297 YY_RULE_SETUP
1298 #line 210 "lexer.l"
1299 {BEGIN(COMMENT); before_comment = INITIAL; }
1300         YY_BREAK
1301 case 22:
1302 YY_RULE_SETUP
1303 #line 211 "lexer.l"
1304 {
1305         add_to_cbuf(yytext);
1306         BEGIN(COMMENT);
1307         before_comment = C_CODE;
1308 }
1309         YY_BREAK
1310 case 23:
1311 YY_RULE_SETUP
1312 #line 216 "lexer.l"
1313 {BEGIN(COMMENT); before_comment = CLASS_CODE; }
1314         YY_BREAK
1315 case 24:
1316 YY_RULE_SETUP
1317 #line 217 "lexer.l"
1318 {BEGIN(COMMENT); before_comment = CLASS_CODE_I; }
1319         YY_BREAK
1320 case 25:
1321 YY_RULE_SETUP
1322 #line 218 "lexer.l"
1323 {
1324         if(before_comment == C_CODE) add_to_cbuf(yytext);
1325         BEGIN(before_comment);
1326                 }
1327         YY_BREAK
1328 case 26:
1329 YY_RULE_SETUP
1330 #line 222 "lexer.l"
1331 {
1332         /* comment, ignore */
1333         if(before_comment == C_CODE) add_to_cbuf(yytext);
1334                 }
1335         YY_BREAK
1336 case 27:
1337 YY_RULE_SETUP
1338 #line 226 "lexer.l"
1339 {
1340         /* comment, ignore */
1341         if(before_comment == C_CODE) add_to_cbuf(yytext);
1342                 }
1343         YY_BREAK
1344 case 28:
1345 YY_RULE_SETUP
1346 #line 231 "lexer.l"
1347 {
1348                         BEGIN(C_CODE);
1349                         parenth_depth = 1;
1350                         class_after_c = FALSE;
1351                         code_type = ACODE;
1352                         clear_cbuf();
1353                         ccode_line = line_no;
1354                 }
1355         YY_BREAK
1356 case 29:
1357 YY_RULE_SETUP
1358 #line 239 "lexer.l"
1359 {
1360                         BEGIN(C_CODE);
1361                         parenth_depth = 1;
1362                         class_after_c = FALSE;
1363                         code_type = ATCODE;
1364                         clear_cbuf();
1365                         ccode_line = line_no;
1366                 }
1367         YY_BREAK
1368 case 30:
1369 YY_RULE_SETUP
1370 #line 248 "lexer.l"
1371 {
1372                         BEGIN(C_CODE);
1373                         parenth_depth = 1;
1374                         class_after_c = FALSE;
1375                         code_type = HTCODE;
1376                         clear_cbuf();
1377                         ccode_line = line_no;
1378                 }
1379         YY_BREAK
1380 case 31:
1381 YY_RULE_SETUP
1382 #line 256 "lexer.l"
1383 {
1384                         BEGIN(C_CODE);
1385                         parenth_depth = 1;
1386                         class_after_c = FALSE;
1387                         code_type = PHCODE;
1388                         clear_cbuf();
1389                         ccode_line = line_no;
1390                 }
1391         YY_BREAK
1392 case 32:
1393 YY_RULE_SETUP
1394 #line 264 "lexer.l"
1395 {
1396                         BEGIN(C_CODE);
1397                         parenth_depth = 1;
1398                         class_after_c = FALSE;
1399                         code_type = HCODE;
1400                         clear_cbuf();
1401                         ccode_line = line_no;
1402                 }
1403         YY_BREAK
1404 case 33:
1405 YY_RULE_SETUP
1406 #line 272 "lexer.l"
1407 {
1408                         BEGIN(C_CODE);
1409                         parenth_depth = 1;
1410                         class_after_c = FALSE;
1411                         code_type = CCODE;
1412                         clear_cbuf();
1413                         ccode_line = line_no;
1414                         if(look_for_includes==0)
1415                                 look_for_includes=1;
1416                 }
1417         YY_BREAK
1418 case 34:
1419 YY_RULE_SETUP
1420 #line 282 "lexer.l"
1421 {
1422                         BEGIN(INITIAL);
1423                         yylval.cbuf = cbuf;
1424                         cbuf = NULL;
1425                         if(look_for_includes==1)
1426                                 look_for_includes=0;
1427                         return code_type;
1428                 }
1429         YY_BREAK
1430 case 35:
1431 YY_RULE_SETUP
1432 #line 291 "lexer.l"
1433 { add_to_cbuf(yytext); }
1434         YY_BREAK
1435 case 36:
1436 YY_RULE_SETUP
1437 #line 292 "lexer.l"
1438 { add_to_cbuf(yytext); }
1439         YY_BREAK
1440 case 37:
1441 YY_RULE_SETUP
1442 #line 293 "lexer.l"
1443 { add_to_cbuf(yytext); }
1444         YY_BREAK
1445 case 38:
1446 YY_RULE_SETUP
1447 #line 294 "lexer.l"
1448 { add_to_cbuf(yytext); }
1449         YY_BREAK
1450 case 39:
1451 YY_RULE_SETUP
1452 #line 295 "lexer.l"
1453 { add_to_cbuf(yytext); }
1454         YY_BREAK
1455 case 40:
1456 YY_RULE_SETUP
1457 #line 296 "lexer.l"
1458 { add_to_cbuf(yytext); }
1459         YY_BREAK
1460 case 41:
1461 YY_RULE_SETUP
1462 #line 298 "lexer.l"
1463 { add_to_cbuf(yytext); }
1464         YY_BREAK
1465 case 42:
1466 YY_RULE_SETUP
1467 #line 299 "lexer.l"
1468 {
1469                         BEGIN(C_CODE_STRING);
1470                         add_to_cbuf(yytext);
1471                 }
1472         YY_BREAK
1473 case 43:
1474 YY_RULE_SETUP
1475 #line 303 "lexer.l"
1476 { add_to_cbuf(yytext); }
1477         YY_BREAK
1478 case 44:
1479 YY_RULE_SETUP
1480 #line 304 "lexer.l"
1481 {
1482                                 BEGIN(C_CODE);
1483                                 add_to_cbuf(yytext);
1484                         }
1485         YY_BREAK
1486 case 45:
1487 YY_RULE_SETUP
1488 #line 308 "lexer.l"
1489 { add_to_cbuf(yytext); }
1490         YY_BREAK
1491 case 46:
1492 YY_RULE_SETUP
1493 #line 309 "lexer.l"
1494 { add_to_cbuf(yytext); }
1495         YY_BREAK
1496 case 47:
1497 YY_RULE_SETUP
1498 #line 311 "lexer.l"
1499 {
1500                         parenth_depth++;
1501                         add_to_cbuf(yytext);
1502                 }
1503         YY_BREAK
1504 case 48:
1505 YY_RULE_SETUP
1506 #line 315 "lexer.l"
1507 {
1508                         parenth_depth--;
1509                         if(parenth_depth<0) {
1510                                 REJECT;
1511                         } else if(parenth_depth==0 && class_after_c) {
1512                                 BEGIN(CLASS_CODE_I);
1513                                 yylval.cbuf = cbuf;
1514                                 cbuf = NULL;
1515                                 return CCODE;
1516                         }
1517                         add_to_cbuf(yytext);
1518                 }
1519         YY_BREAK
1520 case 49:
1521 YY_RULE_SETUP
1522 #line 328 "lexer.l"
1523 { add_to_cbuf(yytext); }
1524         YY_BREAK
1525 case 50:
1526 YY_RULE_SETUP
1527 #line 329 "lexer.l"
1528 { add_to_cbuf(yytext); }
1529         YY_BREAK
1530 case 51:
1531 YY_RULE_SETUP
1532 #line 331 "lexer.l"
1533 {
1534                         static int found_classes = 0;
1535                         look_for_includes = 2;
1536                         BEGIN(CLASS_CODE);
1537
1538                         if(++found_classes > 1) {
1539                                 error_print(GOB_ERROR, line_no,
1540                                             "Only one class per file allowed");
1541                         }
1542
1543                         return CLASS;
1544                 }
1545         YY_BREAK
1546 case 52:
1547 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1548 yy_c_buf_p = yy_cp -= 1;
1549 YY_DO_BEFORE_ACTION; /* set up yytext again */
1550 YY_RULE_SETUP
1551 #line 344 "lexer.l"
1552 {
1553                         int maj = 0,min = 0,pl = 0;
1554                         int rmaj = 0,rmin = 0,rpl = 0;
1555                         int effective_maj = 0;
1556                         int effective_rmaj = 0;
1557                         char *p;
1558
1559                         sscanf(VERSION,"%d.%d.%d",&rmaj,&rmin,&rpl);
1560                         effective_rmaj = rmaj;
1561                         if (rmin >= 90)
1562                                 effective_rmaj = rmaj + 1;
1563
1564                         p = strchr(yytext,'r');
1565                         g_assert(p); /* we MUST have found it */
1566                         sscanf(p,"requires %d.%d.%d",&maj,&min,&pl);
1567                         effective_maj = maj;
1568                         if (min >= 90)
1569                                 effective_maj = maj + 1;
1570
1571                         if(rmaj < maj ||
1572                            (rmaj == maj && rmin < min) ||
1573                            (rmaj == maj && rmin == min && rpl < pl)) {
1574                                 error_printf(GOB_ERROR, line_no,
1575                                              "GOB version at least %d.%d.%d required "
1576                                              "(this is %s)\n"
1577                                              "To upgrade your gob, see: "
1578                                              "http://www.5z.com/jirka/gob.html",
1579                                              maj, min, pl, VERSION);
1580                         }
1581
1582                         if(effective_rmaj != effective_maj) {
1583                                 error_printf(GOB_ERROR, line_no,
1584                                              "GOB major version %d required "
1585                                              "(this is %s)\n"
1586                                              "To upgrade your gob, see: "
1587                                              "http://www.5z.com/jirka/gob.html",
1588                                              maj, VERSION);
1589                         }
1590                 }
1591         YY_BREAK
1592 case 53:
1593 YY_RULE_SETUP
1594 #line 384 "lexer.l"
1595 {
1596                         if(for_cpp) {
1597                                 error_printf(GOB_WARN, line_no,
1598                                              "'%s' keyword should not "
1599                                              "be used when generating "
1600                                              "C++ code", yytext);
1601                         }
1602                         REJECT;
1603                 }
1604         YY_BREAK
1605 case 54:
1606 YY_RULE_SETUP
1607 #line 394 "lexer.l"
1608 {return FROM;}
1609         YY_BREAK
1610 case 55:
1611 YY_RULE_SETUP
1612 #line 396 "lexer.l"
1613 {return VOID;}
1614         YY_BREAK
1615 case 56:
1616 YY_RULE_SETUP
1617 #line 397 "lexer.l"
1618 {return STRUCT;}
1619         YY_BREAK
1620 case 57:
1621 YY_RULE_SETUP
1622 #line 398 "lexer.l"
1623 {return UNION;}
1624         YY_BREAK
1625 case 58:
1626 YY_RULE_SETUP
1627 #line 399 "lexer.l"
1628 {return ENUM;}
1629         YY_BREAK
1630 case 59:
1631 YY_RULE_SETUP
1632 #line 400 "lexer.l"
1633 {return SIGNED;}
1634         YY_BREAK
1635 case 60:
1636 YY_RULE_SETUP
1637 #line 401 "lexer.l"
1638 {return UNSIGNED;}
1639         YY_BREAK
1640 case 61:
1641 YY_RULE_SETUP
1642 #line 402 "lexer.l"
1643 {return LONG;}
1644         YY_BREAK
1645 case 62:
1646 YY_RULE_SETUP
1647 #line 403 "lexer.l"
1648 {return SHORT;}
1649         YY_BREAK
1650 case 63:
1651 YY_RULE_SETUP
1652 #line 404 "lexer.l"
1653 {return INT;}
1654         YY_BREAK
1655 case 64:
1656 YY_RULE_SETUP
1657 #line 405 "lexer.l"
1658 {return FLOAT;}
1659         YY_BREAK
1660 case 65:
1661 YY_RULE_SETUP
1662 #line 406 "lexer.l"
1663 {return DOUBLE;}
1664         YY_BREAK
1665 case 66:
1666 YY_RULE_SETUP
1667 #line 407 "lexer.l"
1668 {return CHAR;}
1669         YY_BREAK
1670 case 67:
1671 YY_RULE_SETUP
1672 #line 408 "lexer.l"
1673 {return CONST;}
1674         YY_BREAK
1675 case 68:
1676 YY_RULE_SETUP
1677 #line 410 "lexer.l"
1678 {return THREEDOTS;}
1679         YY_BREAK
1680 case 69:
1681 YY_RULE_SETUP
1682 #line 412 "lexer.l"
1683 {yylval.line = line_no; return PUBLIC;}
1684         YY_BREAK
1685 case 70:
1686 YY_RULE_SETUP
1687 #line 413 "lexer.l"
1688 {yylval.line = line_no; return PRIVATE;}
1689         YY_BREAK
1690 case 71:
1691 YY_RULE_SETUP
1692 #line 414 "lexer.l"
1693 {yylval.line = line_no; return PROTECTED;}
1694         YY_BREAK
1695 case 72:
1696 YY_RULE_SETUP
1697 #line 415 "lexer.l"
1698 {yylval.line = line_no; return CLASSWIDE;}
1699         YY_BREAK
1700 case 73:
1701 YY_RULE_SETUP
1702 #line 416 "lexer.l"
1703 {yylval.line = line_no; return ARGUMENT;}
1704         YY_BREAK
1705 case 74:
1706 YY_RULE_SETUP
1707 #line 417 "lexer.l"
1708 {yylval.line = line_no; return VIRTUAL;}
1709         YY_BREAK
1710 case 75:
1711 YY_RULE_SETUP
1712 #line 418 "lexer.l"
1713 {yylval.line = line_no; return SIGNAL;}
1714         YY_BREAK
1715 case 76:
1716 YY_RULE_SETUP
1717 #line 419 "lexer.l"
1718 {yylval.line = line_no; return OVERRIDE;}
1719         YY_BREAK
1720 case 77:
1721 YY_RULE_SETUP
1722 #line 420 "lexer.l"
1723 {
1724                         yylval.id = g_strdup(yytext);
1725                         return NUMBER;
1726                 }
1727         YY_BREAK
1728 case 78:
1729 YY_RULE_SETUP
1730 #line 424 "lexer.l"
1731 {
1732                         /* this one is for a classname with a namespace */
1733                         yylval.id = g_strdup(yytext);
1734                         return TYPETOKEN;
1735                 }
1736         YY_BREAK
1737 case 79:
1738 YY_RULE_SETUP
1739 #line 429 "lexer.l"
1740 {
1741                         /* this is for a classname with an empty namespace */
1742                         yylval.id = g_strdup(yytext);
1743                         return TYPETOKEN;
1744                 }
1745         YY_BREAK
1746 case 80:
1747 YY_RULE_SETUP
1748 #line 434 "lexer.l"
1749 {
1750                         yylval.id = g_strdup(yytext);
1751                         return TOKEN;
1752                 }
1753         YY_BREAK
1754 case 81:
1755 YY_RULE_SETUP
1756 #line 439 "lexer.l"
1757 {
1758                         yylval.id = g_strdup(yytext);
1759                         return ARRAY_DIM;
1760                 }
1761         YY_BREAK
1762 case 82:
1763 YY_RULE_SETUP
1764 #line 444 "lexer.l"
1765 {
1766                         BEGIN(CLASS_CODE_I);
1767                         return '{';
1768                 }
1769         YY_BREAK
1770 case 83:
1771 YY_RULE_SETUP
1772 #line 448 "lexer.l"
1773 {
1774                         BEGIN(C_CODE);
1775                         parenth_depth=1;
1776                         class_after_c = TRUE;
1777                         yylval.line = line_no;
1778                         clear_cbuf();
1779                         ccode_line = line_no;
1780                         return '{';
1781                 }
1782         YY_BREAK
1783 case 84:
1784 YY_RULE_SETUP
1785 #line 457 "lexer.l"
1786 {
1787                                 BEGIN(INITIAL);
1788                                 return '}';
1789                         }
1790         YY_BREAK
1791 case 85:
1792 YY_RULE_SETUP
1793 #line 462 "lexer.l"
1794 ;  /*ignore*/
1795         YY_BREAK
1796 case 86:
1797 YY_RULE_SETUP
1798 #line 464 "lexer.l"
1799 {
1800                         yylval.line = line_no;
1801                         return yytext[0];
1802                 }
1803         YY_BREAK
1804 case 87:
1805 YY_RULE_SETUP
1806 #line 469 "lexer.l"
1807 ;  /*ignore*/
1808         YY_BREAK
1809 case 88:
1810 YY_RULE_SETUP
1811 #line 471 "lexer.l"
1812 ECHO;
1813         YY_BREAK
1814 #line 1815 "lex.yy.c"
1815                         case YY_STATE_EOF(INITIAL):
1816                         case YY_STATE_EOF(COMMENT):
1817                         case YY_STATE_EOF(C_CODE):
1818                         case YY_STATE_EOF(C_CODE_STRING):
1819                         case YY_STATE_EOF(CLASS_CODE):
1820                         case YY_STATE_EOF(CLASS_CODE_I):
1821                         case YY_STATE_EOF(GTK_DOC_BEFORE_NAME):
1822                         case YY_STATE_EOF(GTK_DOC):
1823                         case YY_STATE_EOF(GTK_DOC_LINE):
1824                                 yyterminate();
1825
1826         case YY_END_OF_BUFFER:
1827                 {
1828                 /* Amount of text matched not including the EOB char. */
1829                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1830
1831                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1832                 *yy_cp = yy_hold_char;
1833                 YY_RESTORE_YY_MORE_OFFSET
1834
1835                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1836                         {
1837                         /* We're scanning a new file or input source.  It's
1838                          * possible that this happened because the user
1839                          * just pointed yyin at a new source and called
1840                          * yylex().  If so, then we have to assure
1841                          * consistency between yy_current_buffer and our
1842                          * globals.  Here is the right place to do so, because
1843                          * this is the first action (other than possibly a
1844                          * back-up) that will match for the new input source.
1845                          */
1846                         yy_n_chars = yy_current_buffer->yy_n_chars;
1847                         yy_current_buffer->yy_input_file = yyin;
1848                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1849                         }
1850
1851                 /* Note that here we test for yy_c_buf_p "<=" to the position
1852                  * of the first EOB in the buffer, since yy_c_buf_p will
1853                  * already have been incremented past the NUL character
1854                  * (since all states make transitions on EOB to the
1855                  * end-of-buffer state).  Contrast this with the test
1856                  * in input().
1857                  */
1858                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1859                         { /* This was really a NUL. */
1860                         yy_state_type yy_next_state;
1861
1862                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1863
1864                         yy_current_state = yy_get_previous_state();
1865
1866                         /* Okay, we're now positioned to make the NUL
1867                          * transition.  We couldn't have
1868                          * yy_get_previous_state() go ahead and do it
1869                          * for us because it doesn't know how to deal
1870                          * with the possibility of jamming (and we don't
1871                          * want to build jamming into it because then it
1872                          * will run more slowly).
1873                          */
1874
1875                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1876
1877                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1878
1879                         if ( yy_next_state )
1880                                 {
1881                                 /* Consume the NUL. */
1882                                 yy_cp = ++yy_c_buf_p;
1883                                 yy_current_state = yy_next_state;
1884                                 goto yy_match;
1885                                 }
1886
1887                         else
1888                                 {
1889                                 yy_cp = yy_c_buf_p;
1890                                 goto yy_find_action;
1891                                 }
1892                         }
1893
1894                 else switch ( yy_get_next_buffer() )
1895                         {
1896                         case EOB_ACT_END_OF_FILE:
1897                                 {
1898                                 yy_did_buffer_switch_on_eof = 0;
1899
1900                                 if ( yywrap() )
1901                                         {
1902                                         /* Note: because we've taken care in
1903                                          * yy_get_next_buffer() to have set up
1904                                          * yytext, we can now set up
1905                                          * yy_c_buf_p so that if some total
1906                                          * hoser (like flex itself) wants to
1907                                          * call the scanner after we return the
1908                                          * YY_NULL, it'll still work - another
1909                                          * YY_NULL will get returned.
1910                                          */
1911                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1912
1913                                         yy_act = YY_STATE_EOF(YY_START);
1914                                         goto do_action;
1915                                         }
1916
1917                                 else
1918                                         {
1919                                         if ( ! yy_did_buffer_switch_on_eof )
1920                                                 YY_NEW_FILE;
1921                                         }
1922                                 break;
1923                                 }
1924
1925                         case EOB_ACT_CONTINUE_SCAN:
1926                                 yy_c_buf_p =
1927                                         yytext_ptr + yy_amount_of_matched_text;
1928
1929                                 yy_current_state = yy_get_previous_state();
1930
1931                                 yy_cp = yy_c_buf_p;
1932                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1933                                 goto yy_match;
1934
1935                         case EOB_ACT_LAST_MATCH:
1936                                 yy_c_buf_p =
1937                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1938
1939                                 yy_current_state = yy_get_previous_state();
1940
1941                                 yy_cp = yy_c_buf_p;
1942                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1943                                 goto yy_find_action;
1944                         }
1945                 break;
1946                 }
1947
1948         default:
1949                 YY_FATAL_ERROR(
1950                         "fatal flex scanner internal error--no action found" );
1951         } /* end of action switch */
1952                 } /* end of scanning one token */
1953         } /* end of yylex */
1954
1955
1956 /* yy_get_next_buffer - try to read in a new buffer
1957  *
1958  * Returns a code representing an action:
1959  *      EOB_ACT_LAST_MATCH -
1960  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1961  *      EOB_ACT_END_OF_FILE - end of file
1962  */
1963
1964 static int yy_get_next_buffer()
1965         {
1966         register char *dest = yy_current_buffer->yy_ch_buf;
1967         register char *source = yytext_ptr;
1968         register int number_to_move, i;
1969         int ret_val;
1970
1971         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1972                 YY_FATAL_ERROR(
1973                 "fatal flex scanner internal error--end of buffer missed" );
1974
1975         if ( yy_current_buffer->yy_fill_buffer == 0 )
1976                 { /* Don't try to fill the buffer, so this is an EOF. */
1977                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1978                         {
1979                         /* We matched a single character, the EOB, so
1980                          * treat this as a final EOF.
1981                          */
1982                         return EOB_ACT_END_OF_FILE;
1983                         }
1984
1985                 else
1986                         {
1987                         /* We matched some text prior to the EOB, first
1988                          * process it.
1989                          */
1990                         return EOB_ACT_LAST_MATCH;
1991                         }
1992                 }
1993
1994         /* Try to read more data. */
1995
1996         /* First move last chars to start of buffer. */
1997         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1998
1999         for ( i = 0; i < number_to_move; ++i )
2000                 *(dest++) = *(source++);
2001
2002         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2003                 /* don't do the read, it's not guaranteed to return an EOF,
2004                  * just force an EOF
2005                  */
2006                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2007
2008         else
2009                 {
2010                 int num_to_read =
2011                         yy_current_buffer->yy_buf_size - number_to_move - 1;
2012
2013                 while ( num_to_read <= 0 )
2014                         { /* Not enough room in the buffer - grow it. */
2015 #ifdef YY_USES_REJECT
2016                         YY_FATAL_ERROR(
2017 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2018 #else
2019
2020                         /* just a shorter name for the current buffer */
2021                         YY_BUFFER_STATE b = yy_current_buffer;
2022
2023                         int yy_c_buf_p_offset =
2024                                 (int) (yy_c_buf_p - b->yy_ch_buf);
2025
2026                         if ( b->yy_is_our_buffer )
2027                                 {
2028                                 int new_size = b->yy_buf_size * 2;
2029
2030                                 if ( new_size <= 0 )
2031                                         b->yy_buf_size += b->yy_buf_size / 8;
2032                                 else
2033                                         b->yy_buf_size *= 2;
2034
2035                                 b->yy_ch_buf = (char *)
2036                                         /* Include room in for 2 EOB chars. */
2037                                         yy_flex_realloc( (void *) b->yy_ch_buf,
2038                                                          b->yy_buf_size + 2 );
2039                                 }
2040                         else
2041                                 /* Can't grow it, we don't own it. */
2042                                 b->yy_ch_buf = 0;
2043
2044                         if ( ! b->yy_ch_buf )
2045                                 YY_FATAL_ERROR(
2046                                 "fatal error - scanner input buffer overflow" );
2047
2048                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2049
2050                         num_to_read = yy_current_buffer->yy_buf_size -
2051                                                 number_to_move - 1;
2052 #endif
2053                         }
2054
2055                 if ( num_to_read > YY_READ_BUF_SIZE )
2056                         num_to_read = YY_READ_BUF_SIZE;
2057
2058                 /* Read in more data. */
2059                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2060                         yy_n_chars, num_to_read );
2061
2062                 yy_current_buffer->yy_n_chars = yy_n_chars;
2063                 }
2064
2065         if ( yy_n_chars == 0 )
2066                 {
2067                 if ( number_to_move == YY_MORE_ADJ )
2068                         {
2069                         ret_val = EOB_ACT_END_OF_FILE;
2070                         yyrestart( yyin );
2071                         }
2072
2073                 else
2074                         {
2075                         ret_val = EOB_ACT_LAST_MATCH;
2076                         yy_current_buffer->yy_buffer_status =
2077                                 YY_BUFFER_EOF_PENDING;
2078                         }
2079                 }
2080
2081         else
2082                 ret_val = EOB_ACT_CONTINUE_SCAN;
2083
2084         yy_n_chars += number_to_move;
2085         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2086         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2087
2088         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2089
2090         return ret_val;
2091         }
2092
2093
2094 /* yy_get_previous_state - get the state just before the EOB char was reached */
2095
2096 static yy_state_type yy_get_previous_state()
2097         {
2098         register yy_state_type yy_current_state;
2099         register char *yy_cp;
2100
2101         yy_current_state = yy_start;
2102         yy_current_state += YY_AT_BOL();
2103         yy_state_ptr = yy_state_buf;
2104         *yy_state_ptr++ = yy_current_state;
2105
2106         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2107                 {
2108                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2109                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2110                         {
2111                         yy_current_state = (int) yy_def[yy_current_state];
2112                         if ( yy_current_state >= 358 )
2113                                 yy_c = yy_meta[(unsigned int) yy_c];
2114                         }
2115                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2116                 *yy_state_ptr++ = yy_current_state;
2117                 }
2118
2119         return yy_current_state;
2120         }
2121
2122
2123 /* yy_try_NUL_trans - try to make a transition on the NUL character
2124  *
2125  * synopsis
2126  *      next_state = yy_try_NUL_trans( current_state );
2127  */
2128
2129 #ifdef YY_USE_PROTOS
2130 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2131 #else
2132 static yy_state_type yy_try_NUL_trans( yy_current_state )
2133 yy_state_type yy_current_state;
2134 #endif
2135         {
2136         register int yy_is_jam;
2137
2138         register YY_CHAR yy_c = 1;
2139         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2140                 {
2141                 yy_current_state = (int) yy_def[yy_current_state];
2142                 if ( yy_current_state >= 358 )
2143                         yy_c = yy_meta[(unsigned int) yy_c];
2144                 }
2145         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2146         yy_is_jam = (yy_current_state == 357);
2147         if ( ! yy_is_jam )
2148                 *yy_state_ptr++ = yy_current_state;
2149
2150         return yy_is_jam ? 0 : yy_current_state;
2151         }
2152
2153
2154 #ifndef YY_NO_UNPUT
2155 #ifdef YY_USE_PROTOS
2156 static void yyunput( int c, register char *yy_bp )
2157 #else
2158 static void yyunput( c, yy_bp )
2159 int c;
2160 register char *yy_bp;
2161 #endif
2162         {
2163         register char *yy_cp = yy_c_buf_p;
2164
2165         /* undo effects of setting up yytext */
2166         *yy_cp = yy_hold_char;
2167
2168         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2169                 { /* need to shift things up to make room */
2170                 /* +2 for EOB chars. */
2171                 register int number_to_move = yy_n_chars + 2;
2172                 register char *dest = &yy_current_buffer->yy_ch_buf[
2173                                         yy_current_buffer->yy_buf_size + 2];
2174                 register char *source =
2175                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2176
2177                 while ( source > yy_current_buffer->yy_ch_buf )
2178                         *--dest = *--source;
2179
2180                 yy_cp += (int) (dest - source);
2181                 yy_bp += (int) (dest - source);
2182                 yy_current_buffer->yy_n_chars =
2183                         yy_n_chars = yy_current_buffer->yy_buf_size;
2184
2185                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2186                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2187                 }
2188
2189         *--yy_cp = (char) c;
2190
2191
2192         yytext_ptr = yy_bp;
2193         yy_hold_char = *yy_cp;
2194         yy_c_buf_p = yy_cp;
2195         }
2196 #endif  /* ifndef YY_NO_UNPUT */
2197
2198
2199 #ifdef __cplusplus
2200 static int yyinput()
2201 #else
2202 static int input()
2203 #endif
2204         {
2205         int c;
2206
2207         *yy_c_buf_p = yy_hold_char;
2208
2209         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2210                 {
2211                 /* yy_c_buf_p now points to the character we want to return.
2212                  * If this occurs *before* the EOB characters, then it's a
2213                  * valid NUL; if not, then we've hit the end of the buffer.
2214                  */
2215                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2216                         /* This was really a NUL. */
2217                         *yy_c_buf_p = '\0';
2218
2219                 else
2220                         { /* need more input */
2221                         int offset = yy_c_buf_p - yytext_ptr;
2222                         ++yy_c_buf_p;
2223
2224                         switch ( yy_get_next_buffer() )
2225                                 {
2226                                 case EOB_ACT_LAST_MATCH:
2227                                         /* This happens because yy_g_n_b()
2228                                          * sees that we've accumulated a
2229                                          * token and flags that we need to
2230                                          * try matching the token before
2231                                          * proceeding.  But for input(),
2232                                          * there's no matching to consider.
2233                                          * So convert the EOB_ACT_LAST_MATCH
2234                                          * to EOB_ACT_END_OF_FILE.
2235                                          */
2236
2237                                         /* Reset buffer status. */
2238                                         yyrestart( yyin );
2239
2240                                         /* fall through */
2241
2242                                 case EOB_ACT_END_OF_FILE:
2243                                         {
2244                                         if ( yywrap() )
2245                                                 return EOF;
2246
2247                                         if ( ! yy_did_buffer_switch_on_eof )
2248                                                 YY_NEW_FILE;
2249 #ifdef __cplusplus
2250                                         return yyinput();
2251 #else
2252                                         return input();
2253 #endif
2254                                         }
2255
2256                                 case EOB_ACT_CONTINUE_SCAN:
2257                                         yy_c_buf_p = yytext_ptr + offset;
2258                                         break;
2259                                 }
2260                         }
2261                 }
2262
2263         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2264         *yy_c_buf_p = '\0';     /* preserve yytext */
2265         yy_hold_char = *++yy_c_buf_p;
2266
2267         yy_current_buffer->yy_at_bol = (c == '\n');
2268
2269         return c;
2270         }
2271
2272
2273 #ifdef YY_USE_PROTOS
2274 void yyrestart( FILE *input_file )
2275 #else
2276 void yyrestart( input_file )
2277 FILE *input_file;
2278 #endif
2279         {
2280         if ( ! yy_current_buffer )
2281                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2282
2283         yy_init_buffer( yy_current_buffer, input_file );
2284         yy_load_buffer_state();
2285         }
2286
2287
2288 #ifdef YY_USE_PROTOS
2289 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2290 #else
2291 void yy_switch_to_buffer( new_buffer )
2292 YY_BUFFER_STATE new_buffer;
2293 #endif
2294         {
2295         if ( yy_current_buffer == new_buffer )
2296                 return;
2297
2298         if ( yy_current_buffer )
2299                 {
2300                 /* Flush out information for old buffer. */
2301                 *yy_c_buf_p = yy_hold_char;
2302                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2303                 yy_current_buffer->yy_n_chars = yy_n_chars;
2304                 }
2305
2306         yy_current_buffer = new_buffer;
2307         yy_load_buffer_state();
2308
2309         /* We don't actually know whether we did this switch during
2310          * EOF (yywrap()) processing, but the only time this flag
2311          * is looked at is after yywrap() is called, so it's safe
2312          * to go ahead and always set it.
2313          */
2314         yy_did_buffer_switch_on_eof = 1;
2315         }
2316
2317
2318 #ifdef YY_USE_PROTOS
2319 void yy_load_buffer_state( void )
2320 #else
2321 void yy_load_buffer_state()
2322 #endif
2323         {
2324         yy_n_chars = yy_current_buffer->yy_n_chars;
2325         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2326         yyin = yy_current_buffer->yy_input_file;
2327         yy_hold_char = *yy_c_buf_p;
2328         }
2329
2330
2331 #ifdef YY_USE_PROTOS
2332 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2333 #else
2334 YY_BUFFER_STATE yy_create_buffer( file, size )
2335 FILE *file;
2336 int size;
2337 #endif
2338         {
2339         YY_BUFFER_STATE b;
2340
2341         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2342         if ( ! b )
2343                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2344
2345         b->yy_buf_size = size;
2346
2347         /* yy_ch_buf has to be 2 characters longer than the size given because
2348          * we need to put in 2 end-of-buffer characters.
2349          */
2350         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2351         if ( ! b->yy_ch_buf )
2352                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2353
2354         b->yy_is_our_buffer = 1;
2355
2356         yy_init_buffer( b, file );
2357
2358         return b;
2359         }
2360
2361
2362 #ifdef YY_USE_PROTOS
2363 void yy_delete_buffer( YY_BUFFER_STATE b )
2364 #else
2365 void yy_delete_buffer( b )
2366 YY_BUFFER_STATE b;
2367 #endif
2368         {
2369         if ( ! b )
2370                 return;
2371
2372         if ( b == yy_current_buffer )
2373                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2374
2375         if ( b->yy_is_our_buffer )
2376                 yy_flex_free( (void *) b->yy_ch_buf );
2377
2378         yy_flex_free( (void *) b );
2379         }
2380
2381
2382
2383 #ifdef YY_USE_PROTOS
2384 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2385 #else
2386 void yy_init_buffer( b, file )
2387 YY_BUFFER_STATE b;
2388 FILE *file;
2389 #endif
2390
2391
2392         {
2393         yy_flush_buffer( b );
2394
2395         b->yy_input_file = file;
2396         b->yy_fill_buffer = 1;
2397
2398 #if YY_ALWAYS_INTERACTIVE
2399         b->yy_is_interactive = 1;
2400 #else
2401 #if YY_NEVER_INTERACTIVE
2402         b->yy_is_interactive = 0;
2403 #else
2404         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2405 #endif
2406 #endif
2407         }
2408
2409
2410 #ifdef YY_USE_PROTOS
2411 void yy_flush_buffer( YY_BUFFER_STATE b )
2412 #else
2413 void yy_flush_buffer( b )
2414 YY_BUFFER_STATE b;
2415 #endif
2416
2417         {
2418         if ( ! b )
2419                 return;
2420
2421         b->yy_n_chars = 0;
2422
2423         /* We always need two end-of-buffer characters.  The first causes
2424          * a transition to the end-of-buffer state.  The second causes
2425          * a jam in that state.
2426          */
2427         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2428         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2429
2430         b->yy_buf_pos = &b->yy_ch_buf[0];
2431
2432         b->yy_at_bol = 1;
2433         b->yy_buffer_status = YY_BUFFER_NEW;
2434
2435         if ( b == yy_current_buffer )
2436                 yy_load_buffer_state();
2437         }
2438
2439
2440 #ifndef YY_NO_SCAN_BUFFER
2441 #ifdef YY_USE_PROTOS
2442 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2443 #else
2444 YY_BUFFER_STATE yy_scan_buffer( base, size )
2445 char *base;
2446 yy_size_t size;
2447 #endif
2448         {
2449         YY_BUFFER_STATE b;
2450
2451         if ( size < 2 ||
2452              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2453              base[size-1] != YY_END_OF_BUFFER_CHAR )
2454                 /* They forgot to leave room for the EOB's. */
2455                 return 0;
2456
2457         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2458         if ( ! b )
2459                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2460
2461         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2462         b->yy_buf_pos = b->yy_ch_buf = base;
2463         b->yy_is_our_buffer = 0;
2464         b->yy_input_file = 0;
2465         b->yy_n_chars = b->yy_buf_size;
2466         b->yy_is_interactive = 0;
2467         b->yy_at_bol = 1;
2468         b->yy_fill_buffer = 0;
2469         b->yy_buffer_status = YY_BUFFER_NEW;
2470
2471         yy_switch_to_buffer( b );
2472
2473         return b;
2474         }
2475 #endif
2476
2477
2478 #ifndef YY_NO_SCAN_STRING
2479 #ifdef YY_USE_PROTOS
2480 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2481 #else
2482 YY_BUFFER_STATE yy_scan_string( yy_str )
2483 yyconst char *yy_str;
2484 #endif
2485         {
2486         int len;
2487         for ( len = 0; yy_str[len]; ++len )
2488                 ;
2489
2490         return yy_scan_bytes( yy_str, len );
2491         }
2492 #endif
2493
2494
2495 #ifndef YY_NO_SCAN_BYTES
2496 #ifdef YY_USE_PROTOS
2497 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2498 #else
2499 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2500 yyconst char *bytes;
2501 int len;
2502 #endif
2503         {
2504         YY_BUFFER_STATE b;
2505         char *buf;
2506         yy_size_t n;
2507         int i;
2508
2509         /* Get memory for full buffer, including space for trailing EOB's. */
2510         n = len + 2;
2511         buf = (char *) yy_flex_alloc( n );
2512         if ( ! buf )
2513                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2514
2515         for ( i = 0; i < len; ++i )
2516                 buf[i] = bytes[i];
2517
2518         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2519
2520         b = yy_scan_buffer( buf, n );
2521         if ( ! b )
2522                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2523
2524         /* It's okay to grow etc. this buffer, and we should throw it
2525          * away when we're done.
2526          */
2527         b->yy_is_our_buffer = 1;
2528
2529         return b;
2530         }
2531 #endif
2532
2533
2534 #ifndef YY_NO_PUSH_STATE
2535 #ifdef YY_USE_PROTOS
2536 static void yy_push_state( int new_state )
2537 #else
2538 static void yy_push_state( new_state )
2539 int new_state;
2540 #endif
2541         {
2542         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2543                 {
2544                 yy_size_t new_size;
2545
2546                 yy_start_stack_depth += YY_START_STACK_INCR;
2547                 new_size = yy_start_stack_depth * sizeof( int );
2548
2549                 if ( ! yy_start_stack )
2550                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2551
2552                 else
2553                         yy_start_stack = (int *) yy_flex_realloc(
2554                                         (void *) yy_start_stack, new_size );
2555
2556                 if ( ! yy_start_stack )
2557                         YY_FATAL_ERROR(
2558                         "out of memory expanding start-condition stack" );
2559                 }
2560
2561         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2562
2563         BEGIN(new_state);
2564         }
2565 #endif
2566
2567
2568 #ifndef YY_NO_POP_STATE
2569 static void yy_pop_state()
2570         {
2571         if ( --yy_start_stack_ptr < 0 )
2572                 YY_FATAL_ERROR( "start-condition stack underflow" );
2573
2574         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2575         }
2576 #endif
2577
2578
2579 #ifndef YY_NO_TOP_STATE
2580 static int yy_top_state()
2581         {
2582         return yy_start_stack[yy_start_stack_ptr - 1];
2583         }
2584 #endif
2585
2586 #ifndef YY_EXIT_FAILURE
2587 #define YY_EXIT_FAILURE 2
2588 #endif
2589
2590 #ifdef YY_USE_PROTOS
2591 static void yy_fatal_error( yyconst char msg[] )
2592 #else
2593 static void yy_fatal_error( msg )
2594 char msg[];
2595 #endif
2596         {
2597         (void) fprintf( stderr, "%s\n", msg );
2598         exit( YY_EXIT_FAILURE );
2599         }
2600
2601
2602
2603 /* Redefine yyless() so it works in section 3 code. */
2604
2605 #undef yyless
2606 #define yyless(n) \
2607         do \
2608                 { \
2609                 /* Undo effects of setting up yytext. */ \
2610                 yytext[yyleng] = yy_hold_char; \
2611                 yy_c_buf_p = yytext + n; \
2612                 yy_hold_char = *yy_c_buf_p; \
2613                 *yy_c_buf_p = '\0'; \
2614                 yyleng = n; \
2615                 } \
2616         while ( 0 )
2617
2618
2619 /* Internal utility routines. */
2620
2621 #ifndef yytext_ptr
2622 #ifdef YY_USE_PROTOS
2623 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2624 #else
2625 static void yy_flex_strncpy( s1, s2, n )
2626 char *s1;
2627 yyconst char *s2;
2628 int n;
2629 #endif
2630         {
2631         register int i;
2632         for ( i = 0; i < n; ++i )
2633                 s1[i] = s2[i];
2634         }
2635 #endif
2636
2637 #ifdef YY_NEED_STRLEN
2638 #ifdef YY_USE_PROTOS
2639 static int yy_flex_strlen( yyconst char *s )
2640 #else
2641 static int yy_flex_strlen( s )
2642 yyconst char *s;
2643 #endif
2644         {
2645         register int n;
2646         for ( n = 0; s[n]; ++n )
2647                 ;
2648
2649         return n;
2650         }
2651 #endif
2652
2653
2654 #ifdef YY_USE_PROTOS
2655 static void *yy_flex_alloc( yy_size_t size )
2656 #else
2657 static void *yy_flex_alloc( size )
2658 yy_size_t size;
2659 #endif
2660         {
2661         return (void *) malloc( size );
2662         }
2663
2664 #ifdef YY_USE_PROTOS
2665 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2666 #else
2667 static void *yy_flex_realloc( ptr, size )
2668 void *ptr;
2669 yy_size_t size;
2670 #endif
2671         {
2672         /* The cast to (char *) in the following accommodates both
2673          * implementations that use char* generic pointers, and those
2674          * that use void* generic pointers.  It works with the latter
2675          * because both ANSI C and C++ allow castless assignment from
2676          * any pointer type to void*, and deal with argument conversions
2677          * as though doing an assignment.
2678          */
2679         return (void *) realloc( (char *) ptr, size );
2680         }
2681
2682 #ifdef YY_USE_PROTOS
2683 static void yy_flex_free( void *ptr )
2684 #else
2685 static void yy_flex_free( ptr )
2686 void *ptr;
2687 #endif
2688         {
2689         free( ptr );
2690         }
2691
2692 #if YY_MAIN
2693 int main()
2694         {
2695         yylex();
2696         return 0;
2697         }
2698 #endif
2699 #line 471 "lexer.l"
2700
2701
2702 /* Ugly warning avoiding */
2703 #ifdef FLEX_SCANNER
2704 static void warning_avoider(void) G_GNUC_UNUSED;
2705 static void warning_avoider(void) {
2706         yy_flex_realloc(NULL, 0);
2707         yyunput(0, NULL);
2708         warning_avoider();
2709 }
2710 #endif
2711