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
  13
  14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15 #ifdef c_plusplus
  16 #ifndef __cplusplus
  17 #define __cplusplus
  18 #endif
  19 #endif
  20
  21
  22 #ifdef __cplusplus
  23
  24 #include <stdlib.h>
  25 #include <unistd.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                         char *p;
1556
1557                         sscanf(VERSION,"%d.%d.%d",&rmaj,&rmin,&rpl);
1558                         p = strchr(yytext,'r');
1559                         g_assert(p); /* we MUST have found it */
1560                         sscanf(p,"requires %d.%d.%d",&maj,&min,&pl);
1561                         if(rmaj < maj ||
1562                            (rmaj == maj && rmin < min) ||
1563                            (rmaj == maj && rmin == min && rpl < pl)) {
1564                                 error_printf(GOB_ERROR, line_no,
1565                                              "GOB version %d.%d.%d required "
1566                                              "(this is %s)\n"
1567                                              "To upgrade your gob, see: "
1568                                              "http://www.5z.com/jirka/gob.html",
1569                                              maj, min, pl, VERSION);
1570                         }
1571                 }
1572         YY_BREAK
1573 case 53:
1574 YY_RULE_SETUP
1575 #line 365 "lexer.l"
1576 {
1577                         if(for_cpp) {
1578                                 error_printf(GOB_WARN, line_no,
1579                                              "'%s' keyword should not "
1580                                              "be used when generating "
1581                                              "C++ code", yytext);
1582                         }
1583                         REJECT;
1584                 }
1585         YY_BREAK
1586 case 54:
1587 YY_RULE_SETUP
1588 #line 375 "lexer.l"
1589 {return FROM;}
1590         YY_BREAK
1591 case 55:
1592 YY_RULE_SETUP
1593 #line 377 "lexer.l"
1594 {return VOID;}
1595         YY_BREAK
1596 case 56:
1597 YY_RULE_SETUP
1598 #line 378 "lexer.l"
1599 {return STRUCT;}
1600         YY_BREAK
1601 case 57:
1602 YY_RULE_SETUP
1603 #line 379 "lexer.l"
1604 {return UNION;}
1605         YY_BREAK
1606 case 58:
1607 YY_RULE_SETUP
1608 #line 380 "lexer.l"
1609 {return ENUM;}
1610         YY_BREAK
1611 case 59:
1612 YY_RULE_SETUP
1613 #line 381 "lexer.l"
1614 {return SIGNED;}
1615         YY_BREAK
1616 case 60:
1617 YY_RULE_SETUP
1618 #line 382 "lexer.l"
1619 {return UNSIGNED;}
1620         YY_BREAK
1621 case 61:
1622 YY_RULE_SETUP
1623 #line 383 "lexer.l"
1624 {return LONG;}
1625         YY_BREAK
1626 case 62:
1627 YY_RULE_SETUP
1628 #line 384 "lexer.l"
1629 {return SHORT;}
1630         YY_BREAK
1631 case 63:
1632 YY_RULE_SETUP
1633 #line 385 "lexer.l"
1634 {return INT;}
1635         YY_BREAK
1636 case 64:
1637 YY_RULE_SETUP
1638 #line 386 "lexer.l"
1639 {return FLOAT;}
1640         YY_BREAK
1641 case 65:
1642 YY_RULE_SETUP
1643 #line 387 "lexer.l"
1644 {return DOUBLE;}
1645         YY_BREAK
1646 case 66:
1647 YY_RULE_SETUP
1648 #line 388 "lexer.l"
1649 {return CHAR;}
1650         YY_BREAK
1651 case 67:
1652 YY_RULE_SETUP
1653 #line 389 "lexer.l"
1654 {return CONST;}
1655         YY_BREAK
1656 case 68:
1657 YY_RULE_SETUP
1658 #line 391 "lexer.l"
1659 {return THREEDOTS;}
1660         YY_BREAK
1661 case 69:
1662 YY_RULE_SETUP
1663 #line 393 "lexer.l"
1664 {yylval.line = line_no; return PUBLIC;}
1665         YY_BREAK
1666 case 70:
1667 YY_RULE_SETUP
1668 #line 394 "lexer.l"
1669 {yylval.line = line_no; return PRIVATE;}
1670         YY_BREAK
1671 case 71:
1672 YY_RULE_SETUP
1673 #line 395 "lexer.l"
1674 {yylval.line = line_no; return PROTECTED;}
1675         YY_BREAK
1676 case 72:
1677 YY_RULE_SETUP
1678 #line 396 "lexer.l"
1679 {yylval.line = line_no; return CLASSWIDE;}
1680         YY_BREAK
1681 case 73:
1682 YY_RULE_SETUP
1683 #line 397 "lexer.l"
1684 {yylval.line = line_no; return ARGUMENT;}
1685         YY_BREAK
1686 case 74:
1687 YY_RULE_SETUP
1688 #line 398 "lexer.l"
1689 {yylval.line = line_no; return VIRTUAL;}
1690         YY_BREAK
1691 case 75:
1692 YY_RULE_SETUP
1693 #line 399 "lexer.l"
1694 {yylval.line = line_no; return SIGNAL;}
1695         YY_BREAK
1696 case 76:
1697 YY_RULE_SETUP
1698 #line 400 "lexer.l"
1699 {yylval.line = line_no; return OVERRIDE;}
1700         YY_BREAK
1701 case 77:
1702 YY_RULE_SETUP
1703 #line 401 "lexer.l"
1704 {
1705                         yylval.id = g_strdup(yytext);
1706                         return NUMBER;
1707                 }
1708         YY_BREAK
1709 case 78:
1710 YY_RULE_SETUP
1711 #line 405 "lexer.l"
1712 {
1713                         /* this one is for a classname with a namespace */
1714                         yylval.id = g_strdup(yytext);
1715                         return TYPETOKEN;
1716                 }
1717         YY_BREAK
1718 case 79:
1719 YY_RULE_SETUP
1720 #line 410 "lexer.l"
1721 {
1722                         /* this is for a classname with an empty namespace */
1723                         yylval.id = g_strdup(yytext);
1724                         return TYPETOKEN;
1725                 }
1726         YY_BREAK
1727 case 80:
1728 YY_RULE_SETUP
1729 #line 415 "lexer.l"
1730 {
1731                         yylval.id = g_strdup(yytext);
1732                         return TOKEN;
1733                 }
1734         YY_BREAK
1735 case 81:
1736 YY_RULE_SETUP
1737 #line 420 "lexer.l"
1738 {
1739                         yylval.id = g_strdup(yytext);
1740                         return ARRAY_DIM;
1741                 }
1742         YY_BREAK
1743 case 82:
1744 YY_RULE_SETUP
1745 #line 425 "lexer.l"
1746 {
1747                         BEGIN(CLASS_CODE_I);
1748                         return '{';
1749                 }
1750         YY_BREAK
1751 case 83:
1752 YY_RULE_SETUP
1753 #line 429 "lexer.l"
1754 {
1755                         BEGIN(C_CODE);
1756                         parenth_depth=1;
1757                         class_after_c = TRUE;
1758                         yylval.line = line_no;
1759                         clear_cbuf();
1760                         ccode_line = line_no;
1761                         return '{';
1762                 }
1763         YY_BREAK
1764 case 84:
1765 YY_RULE_SETUP
1766 #line 438 "lexer.l"
1767 {
1768                                 BEGIN(INITIAL);
1769                                 return '}';
1770                         }
1771         YY_BREAK
1772 case 85:
1773 YY_RULE_SETUP
1774 #line 443 "lexer.l"
1775 ;  /*ignore*/
1776         YY_BREAK
1777 case 86:
1778 YY_RULE_SETUP
1779 #line 445 "lexer.l"
1780 {
1781                         yylval.line = line_no;
1782                         return yytext[0];
1783                 }
1784         YY_BREAK
1785 case 87:
1786 YY_RULE_SETUP
1787 #line 450 "lexer.l"
1788 ;  /*ignore*/
1789         YY_BREAK
1790 case 88:
1791 YY_RULE_SETUP
1792 #line 452 "lexer.l"
1793 ECHO;
1794         YY_BREAK
1795 #line 1796 "lex.yy.c"
1796                         case YY_STATE_EOF(INITIAL):
1797                         case YY_STATE_EOF(COMMENT):
1798                         case YY_STATE_EOF(C_CODE):
1799                         case YY_STATE_EOF(C_CODE_STRING):
1800                         case YY_STATE_EOF(CLASS_CODE):
1801                         case YY_STATE_EOF(CLASS_CODE_I):
1802                         case YY_STATE_EOF(GTK_DOC_BEFORE_NAME):
1803                         case YY_STATE_EOF(GTK_DOC):
1804                         case YY_STATE_EOF(GTK_DOC_LINE):
1805                                 yyterminate();
1806
1807         case YY_END_OF_BUFFER:
1808                 {
1809                 /* Amount of text matched not including the EOB char. */
1810                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1811
1812                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1813                 *yy_cp = yy_hold_char;
1814                 YY_RESTORE_YY_MORE_OFFSET
1815
1816                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1817                         {
1818                         /* We're scanning a new file or input source.  It's
1819                          * possible that this happened because the user
1820                          * just pointed yyin at a new source and called
1821                          * yylex().  If so, then we have to assure
1822                          * consistency between yy_current_buffer and our
1823                          * globals.  Here is the right place to do so, because
1824                          * this is the first action (other than possibly a
1825                          * back-up) that will match for the new input source.
1826                          */
1827                         yy_n_chars = yy_current_buffer->yy_n_chars;
1828                         yy_current_buffer->yy_input_file = yyin;
1829                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1830                         }
1831
1832                 /* Note that here we test for yy_c_buf_p "<=" to the position
1833                  * of the first EOB in the buffer, since yy_c_buf_p will
1834                  * already have been incremented past the NUL character
1835                  * (since all states make transitions on EOB to the
1836                  * end-of-buffer state).  Contrast this with the test
1837                  * in input().
1838                  */
1839                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1840                         { /* This was really a NUL. */
1841                         yy_state_type yy_next_state;
1842
1843                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1844
1845                         yy_current_state = yy_get_previous_state();
1846
1847                         /* Okay, we're now positioned to make the NUL
1848                          * transition.  We couldn't have
1849                          * yy_get_previous_state() go ahead and do it
1850                          * for us because it doesn't know how to deal
1851                          * with the possibility of jamming (and we don't
1852                          * want to build jamming into it because then it
1853                          * will run more slowly).
1854                          */
1855
1856                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1857
1858                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1859
1860                         if ( yy_next_state )
1861                                 {
1862                                 /* Consume the NUL. */
1863                                 yy_cp = ++yy_c_buf_p;
1864                                 yy_current_state = yy_next_state;
1865                                 goto yy_match;
1866                                 }
1867
1868                         else
1869                                 {
1870                                 yy_cp = yy_c_buf_p;
1871                                 goto yy_find_action;
1872                                 }
1873                         }
1874
1875                 else switch ( yy_get_next_buffer() )
1876                         {
1877                         case EOB_ACT_END_OF_FILE:
1878                                 {
1879                                 yy_did_buffer_switch_on_eof = 0;
1880
1881                                 if ( yywrap() )
1882                                         {
1883                                         /* Note: because we've taken care in
1884                                          * yy_get_next_buffer() to have set up
1885                                          * yytext, we can now set up
1886                                          * yy_c_buf_p so that if some total
1887                                          * hoser (like flex itself) wants to
1888                                          * call the scanner after we return the
1889                                          * YY_NULL, it'll still work - another
1890                                          * YY_NULL will get returned.
1891                                          */
1892                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1893
1894                                         yy_act = YY_STATE_EOF(YY_START);
1895                                         goto do_action;
1896                                         }
1897
1898                                 else
1899                                         {
1900                                         if ( ! yy_did_buffer_switch_on_eof )
1901                                                 YY_NEW_FILE;
1902                                         }
1903                                 break;
1904                                 }
1905
1906                         case EOB_ACT_CONTINUE_SCAN:
1907                                 yy_c_buf_p =
1908                                         yytext_ptr + yy_amount_of_matched_text;
1909
1910                                 yy_current_state = yy_get_previous_state();
1911
1912                                 yy_cp = yy_c_buf_p;
1913                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1914                                 goto yy_match;
1915
1916                         case EOB_ACT_LAST_MATCH:
1917                                 yy_c_buf_p =
1918                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1919
1920                                 yy_current_state = yy_get_previous_state();
1921
1922                                 yy_cp = yy_c_buf_p;
1923                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1924                                 goto yy_find_action;
1925                         }
1926                 break;
1927                 }
1928
1929         default:
1930                 YY_FATAL_ERROR(
1931                         "fatal flex scanner internal error--no action found" );
1932         } /* end of action switch */
1933                 } /* end of scanning one token */
1934         } /* end of yylex */
1935
1936
1937 /* yy_get_next_buffer - try to read in a new buffer
1938  *
1939  * Returns a code representing an action:
1940  *      EOB_ACT_LAST_MATCH -
1941  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1942  *      EOB_ACT_END_OF_FILE - end of file
1943  */
1944
1945 static int yy_get_next_buffer()
1946         {
1947         register char *dest = yy_current_buffer->yy_ch_buf;
1948         register char *source = yytext_ptr;
1949         register int number_to_move, i;
1950         int ret_val;
1951
1952         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1953                 YY_FATAL_ERROR(
1954                 "fatal flex scanner internal error--end of buffer missed" );
1955
1956         if ( yy_current_buffer->yy_fill_buffer == 0 )
1957                 { /* Don't try to fill the buffer, so this is an EOF. */
1958                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1959                         {
1960                         /* We matched a single character, the EOB, so
1961                          * treat this as a final EOF.
1962                          */
1963                         return EOB_ACT_END_OF_FILE;
1964                         }
1965
1966                 else
1967                         {
1968                         /* We matched some text prior to the EOB, first
1969                          * process it.
1970                          */
1971                         return EOB_ACT_LAST_MATCH;
1972                         }
1973                 }
1974
1975         /* Try to read more data. */
1976
1977         /* First move last chars to start of buffer. */
1978         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1979
1980         for ( i = 0; i < number_to_move; ++i )
1981                 *(dest++) = *(source++);
1982
1983         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1984                 /* don't do the read, it's not guaranteed to return an EOF,
1985                  * just force an EOF
1986                  */
1987                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1988
1989         else
1990                 {
1991                 int num_to_read =
1992                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1993
1994                 while ( num_to_read <= 0 )
1995                         { /* Not enough room in the buffer - grow it. */
1996 #ifdef YY_USES_REJECT
1997                         YY_FATAL_ERROR(
1998 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1999 #else
2000
2001                         /* just a shorter name for the current buffer */
2002                         YY_BUFFER_STATE b = yy_current_buffer;
2003
2004                         int yy_c_buf_p_offset =
2005                                 (int) (yy_c_buf_p - b->yy_ch_buf);
2006
2007                         if ( b->yy_is_our_buffer )
2008                                 {
2009                                 int new_size = b->yy_buf_size * 2;
2010
2011                                 if ( new_size <= 0 )
2012                                         b->yy_buf_size += b->yy_buf_size / 8;
2013                                 else
2014                                         b->yy_buf_size *= 2;
2015
2016                                 b->yy_ch_buf = (char *)
2017                                         /* Include room in for 2 EOB chars. */
2018                                         yy_flex_realloc( (void *) b->yy_ch_buf,
2019                                                          b->yy_buf_size + 2 );
2020                                 }
2021                         else
2022                                 /* Can't grow it, we don't own it. */
2023                                 b->yy_ch_buf = 0;
2024
2025                         if ( ! b->yy_ch_buf )
2026                                 YY_FATAL_ERROR(
2027                                 "fatal error - scanner input buffer overflow" );
2028
2029                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2030
2031                         num_to_read = yy_current_buffer->yy_buf_size -
2032                                                 number_to_move - 1;
2033 #endif
2034                         }
2035
2036                 if ( num_to_read > YY_READ_BUF_SIZE )
2037                         num_to_read = YY_READ_BUF_SIZE;
2038
2039                 /* Read in more data. */
2040                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2041                         yy_n_chars, num_to_read );
2042
2043                 yy_current_buffer->yy_n_chars = yy_n_chars;
2044                 }
2045
2046         if ( yy_n_chars == 0 )
2047                 {
2048                 if ( number_to_move == YY_MORE_ADJ )
2049                         {
2050                         ret_val = EOB_ACT_END_OF_FILE;
2051                         yyrestart( yyin );
2052                         }
2053
2054                 else
2055                         {
2056                         ret_val = EOB_ACT_LAST_MATCH;
2057                         yy_current_buffer->yy_buffer_status =
2058                                 YY_BUFFER_EOF_PENDING;
2059                         }
2060                 }
2061
2062         else
2063                 ret_val = EOB_ACT_CONTINUE_SCAN;
2064
2065         yy_n_chars += number_to_move;
2066         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2067         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2068
2069         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2070
2071         return ret_val;
2072         }
2073
2074
2075 /* yy_get_previous_state - get the state just before the EOB char was reached */
2076
2077 static yy_state_type yy_get_previous_state()
2078         {
2079         register yy_state_type yy_current_state;
2080         register char *yy_cp;
2081
2082         yy_current_state = yy_start;
2083         yy_current_state += YY_AT_BOL();
2084         yy_state_ptr = yy_state_buf;
2085         *yy_state_ptr++ = yy_current_state;
2086
2087         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2088                 {
2089                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2090                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2091                         {
2092                         yy_current_state = (int) yy_def[yy_current_state];
2093                         if ( yy_current_state >= 358 )
2094                                 yy_c = yy_meta[(unsigned int) yy_c];
2095                         }
2096                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2097                 *yy_state_ptr++ = yy_current_state;
2098                 }
2099
2100         return yy_current_state;
2101         }
2102
2103
2104 /* yy_try_NUL_trans - try to make a transition on the NUL character
2105  *
2106  * synopsis
2107  *      next_state = yy_try_NUL_trans( current_state );
2108  */
2109
2110 #ifdef YY_USE_PROTOS
2111 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2112 #else
2113 static yy_state_type yy_try_NUL_trans( yy_current_state )
2114 yy_state_type yy_current_state;
2115 #endif
2116         {
2117         register int yy_is_jam;
2118
2119         register YY_CHAR yy_c = 1;
2120         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2121                 {
2122                 yy_current_state = (int) yy_def[yy_current_state];
2123                 if ( yy_current_state >= 358 )
2124                         yy_c = yy_meta[(unsigned int) yy_c];
2125                 }
2126         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2127         yy_is_jam = (yy_current_state == 357);
2128         if ( ! yy_is_jam )
2129                 *yy_state_ptr++ = yy_current_state;
2130
2131         return yy_is_jam ? 0 : yy_current_state;
2132         }
2133
2134
2135 #ifndef YY_NO_UNPUT
2136 #ifdef YY_USE_PROTOS
2137 static void yyunput( int c, register char *yy_bp )
2138 #else
2139 static void yyunput( c, yy_bp )
2140 int c;
2141 register char *yy_bp;
2142 #endif
2143         {
2144         register char *yy_cp = yy_c_buf_p;
2145
2146         /* undo effects of setting up yytext */
2147         *yy_cp = yy_hold_char;
2148
2149         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2150                 { /* need to shift things up to make room */
2151                 /* +2 for EOB chars. */
2152                 register int number_to_move = yy_n_chars + 2;
2153                 register char *dest = &yy_current_buffer->yy_ch_buf[
2154                                         yy_current_buffer->yy_buf_size + 2];
2155                 register char *source =
2156                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2157
2158                 while ( source > yy_current_buffer->yy_ch_buf )
2159                         *--dest = *--source;
2160
2161                 yy_cp += (int) (dest - source);
2162                 yy_bp += (int) (dest - source);
2163                 yy_current_buffer->yy_n_chars =
2164                         yy_n_chars = yy_current_buffer->yy_buf_size;
2165
2166                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2167                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2168                 }
2169
2170         *--yy_cp = (char) c;
2171
2172
2173         yytext_ptr = yy_bp;
2174         yy_hold_char = *yy_cp;
2175         yy_c_buf_p = yy_cp;
2176         }
2177 #endif  /* ifndef YY_NO_UNPUT */
2178
2179
2180 #ifdef __cplusplus
2181 static int yyinput()
2182 #else
2183 static int input()
2184 #endif
2185         {
2186         int c;
2187
2188         *yy_c_buf_p = yy_hold_char;
2189
2190         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2191                 {
2192                 /* yy_c_buf_p now points to the character we want to return.
2193                  * If this occurs *before* the EOB characters, then it's a
2194                  * valid NUL; if not, then we've hit the end of the buffer.
2195                  */
2196                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2197                         /* This was really a NUL. */
2198                         *yy_c_buf_p = '\0';
2199
2200                 else
2201                         { /* need more input */
2202                         int offset = yy_c_buf_p - yytext_ptr;
2203                         ++yy_c_buf_p;
2204
2205                         switch ( yy_get_next_buffer() )
2206                                 {
2207                                 case EOB_ACT_LAST_MATCH:
2208                                         /* This happens because yy_g_n_b()
2209                                          * sees that we've accumulated a
2210                                          * token and flags that we need to
2211                                          * try matching the token before
2212                                          * proceeding.  But for input(),
2213                                          * there's no matching to consider.
2214                                          * So convert the EOB_ACT_LAST_MATCH
2215                                          * to EOB_ACT_END_OF_FILE.
2216                                          */
2217
2218                                         /* Reset buffer status. */
2219                                         yyrestart( yyin );
2220
2221                                         /* fall through */
2222
2223                                 case EOB_ACT_END_OF_FILE:
2224                                         {
2225                                         if ( yywrap() )
2226                                                 return EOF;
2227
2228                                         if ( ! yy_did_buffer_switch_on_eof )
2229                                                 YY_NEW_FILE;
2230 #ifdef __cplusplus
2231                                         return yyinput();
2232 #else
2233                                         return input();
2234 #endif
2235                                         }
2236
2237                                 case EOB_ACT_CONTINUE_SCAN:
2238                                         yy_c_buf_p = yytext_ptr + offset;
2239                                         break;
2240                                 }
2241                         }
2242                 }
2243
2244         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2245         *yy_c_buf_p = '\0';     /* preserve yytext */
2246         yy_hold_char = *++yy_c_buf_p;
2247
2248         yy_current_buffer->yy_at_bol = (c == '\n');
2249
2250         return c;
2251         }
2252
2253
2254 #ifdef YY_USE_PROTOS
2255 void yyrestart( FILE *input_file )
2256 #else
2257 void yyrestart( input_file )
2258 FILE *input_file;
2259 #endif
2260         {
2261         if ( ! yy_current_buffer )
2262                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2263
2264         yy_init_buffer( yy_current_buffer, input_file );
2265         yy_load_buffer_state();
2266         }
2267
2268
2269 #ifdef YY_USE_PROTOS
2270 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2271 #else
2272 void yy_switch_to_buffer( new_buffer )
2273 YY_BUFFER_STATE new_buffer;
2274 #endif
2275         {
2276         if ( yy_current_buffer == new_buffer )
2277                 return;
2278
2279         if ( yy_current_buffer )
2280                 {
2281                 /* Flush out information for old buffer. */
2282                 *yy_c_buf_p = yy_hold_char;
2283                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2284                 yy_current_buffer->yy_n_chars = yy_n_chars;
2285                 }
2286
2287         yy_current_buffer = new_buffer;
2288         yy_load_buffer_state();
2289
2290         /* We don't actually know whether we did this switch during
2291          * EOF (yywrap()) processing, but the only time this flag
2292          * is looked at is after yywrap() is called, so it's safe
2293          * to go ahead and always set it.
2294          */
2295         yy_did_buffer_switch_on_eof = 1;
2296         }
2297
2298
2299 #ifdef YY_USE_PROTOS
2300 void yy_load_buffer_state( void )
2301 #else
2302 void yy_load_buffer_state()
2303 #endif
2304         {
2305         yy_n_chars = yy_current_buffer->yy_n_chars;
2306         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2307         yyin = yy_current_buffer->yy_input_file;
2308         yy_hold_char = *yy_c_buf_p;
2309         }
2310
2311
2312 #ifdef YY_USE_PROTOS
2313 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2314 #else
2315 YY_BUFFER_STATE yy_create_buffer( file, size )
2316 FILE *file;
2317 int size;
2318 #endif
2319         {
2320         YY_BUFFER_STATE b;
2321
2322         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2323         if ( ! b )
2324                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2325
2326         b->yy_buf_size = size;
2327
2328         /* yy_ch_buf has to be 2 characters longer than the size given because
2329          * we need to put in 2 end-of-buffer characters.
2330          */
2331         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2332         if ( ! b->yy_ch_buf )
2333                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2334
2335         b->yy_is_our_buffer = 1;
2336
2337         yy_init_buffer( b, file );
2338
2339         return b;
2340         }
2341
2342
2343 #ifdef YY_USE_PROTOS
2344 void yy_delete_buffer( YY_BUFFER_STATE b )
2345 #else
2346 void yy_delete_buffer( b )
2347 YY_BUFFER_STATE b;
2348 #endif
2349         {
2350         if ( ! b )
2351                 return;
2352
2353         if ( b == yy_current_buffer )
2354                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2355
2356         if ( b->yy_is_our_buffer )
2357                 yy_flex_free( (void *) b->yy_ch_buf );
2358
2359         yy_flex_free( (void *) b );
2360         }
2361
2362
2363 #ifndef YY_ALWAYS_INTERACTIVE
2364 #ifndef YY_NEVER_INTERACTIVE
2365 extern int isatty YY_PROTO(( int ));
2366 #endif
2367 #endif
2368
2369 #ifdef YY_USE_PROTOS
2370 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2371 #else
2372 void yy_init_buffer( b, file )
2373 YY_BUFFER_STATE b;
2374 FILE *file;
2375 #endif
2376
2377
2378         {
2379         yy_flush_buffer( b );
2380
2381         b->yy_input_file = file;
2382         b->yy_fill_buffer = 1;
2383
2384 #if YY_ALWAYS_INTERACTIVE
2385         b->yy_is_interactive = 1;
2386 #else
2387 #if YY_NEVER_INTERACTIVE
2388         b->yy_is_interactive = 0;
2389 #else
2390         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2391 #endif
2392 #endif
2393         }
2394
2395
2396 #ifdef YY_USE_PROTOS
2397 void yy_flush_buffer( YY_BUFFER_STATE b )
2398 #else
2399 void yy_flush_buffer( b )
2400 YY_BUFFER_STATE b;
2401 #endif
2402
2403         {
2404         if ( ! b )
2405                 return;
2406
2407         b->yy_n_chars = 0;
2408
2409         /* We always need two end-of-buffer characters.  The first causes
2410          * a transition to the end-of-buffer state.  The second causes
2411          * a jam in that state.
2412          */
2413         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2414         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2415
2416         b->yy_buf_pos = &b->yy_ch_buf[0];
2417
2418         b->yy_at_bol = 1;
2419         b->yy_buffer_status = YY_BUFFER_NEW;
2420
2421         if ( b == yy_current_buffer )
2422                 yy_load_buffer_state();
2423         }
2424
2425
2426 #ifndef YY_NO_SCAN_BUFFER
2427 #ifdef YY_USE_PROTOS
2428 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2429 #else
2430 YY_BUFFER_STATE yy_scan_buffer( base, size )
2431 char *base;
2432 yy_size_t size;
2433 #endif
2434         {
2435         YY_BUFFER_STATE b;
2436
2437         if ( size < 2 ||
2438              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2439              base[size-1] != YY_END_OF_BUFFER_CHAR )
2440                 /* They forgot to leave room for the EOB's. */
2441                 return 0;
2442
2443         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2444         if ( ! b )
2445                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2446
2447         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2448         b->yy_buf_pos = b->yy_ch_buf = base;
2449         b->yy_is_our_buffer = 0;
2450         b->yy_input_file = 0;
2451         b->yy_n_chars = b->yy_buf_size;
2452         b->yy_is_interactive = 0;
2453         b->yy_at_bol = 1;
2454         b->yy_fill_buffer = 0;
2455         b->yy_buffer_status = YY_BUFFER_NEW;
2456
2457         yy_switch_to_buffer( b );
2458
2459         return b;
2460         }
2461 #endif
2462
2463
2464 #ifndef YY_NO_SCAN_STRING
2465 #ifdef YY_USE_PROTOS
2466 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2467 #else
2468 YY_BUFFER_STATE yy_scan_string( yy_str )
2469 yyconst char *yy_str;
2470 #endif
2471         {
2472         int len;
2473         for ( len = 0; yy_str[len]; ++len )
2474                 ;
2475
2476         return yy_scan_bytes( yy_str, len );
2477         }
2478 #endif
2479
2480
2481 #ifndef YY_NO_SCAN_BYTES
2482 #ifdef YY_USE_PROTOS
2483 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2484 #else
2485 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2486 yyconst char *bytes;
2487 int len;
2488 #endif
2489         {
2490         YY_BUFFER_STATE b;
2491         char *buf;
2492         yy_size_t n;
2493         int i;
2494
2495         /* Get memory for full buffer, including space for trailing EOB's. */
2496         n = len + 2;
2497         buf = (char *) yy_flex_alloc( n );
2498         if ( ! buf )
2499                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2500
2501         for ( i = 0; i < len; ++i )
2502                 buf[i] = bytes[i];
2503
2504         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2505
2506         b = yy_scan_buffer( buf, n );
2507         if ( ! b )
2508                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2509
2510         /* It's okay to grow etc. this buffer, and we should throw it
2511          * away when we're done.
2512          */
2513         b->yy_is_our_buffer = 1;
2514
2515         return b;
2516         }
2517 #endif
2518
2519
2520 #ifndef YY_NO_PUSH_STATE
2521 #ifdef YY_USE_PROTOS
2522 static void yy_push_state( int new_state )
2523 #else
2524 static void yy_push_state( new_state )
2525 int new_state;
2526 #endif
2527         {
2528         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2529                 {
2530                 yy_size_t new_size;
2531
2532                 yy_start_stack_depth += YY_START_STACK_INCR;
2533                 new_size = yy_start_stack_depth * sizeof( int );
2534
2535                 if ( ! yy_start_stack )
2536                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2537
2538                 else
2539                         yy_start_stack = (int *) yy_flex_realloc(
2540                                         (void *) yy_start_stack, new_size );
2541
2542                 if ( ! yy_start_stack )
2543                         YY_FATAL_ERROR(
2544                         "out of memory expanding start-condition stack" );
2545                 }
2546
2547         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2548
2549         BEGIN(new_state);
2550         }
2551 #endif
2552
2553
2554 #ifndef YY_NO_POP_STATE
2555 static void yy_pop_state()
2556         {
2557         if ( --yy_start_stack_ptr < 0 )
2558                 YY_FATAL_ERROR( "start-condition stack underflow" );
2559
2560         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2561         }
2562 #endif
2563
2564
2565 #ifndef YY_NO_TOP_STATE
2566 static int yy_top_state()
2567         {
2568         return yy_start_stack[yy_start_stack_ptr - 1];
2569         }
2570 #endif
2571
2572 #ifndef YY_EXIT_FAILURE
2573 #define YY_EXIT_FAILURE 2
2574 #endif
2575
2576 #ifdef YY_USE_PROTOS
2577 static void yy_fatal_error( yyconst char msg[] )
2578 #else
2579 static void yy_fatal_error( msg )
2580 char msg[];
2581 #endif
2582         {
2583         (void) fprintf( stderr, "%s\n", msg );
2584         exit( YY_EXIT_FAILURE );
2585         }
2586
2587
2588
2589 /* Redefine yyless() so it works in section 3 code. */
2590
2591 #undef yyless
2592 #define yyless(n) \
2593         do \
2594                 { \
2595                 /* Undo effects of setting up yytext. */ \
2596                 yytext[yyleng] = yy_hold_char; \
2597                 yy_c_buf_p = yytext + n; \
2598                 yy_hold_char = *yy_c_buf_p; \
2599                 *yy_c_buf_p = '\0'; \
2600                 yyleng = n; \
2601                 } \
2602         while ( 0 )
2603
2604
2605 /* Internal utility routines. */
2606
2607 #ifndef yytext_ptr
2608 #ifdef YY_USE_PROTOS
2609 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2610 #else
2611 static void yy_flex_strncpy( s1, s2, n )
2612 char *s1;
2613 yyconst char *s2;
2614 int n;
2615 #endif
2616         {
2617         register int i;
2618         for ( i = 0; i < n; ++i )
2619                 s1[i] = s2[i];
2620         }
2621 #endif
2622
2623 #ifdef YY_NEED_STRLEN
2624 #ifdef YY_USE_PROTOS
2625 static int yy_flex_strlen( yyconst char *s )
2626 #else
2627 static int yy_flex_strlen( s )
2628 yyconst char *s;
2629 #endif
2630         {
2631         register int n;
2632         for ( n = 0; s[n]; ++n )
2633                 ;
2634
2635         return n;
2636         }
2637 #endif
2638
2639
2640 #ifdef YY_USE_PROTOS
2641 static void *yy_flex_alloc( yy_size_t size )
2642 #else
2643 static void *yy_flex_alloc( size )
2644 yy_size_t size;
2645 #endif
2646         {
2647         return (void *) malloc( size );
2648         }
2649
2650 #ifdef YY_USE_PROTOS
2651 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2652 #else
2653 static void *yy_flex_realloc( ptr, size )
2654 void *ptr;
2655 yy_size_t size;
2656 #endif
2657         {
2658         /* The cast to (char *) in the following accommodates both
2659          * implementations that use char* generic pointers, and those
2660          * that use void* generic pointers.  It works with the latter
2661          * because both ANSI C and C++ allow castless assignment from
2662          * any pointer type to void*, and deal with argument conversions
2663          * as though doing an assignment.
2664          */
2665         return (void *) realloc( (char *) ptr, size );
2666         }
2667
2668 #ifdef YY_USE_PROTOS
2669 static void yy_flex_free( void *ptr )
2670 #else
2671 static void yy_flex_free( ptr )
2672 void *ptr;
2673 #endif
2674         {
2675         free( ptr );
2676         }
2677
2678 #if YY_MAIN
2679 int main()
2680         {
2681         yylex();
2682         return 0;
2683         }
2684 #endif
2685 #line 452 "lexer.l"
2686
2687
2688 /* Ugly warning avoiding */
2689 #ifdef FLEX_SCANNER
2690 static void warning_avoider(void) G_GNUC_UNUSED;
2691 static void warning_avoider(void) {
2692         yy_flex_realloc(NULL, 0);
2693         yyunput(0, NULL);
2694         warning_avoider();
2695 }
2696 #endif
2697