src/lexer.c

   1
   2 #line 3 "lexer.c"
   3
   4 #define  YY_INT_ALIGNED short int
   5
   6 /* A lexical scanner generated by flex */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION 2
  10 #define YY_FLEX_MINOR_VERSION 5
  11 #define YY_FLEX_SUBMINOR_VERSION 37
  12 #if YY_FLEX_SUBMINOR_VERSION > 0
  13 #define FLEX_BETA
  14 #endif
  15
  16 /* First, we deal with  platform-specific or compiler-specific issues. */
  17
  18 /* begin standard C headers. */
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23
  24 /* end standard C headers. */
  25
  26 /* flex integer type definitions */
  27
  28 #ifndef FLEXINT_H
  29 #define FLEXINT_H
  30
  31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  32
  33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  34
  35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  36  * if you want the limit (max/min) macros for int types.
  37  */
  38 #ifndef __STDC_LIMIT_MACROS
  39 #define __STDC_LIMIT_MACROS 1
  40 #endif
  41
  42 #include <inttypes.h>
  43 typedef int8_t flex_int8_t;
  44 typedef uint8_t flex_uint8_t;
  45 typedef int16_t flex_int16_t;
  46 typedef uint16_t flex_uint16_t;
  47 typedef int32_t flex_int32_t;
  48 typedef uint32_t flex_uint32_t;
  49 #else
  50 typedef signed char flex_int8_t;
  51 typedef short int flex_int16_t;
  52 typedef int flex_int32_t;
  53 typedef unsigned char flex_uint8_t;
  54 typedef unsigned short int flex_uint16_t;
  55 typedef unsigned int flex_uint32_t;
  56
  57 /* Limits of integral types. */
  58 #ifndef INT8_MIN
  59 #define INT8_MIN               (-128)
  60 #endif
  61 #ifndef INT16_MIN
  62 #define INT16_MIN              (-32767-1)
  63 #endif
  64 #ifndef INT32_MIN
  65 #define INT32_MIN              (-2147483647-1)
  66 #endif
  67 #ifndef INT8_MAX
  68 #define INT8_MAX               (127)
  69 #endif
  70 #ifndef INT16_MAX
  71 #define INT16_MAX              (32767)
  72 #endif
  73 #ifndef INT32_MAX
  74 #define INT32_MAX              (2147483647)
  75 #endif
  76 #ifndef UINT8_MAX
  77 #define UINT8_MAX              (255U)
  78 #endif
  79 #ifndef UINT16_MAX
  80 #define UINT16_MAX             (65535U)
  81 #endif
  82 #ifndef UINT32_MAX
  83 #define UINT32_MAX             (4294967295U)
  84 #endif
  85
  86 #endif /* ! C99 */
  87
  88 #endif /* ! FLEXINT_H */
  89
  90 #ifdef __cplusplus
  91
  92 /* The "const" storage-class-modifier is valid. */
  93 #define YY_USE_CONST
  94
  95 #else   /* ! __cplusplus */
  96
  97 /* C99 requires __STDC__ to be defined as 1. */
  98 #if defined (__STDC__)
  99
 100 #define YY_USE_CONST
 101
 102 #endif  /* defined (__STDC__) */
 103 #endif  /* ! __cplusplus */
 104
 105 #ifdef YY_USE_CONST
 106 #define yyconst const
 107 #else
 108 #define yyconst
 109 #endif
 110
 111 /* Returned upon end-of-file. */
 112 #define YY_NULL 0
 113
 114 /* Promotes a possibly negative, possibly signed char to an unsigned
 115  * integer for use as an array index.  If the signed char is negative,
 116  * we want to instead treat it as an 8-bit unsigned char, hence the
 117  * double cast.
 118  */
 119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 120
 121 /* Enter a start condition.  This macro really ought to take a parameter,
 122  * but we do it the disgusting crufty way forced on us by the ()-less
 123  * definition of BEGIN.
 124  */
 125 #define BEGIN (yy_start) = 1 + 2 *
 126
 127 /* Translate the current start state into a value that can be later handed
 128  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 129  * compatibility.
 130  */
 131 #define YY_START (((yy_start) - 1) / 2)
 132 #define YYSTATE YY_START
 133
 134 /* Action number for EOF rule of a given start state. */
 135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 136
 137 /* Special action meaning "start processing a new file". */
 138 #define YY_NEW_FILE yyrestart(yyin  )
 139
 140 #define YY_END_OF_BUFFER_CHAR 0
 141
 142 /* Size of default input buffer. */
 143 #ifndef YY_BUF_SIZE
 144 #define YY_BUF_SIZE 16384
 145 #endif
 146
 147 /* The state buf must be large enough to hold one state per character in the main buffer.
 148  */
 149 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 150
 151 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 152 #define YY_TYPEDEF_YY_BUFFER_STATE
 153 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 154 #endif
 155
 156 #ifndef YY_TYPEDEF_YY_SIZE_T
 157 #define YY_TYPEDEF_YY_SIZE_T
 158 typedef size_t yy_size_t;
 159 #endif
 160
 161 extern yy_size_t yyleng;
 162
 163 extern FILE *yyin, *yyout;
 164
 165 #define EOB_ACT_CONTINUE_SCAN 0
 166 #define EOB_ACT_END_OF_FILE 1
 167 #define EOB_ACT_LAST_MATCH 2
 168
 169     #define YY_LESS_LINENO(n)
 170
 171 /* Return all but the first "n" matched characters back to the input stream. */
 172 #define yyless(n) \
 173         do \
 174                 { \
 175                 /* Undo effects of setting up yytext. */ \
 176         int yyless_macro_arg = (n); \
 177         YY_LESS_LINENO(yyless_macro_arg);\
 178                 *yy_cp = (yy_hold_char); \
 179                 YY_RESTORE_YY_MORE_OFFSET \
 180                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 181                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 182                 } \
 183         while ( 0 )
 184
 185 #define unput(c) yyunput( c, (yytext_ptr)  )
 186
 187 #ifndef YY_STRUCT_YY_BUFFER_STATE
 188 #define YY_STRUCT_YY_BUFFER_STATE
 189 struct yy_buffer_state
 190         {
 191         FILE *yy_input_file;
 192
 193         char *yy_ch_buf;                /* input buffer */
 194         char *yy_buf_pos;               /* current position in input buffer */
 195
 196         /* Size of input buffer in bytes, not including room for EOB
 197          * characters.
 198          */
 199         yy_size_t yy_buf_size;
 200
 201         /* Number of characters read into yy_ch_buf, not including EOB
 202          * characters.
 203          */
 204         yy_size_t yy_n_chars;
 205
 206         /* Whether we "own" the buffer - i.e., we know we created it,
 207          * and can realloc() it to grow it, and should free() it to
 208          * delete it.
 209          */
 210         int yy_is_our_buffer;
 211
 212         /* Whether this is an "interactive" input source; if so, and
 213          * if we're using stdio for input, then we want to use getc()
 214          * instead of fread(), to make sure we stop fetching input after
 215          * each newline.
 216          */
 217         int yy_is_interactive;
 218
 219         /* Whether we're considered to be at the beginning of a line.
 220          * If so, '^' rules will be active on the next match, otherwise
 221          * not.
 222          */
 223         int yy_at_bol;
 224
 225     int yy_bs_lineno; /**< The line count. */
 226     int yy_bs_column; /**< The column count. */
 227
 228         /* Whether to try to fill the input buffer when we reach the
 229          * end of it.
 230          */
 231         int yy_fill_buffer;
 232
 233         int yy_buffer_status;
 234
 235 #define YY_BUFFER_NEW 0
 236 #define YY_BUFFER_NORMAL 1
 237         /* When an EOF's been seen but there's still some text to process
 238          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 239          * shouldn't try reading from the input source any more.  We might
 240          * still have a bunch of tokens to match, though, because of
 241          * possible backing-up.
 242          *
 243          * When we actually see the EOF, we change the status to "new"
 244          * (via yyrestart()), so that the user can continue scanning by
 245          * just pointing yyin at a new input file.
 246          */
 247 #define YY_BUFFER_EOF_PENDING 2
 248
 249         };
 250 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 251
 252 /* Stack of input buffers. */
 253 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 254 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 255 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 256
 257 /* We provide macros for accessing buffer states in case in the
 258  * future we want to put the buffer states in a more general
 259  * "scanner state".
 260  *
 261  * Returns the top of the stack, or NULL.
 262  */
 263 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 264                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 265                           : NULL)
 266
 267 /* Same as previous macro, but useful when we know that the buffer stack is not
 268  * NULL or when we need an lvalue. For internal use only.
 269  */
 270 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 271
 272 /* yy_hold_char holds the character lost when yytext is formed. */
 273 static char yy_hold_char;
 274 static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
 275 yy_size_t yyleng;
 276
 277 /* Points to current character in buffer. */
 278 static char *yy_c_buf_p = (char *) 0;
 279 static int yy_init = 0;         /* whether we need to initialize */
 280 static int yy_start = 0;        /* start state number */
 281
 282 /* Flag which is used to allow yywrap()'s to do buffer switches
 283  * instead of setting up a fresh yyin.  A bit of a hack ...
 284  */
 285 static int yy_did_buffer_switch_on_eof;
 286
 287 void yyrestart (FILE *input_file  );
 288 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 289 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 290 void yy_delete_buffer (YY_BUFFER_STATE b  );
 291 void yy_flush_buffer (YY_BUFFER_STATE b  );
 292 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 293 void yypop_buffer_state (void );
 294
 295 static void yyensure_buffer_stack (void );
 296 static void yy_load_buffer_state (void );
 297 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 298
 299 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 300
 301 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 302 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 303 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
 304
 305 void *yyalloc (yy_size_t  );
 306 void *yyrealloc (void *,yy_size_t  );
 307 void yyfree (void *  );
 308
 309 #define yy_new_buffer yy_create_buffer
 310
 311 #define yy_set_interactive(is_interactive) \
 312         { \
 313         if ( ! YY_CURRENT_BUFFER ){ \
 314         yyensure_buffer_stack (); \
 315                 YY_CURRENT_BUFFER_LVALUE =    \
 316             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 317         } \
 318         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 319         }
 320
 321 #define yy_set_bol(at_bol) \
 322         { \
 323         if ( ! YY_CURRENT_BUFFER ){\
 324         yyensure_buffer_stack (); \
 325                 YY_CURRENT_BUFFER_LVALUE =    \
 326             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 327         } \
 328         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 329         }
 330
 331 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 332
 333 /* Begin user sect3 */
 334
 335 typedef unsigned char YY_CHAR;
 336
 337 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 338
 339 typedef int yy_state_type;
 340
 341 extern int yylineno;
 342
 343 int yylineno = 1;
 344
 345 extern char *yytext;
 346 #define yytext_ptr yytext
 347
 348 static yy_state_type yy_get_previous_state (void );
 349 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 350 static int yy_get_next_buffer (void );
 351 static void yy_fatal_error (yyconst char msg[]  );
 352
 353 /* Done after the current pattern has been matched and before the
 354  * corresponding action - sets up yytext.
 355  */
 356 #define YY_DO_BEFORE_ACTION \
 357         (yytext_ptr) = yy_bp; \
 358         yyleng = (size_t) (yy_cp - yy_bp); \
 359         (yy_hold_char) = *yy_cp; \
 360         *yy_cp = '\0'; \
 361         (yy_c_buf_p) = yy_cp;
 362
 363 #define YY_NUM_RULES 124
 364 #define YY_END_OF_BUFFER 125
 365 /* This struct is not used in this scanner,
 366    but its presence is necessary. */
 367 struct yy_trans_info
 368         {
 369         flex_int32_t yy_verify;
 370         flex_int32_t yy_nxt;
 371         };
 372 static yyconst flex_int16_t yy_acclist[660] =
 373     {   0,
 374       125,  122,  124,  120,  122,  124,    1,  121,  124,  121,
 375       122,  124,  122,  124,  122,  124,  122,  124,  109,  122,
 376       124,  109,  122,  124,  122,  124,  113,  122,  124,  113,
 377       122,  124,  113,  122,  124,  113,  122,  124,  120,  122,
 378       124,  122,  124,  122,  124,  113,  122,  124,  113,  122,
 379       124,   29,  122,  124,    1,   30,  121,  124,   29,  121,
 380       122,  124,   29,  122,  124,   29,  122,  124,   29,  122,
 381       124,   55,  122,  124,    1,   56,  121,  124,   55,  121,
 382       122,  124,   47,   55,  122,  124,   55,  122,  124,   55,
 383       122,  124,   55,  122,  124,   53,   55,  122,  124,   54,
 384
 385        55,  122,  124,   55,  122,  124,   55,  122,  124,   51,
 386       122,  124,    1,   52,  121,  124,   51,  121,  122,  124,
 387        50,   51,  122,  124,   51,  122,  124,   51,  122,  124,
 388        64,  122,  124,  122,  124,  113,  122,  124,  113,  122,
 389       124,  113,  122,  124,  117,  122,  124,   67,  122,  124,
 390         1,   68,  121,  124,   67,  121,  122,  124,   66,   67,
 391       122,  124,   67,  122,  124,   67,  122,  124,   69,  122,
 392       124,  122,  124,  122,  124,  122,  124,  122,  124,  113,
 393       122,  124,  113,  122,  124,  113,  122,  124,  113,  122,
 394       124,  113,  122,  124,  113,  122,  124,  113,  122,  124,
 395
 396       113,  122,  124,  113,  122,  124,  113,  122,  124,  113,
 397       122,  124,  113,  122,  124,  118,  122,  124,  119,  122,
 398       124,  106,  122,  124,   48,  122,  124,  107,  122,  124,
 399       108,  122,  124,  122,  124,  113,  122,  124,  113,  122,
 400       124,  113,  122,  124,  113,  122,  124,  113,  122,  124,
 401       113,  122,  124,  113,  122,  124,  113,  122,  124,  113,
 402       122,  124,  113,  122,  124,  113,  122,  124,  113,  122,
 403       124,   10,  122,  124,   10,  121,  122,  124,   10,  122,
 404       124,   10,  122,  124,   10,  122,  124,   10,  122,  124,
 405        15,  122,  124,   15,  121,  122,  124,   15,  122,  124,
 406
 407        15,  122,  124,   15,  122,  124,   15,  122,  124,   18,
 408       122,  124,   18,  121,  122,  124,   18,  122,  124,   18,
 409       122,  124,  109,   23,  109,  109,  112,  113,  113,  113,
 410       113,  113,   36,  113,  113,   28,   24,   46,   39,   49,
 411        25,  113,  113,  113,   65,   26,  116,  115,  113,  113,
 412       113,  113,  113,  113,  113,  113,  113,  113,  113,  113,
 413       113,  113,  113,  113,  113,  113,   27,  113,  113,  113,
 414       113,  113,  113,  113,  113,  113,  113,  113,  113,  113,
 415         9,    7,   14,   13,   11,   12,   14,   17,   16,  114,
 416       114,  109,    3,  109,  109,  112,  110,  111,  113,  113,
 417
 418       113,  113,   31,   35,  113,  113,   44,   40,   42,   19,
 419        20,  113,  113,  113,   83,   21,  113,  113,  113,  113,
 420       113,  113,  113,   78,  113,  113,  113,  113,  113,  113,
 421       113,  113,  113,  113,  113,  113,  113,   22,  113,  113,
 422       113,  113,  113,  113,  113,  113,  113,  113,  113,  113,
 423       113,   12,  112,  110,  111,  113,   59,  113,  113,  113,
 424        38,   32,   37,   33,   34,  113,  113,   45,   41,   43,
 425       113,   63,  113,   62,  113,    6,  113,   81,  113,  113,
 426       113,  113,   73,  113,  113,   76,  113,  113,  113,  113,
 427       113,  113,  113,  113,  113,  113,  113,  113,   70,  113,
 428
 429       113,  113,  113,   73,  113,  113,  113,  113,   94,  113,
 430        93,  113,  113,  113,  113,  100,  113,    8,  112,   57,
 431       113,   58,  113,   60,  113,  113,  113,  113,   62,  113,
 432        82,  113,  113,   79,  113,  113,  113,  113,  113,  113,
 433        77,  113,  113,  113,  113,   72,  113,  113,  113,   95,
 434       113,  113,  113,  113,   99,  113,  113,  113,  113,  113,
 435       113,  113,  113,  113,   80,  113,  113,  113,  113,  113,
 436        84,  113,   90,  113,   74,  113,   71,  113,  113,  113,
 437       113,  113,  113,  113,  113,  113,  113,  113,    4,  113,
 438       113,  113,  113,  113,   85,  113,  113,  113,  113,   89,
 439
 440       113,  113,  113,  113,  113,   96,  113,   97,  113,  113,
 441       113,  113,  113,   88,  113,  113,   91,  113,   92,  113,
 442       113,   75,  113,  113,  113,  113,  113,  113,  113,   87,
 443       113,   86,  113,  113,  113,  102,  113,  113,  113,  113,
 444         4,    2,  104,  113,  113,  101,  113,  113,  103,  113,
 445       123,    5,  113,  105,  113,  113,   98,  113,   61
 446     } ;
 447
 448 static yyconst flex_int16_t yy_accept[571] =
 449     {   0,
 450         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 451         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 452         1,    1,    1,    1,    1,    2,    4,    7,   10,   13,
 453        15,   17,   19,   22,   25,   27,   30,   33,   36,   39,
 454        42,   44,   46,   49,   52,   55,   59,   63,   66,   69,
 455        72,   75,   79,   83,   87,   90,   93,   96,  100,  104,
 456       107,  110,  113,  117,  121,  125,  128,  131,  134,  136,
 457       139,  142,  145,  148,  151,  155,  159,  163,  166,  169,
 458       172,  174,  176,  178,  180,  183,  186,  189,  192,  195,
 459       198,  201,  204,  207,  210,  213,  216,  219,  222,  225,
 460
 461       228,  231,  234,  236,  239,  242,  245,  248,  251,  254,
 462       257,  260,  263,  266,  269,  272,  275,  279,  282,  285,
 463       288,  291,  294,  298,  301,  304,  307,  310,  313,  317,
 464       320,  323,  323,  323,  324,  325,  325,  325,  326,  326,
 465       326,  327,  328,  329,  329,  330,  331,  332,  333,  333,
 466       333,  333,  333,  333,  333,  333,  333,  333,  334,  335,
 467       336,  337,  337,  337,  337,  337,  337,  338,  338,  339,
 468       339,  339,  340,  341,  342,  342,  343,  344,  345,  346,
 469       346,  347,  347,  348,  348,  348,  349,  350,  351,  352,
 470       353,  354,  355,  356,  357,  358,  359,  360,  361,  362,
 471
 472       363,  364,  365,  366,  367,  368,  368,  369,  370,  371,
 473       372,  373,  374,  375,  376,  377,  378,  379,  380,  381,
 474       382,  382,  382,  382,  383,  383,  384,  384,  384,  385,
 475       386,  386,  388,  389,  390,  391,  391,  392,  393,  393,
 476       394,  395,  396,  397,  397,  398,  399,  400,  401,  402,
 477       403,  403,  403,  403,  403,  403,  403,  403,  404,  404,
 478       404,  404,  405,  405,  405,  406,  407,  407,  408,  408,
 479       408,  408,  409,  410,  410,  411,  411,  411,  412,  413,
 480       414,  415,  416,  416,  416,  417,  417,  417,  418,  419,
 481       420,  421,  422,  423,  424,  426,  427,  428,  429,  430,
 482
 483       431,  432,  433,  434,  435,  436,  437,  438,  438,  439,
 484       440,  441,  442,  443,  444,  445,  446,  447,  448,  449,
 485       450,  451,  452,  452,  453,  453,  454,  455,  455,  456,
 486       456,  457,  459,  460,  461,  461,  461,  461,  462,  462,
 487       462,  463,  463,  464,  464,  465,  466,  466,  467,  468,
 488       468,  469,  470,  471,  471,  472,  474,  476,  476,  477,
 489       478,  480,  481,  482,  483,  485,  486,  488,  489,  490,
 490       491,  492,  493,  494,  495,  496,  497,  498,  499,  501,
 491       502,  503,  504,  506,  507,  508,  509,  511,  513,  514,
 492       515,  516,  518,  518,  519,  519,  519,  520,  522,  524,
 493
 494       526,  526,  526,  526,  526,  526,  526,  526,  526,  527,
 495       528,  528,  528,  529,  531,  533,  534,  536,  537,  538,
 496       539,  540,  541,  543,  544,  545,  546,  548,  549,  550,
 497       552,  553,  554,  555,  557,  558,  559,  560,  561,  561,
 498       561,  561,  561,  561,  561,  561,  562,  563,  563,  563,
 499       564,  565,  567,  568,  569,  570,  571,  573,  575,  577,
 500       579,  580,  581,  582,  583,  584,  585,  586,  587,  588,
 501       589,  589,  589,  590,  590,  590,  590,  591,  592,  592,
 502       592,  593,  594,  595,  597,  598,  599,  600,  602,  603,
 503       604,  605,  606,  608,  610,  611,  612,  612,  612,  612,
 504
 505       612,  612,  612,  613,  614,  614,  614,  616,  617,  619,
 506       621,  622,  624,  625,  626,  627,  628,  629,  630,  630,
 507       630,  630,  630,  630,  630,  630,  630,  630,  630,  630,
 508       632,  634,  635,  636,  638,  639,  640,  641,  641,  642,
 509       642,  642,  642,  642,  642,  643,  643,  645,  646,  648,
 510       649,  651,  651,  651,  652,  652,  652,  653,  654,  656,
 511       656,  656,  657,  657,  657,  659,  659,  659,  660,  660
 512     } ;
 513
 514 static yyconst flex_int32_t yy_ec[256] =
 515     {   0,
 516         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 517         1,    4,    5,    1,    1,    1,    1,    1,    1,    1,
 518         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 519         1,    6,    1,    7,    8,    1,    9,    1,   10,   11,
 520        12,   13,    1,    1,    1,   14,   15,   16,   17,   18,
 521        18,   18,   18,   18,   18,   19,   19,   20,    1,   21,
 522         1,   22,    1,    1,   23,   23,   23,   23,   24,   23,
 523        25,   25,   26,   25,   25,   25,   25,   25,   25,   25,
 524        25,   27,   28,   25,   25,   25,   25,   25,   25,   25,
 525        29,   30,   31,    1,   32,    1,   33,   34,   35,   36,
 526
 527        37,   38,   39,   40,   41,   42,   43,   44,   45,   46,
 528        47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
 529        57,   25,   58,    1,   59,    1,    1,    1,    1,    1,
 530         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 531         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 532         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 533         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 534         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 535         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 536         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 537
 538         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 539         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 540         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 541         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 542         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 543         1,    1,    1,    1,    1
 544     } ;
 545
 546 static yyconst flex_int32_t yy_meta[60] =
 547     {   0,
 548         1,    2,    3,    4,    5,    2,    1,    1,    1,    1,
 549         1,    1,    1,    1,    1,    6,    6,    6,    6,    7,
 550         1,    1,    8,    8,    9,    9,    9,    9,    1,    1,
 551        10,    9,    8,    8,    8,    8,    8,    8,    9,    9,
 552         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 553         9,    9,    9,    9,    9,    9,    9,    1,    1
 554     } ;
 555
 556 static yyconst flex_int16_t yy_base[604] =
 557     {   0,
 558         0,   58,   58,   65,   69,  126,   80,   85,   74,   87,
 559        93,  113,  179, 1361,  129,  138,  232, 1360,  100,  149,
 560       145,  166,  175,  187, 1367, 1370, 1370, 1370, 1370, 1336,
 561       185,   62,  232,  238,    0, 1345,   42,  161,   60,  239,
 562        63,  257,   97,   77, 1370, 1370, 1370, 1349,  216, 1335,
 563      1370, 1370, 1370, 1370,  176,  146,    0, 1370, 1370,  257,
 564      1303, 1370, 1370, 1370, 1370,    0,  256, 1370,  150,  169,
 565       110,  157, 1370, 1370, 1370, 1370, 1370,    0,  259, 1370,
 566       277,  206,  290,  294,  178,  279,  162,  190,  185,  282,
 567       284,  171,  222,  294,  296,  297, 1370, 1370, 1370, 1370,
 568
 569      1370, 1370,  305,  301,  307,  302,  304,  220,  310,  320,
 570       321,  332,  316,   62,  312, 1370, 1370, 1346,  356,  327,
 571       361, 1370, 1370, 1345,  364,  372,  377, 1356, 1355,  357,
 572       379, 1347, 1346,  370, 1370, 1352,  377,  383,  389,    0,
 573       395, 1334, 1333, 1332,  371,  117,  378,  397,  413, 1301,
 574      1313,  416, 1308,  388, 1296,  373,  231, 1370,  400,  204,
 575      1370,    0, 1337,  377, 1336, 1335, 1370, 1341, 1370,  427,
 576      1297, 1370, 1370, 1370, 1339,  401,  407,  418, 1370, 1327,
 577      1327, 1336,  425,  431, 1307, 1308,  419,  431,  432,  433,
 578       425,  435,  436,  437,  446,  447,  449,  452,  450,  454,
 579
 580       453,  457,  455,  460, 1370, 1333,  456,  317,  461,  462,
 581       467,  465,  471,  474,  475,  482,  484,  486,  487, 1370,
 582       510,  524,  526, 1370,  534, 1370,  536,  541,  549, 1370,
 583      1320, 1370, 1370, 1370, 1370, 1324, 1323,  541, 1329, 1370,
 584       545,    0, 1311,    0, 1310, 1309,  502,  500,  519,  511,
 585      1291, 1278, 1280, 1267, 1272, 1279, 1264, 1370,  518, 1288,
 586      1262, 1370, 1261, 1277,  513,  521, 1290, 1370, 1306, 1305,
 587      1304, 1370, 1370, 1310, 1370, 1277, 1308, 1370,  528,  547,
 588       548, 1370,  567, 1307, 1370, 1278,  564,  551,  552,  555,
 589       557,  564,  558,  567, 1288,  566,  565,  568,  569,  570,
 590
 591       573,  574,  571,  581,  577,  587,  576, 1304, 1370,  590,
 592       589,  596,  591,  593,  605,  607,  610,  599,  613,  611,
 593       614,  615,  635, 1370,  651, 1286, 1285, 1284, 1283, 1282,
 594       623, 1281,  625,  629, 1267, 1246, 1261, 1370, 1260,  604,
 595      1370, 1248, 1370, 1259, 1370, 1370, 1240,  638,  631, 1267,
 596      1370, 1370, 1370, 1248,  639, 1271, 1270,  661, 1370,  641,
 597      1269,  645,  646,  648, 1268,  649, 1267,  650,  651,  656,
 598       657,  658,  653,  669,  668,  661,  665,  659, 1266,  663,
 599       675,  667,  689,  671,  688,  690, 1265, 1264,  693,  694,
 600       695, 1263,  721, 1370,  723,  728, 1262, 1261, 1260, 1259,
 601
 602      1234, 1236,  136, 1226, 1228, 1216, 1236, 1239,  696,  697,
 603         0, 1218,  699,  698, 1250,  717, 1249,  718,  721,  722,
 604       725,  726, 1248,  724,  728,  729, 1247,  730,  732, 1246,
 605       731,  735,  736,  737,  738,  742,  746,  750, 1221, 1214,
 606       783, 1227, 1214, 1211, 1208,  747,  755, 1230, 1216,  751,
 607       763, 1224,  754,  766,  757,  758, 1223, 1222, 1212, 1201,
 608       776,  764,  760,  767,  773,  785,  786,  787,  791,  794,
 609      1173, 1168,  822, 1167,  763, 1166,  798,  796, 1191, 1149,
 610       797,  800,  805, 1127,  802,  806,  809, 1116,  807,  824,
 611       814,  815, 1097, 1091,  828,  830, 1067, 1041, 1075, 1031,
 612
 613       942,  948,  849,  851,  848,  852,  967,  840,  966,  965,
 614       832,  964,  841,  843,  853,  850,  854,  855,  876,  877,
 615       976,  937,  919,  914,  889,  898,  902,  910,  878,  930,
 616       929,  856,  861,  921,  864,  876,  872,  932, 1370,  862,
 617       869,  928,  919,  936, 1370,  903,  866,  868,  498,  903,
 618       493,  475,  954, 1370,  945,  936, 1370,  912,  355,  245,
 619       952,  922,  224,  956,   81,  974,  976, 1370, 1370,  993,
 620      1003, 1013, 1023, 1033, 1043, 1053, 1063, 1066, 1070, 1079,
 621      1089, 1099, 1104, 1114, 1124, 1129, 1132, 1135, 1144, 1154,
 622      1164, 1174, 1179, 1189, 1198, 1200, 1204, 1208, 1216, 1220,
 623
 624      1229, 1239, 1249
 625     } ;
 626
 627 static yyconst flex_int16_t yy_def[604] =
 628     {   0,
 629       569,    1,  570,  570,  571,  571,  572,  572,    1,    1,
 630       573,  573,    1,   13,    1,    1,    1,   17,  574,  574,
 631       575,  575,  576,  576,  569,  569,  569,  569,  569,  577,
 632       569,  569,  569,  569,  578,  579,  579,  579,  579,  569,
 633       569,  569,  579,  579,  569,  569,  569,  569,  569,  569,
 634       569,  569,  569,  569,  569,  569,  580,  569,  569,  569,
 635       569,  569,  569,  569,  569,  581,  569,  569,  569,  579,
 636       579,  579,  569,  569,  569,  569,  569,  582,  569,  569,
 637       569,  569,  578,  583,  579,  579,  579,  579,  579,  579,
 638       579,  579,  579,  579,  579,  579,  569,  569,  569,  569,
 639
 640       569,  569,  569,  579,  579,  579,  579,  579,  579,  579,
 641       579,  579,  579,  579,  579,  569,  569,  569,  569,  569,
 642       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 643       569,  569,  584,  569,  569,  585,  569,  569,  569,  586,
 644       569,  587,  579,  588,  579,  579,  579,  579,  569,  569,
 645       569,  569,  569,  569,  569,  569,  569,  569,  579,  579,
 646       569,  589,  569,  569,  569,  569,  569,  590,  569,  569,
 647       569,  569,  569,  569,  591,  579,  579,  579,  569,  569,
 648       569,  592,  569,  569,  593,  569,  579,  579,  579,  579,
 649       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 650
 651       579,  579,  579,  579,  569,  594,  579,  579,  579,  579,
 652       579,  579,  579,  579,  579,  579,  579,  579,  579,  569,
 653       569,  569,  569,  569,  595,  569,  569,  569,  569,  569,
 654       569,  569,  569,  569,  569,  569,  569,  569,  585,  569,
 655       569,  586,  587,  596,  597,  598,  579,  579,  579,  579,
 656       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 657       569,  569,  569,  569,  579,  579,  569,  569,  569,  569,
 658       569,  569,  569,  590,  569,  569,  591,  569,  579,  579,
 659       579,  569,  569,  592,  569,  593,  583,  579,  579,  579,
 660       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 661
 662       579,  579,  579,  579,  579,  579,  579,  594,  569,  579,
 663       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 664       579,  579,  599,  569,  569,  600,  597,  569,  598,  588,
 665       579,  579,  579,  579,  569,  569,  569,  569,  569,  569,
 666       569,  569,  569,  569,  569,  569,  569,  579,  579,  569,
 667       569,  569,  569,  569,  579,  579,  579,  569,  569,  579,
 668       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 669       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 670       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 671       579,  579,  569,  569,  599,  569,  600,  579,  579,  579,
 672
 673       569,  569,  569,  569,  569,  569,  569,  569,  579,  579,
 674       601,  569,  579,  579,  579,  579,  579,  579,  579,  579,
 675       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 676       579,  579,  579,  579,  579,  579,  579,  579,  569,  569,
 677       569,  569,  569,  569,  569,  579,  579,  569,  569,  579,
 678       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 679       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 680       569,  569,  569,  569,  569,  569,  579,  579,  569,  569,
 681       579,  579,  579,  579,  579,  579,  579,  579,  579,  579,
 682       579,  579,  579,  579,  579,  579,  569,  569,  569,  569,
 683
 684       569,  569,  579,  579,  569,  569,  579,  579,  579,  579,
 685       579,  579,  579,  579,  579,  579,  579,  579,  569,  569,
 686       602,  569,  569,  569,  569,  569,  569,  569,  569,  579,
 687       579,  579,  579,  579,  579,  579,  579,  602,  569,  569,
 688       569,  569,  569,  569,  569,  603,  579,  579,  579,  579,
 689       579,  569,  569,  569,  569,  603,  569,  579,  579,  569,
 690       569,  579,  569,  569,  579,  569,  569,  569,    0,  569,
 691       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 692       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 693       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 694
 695       569,  569,  569
 696     } ;
 697
 698 static yyconst flex_int16_t yy_nxt[1430] =
 699     {   0,
 700        26,   27,   28,   27,   29,   27,   26,   26,   26,   30,
 701        26,   26,   26,   31,   32,   33,   34,   34,   34,   35,
 702        26,   26,   36,   36,   36,   36,   36,   36,   26,   26,
 703        26,   36,   36,   36,   37,   36,   38,   39,   36,   36,
 704        36,   36,   36,   36,   36,   36,   36,   36,   36,   36,
 705        36,   36,   36,   36,   36,   36,   36,   26,   26,   40,
 706        46,  144,   47,   40,  152,   41,   42,   46,  152,   47,
 707        48,   52,   49,   53,  135,   54,  136,   48,   55,  144,
 708        68,  144,   63,   56,   64,  145,   65,   63,   69,   64,
 709        50,   65,   67,   68,   41,   75,  144,   76,   57,   77,
 710
 711       144,   69,   28,  148,  117,   43,  153,   44,   70,   66,
 712        36,   71,  118,  160,   66,   75,  144,   76,  219,   77,
 713        79,   70,   78,   36,   71,   72,   58,   59,   52,  144,
 714        53,   73,   54,   60,   61,   55,  144,  441,   72,   99,
 715        56,  441,   78,   26,   73,   41,  159,   28,   99,  123,
 716       119,   28,   26,  117,  119,   57,  120,  124,  167,  177,
 717       168,  121,  174,   36,  175,   36,   36,  125,   28,  248,
 718       123,  125,   36,  126,   36,   36,  144,   28,  127,  129,
 719       144,  144,  163,   58,   59,   80,   97,  130,  144,   28,
 720       144,  129,   81,   82,  131,   97,  178,  144,   83,  130,
 721
 722       134,  134,  134,  134,  144,  164,  146,   84,  191,  144,
 723       147,   85,  176,   86,   87,   88,   89,  152,  181,   90,
 724       182,  152,   91,  144,  196,   92,   93,  187,  193,   94,
 725        72,   95,   96,  165,  166,  192,   97,   98,  100,  144,
 726       149,  144,  101,  102,  149,  137,  103,  138,  138,  138,
 727       139,  137,  266,  141,  141,  141,  141,  152,  170,  153,
 728       152,  152,  170,  211,  152,  104,  105,  106,  107,  108,
 729       263,  197,   90,  263,  198,   91,  109,  110,  111,  112,
 730       264,  563,  113,  114,   95,  115,  150,  140,  151,  154,
 731       180,  155,  134,  134,  134,  134,  156,  171,  144,  153,
 732
 733       153,  144,  153,  144,  157,  183,  183,  183,  183,  184,
 734       184,  184,  184,  144,  158,  144,  144,  205,  188,  206,
 735       144,  144,  189,  144,  186,  190,  144,  194,  152,  144,
 736       195,  144,  152,  199,  200,  144,  144,  203,  209,  144,
 737       144,  202,  212,  204,  207,  201,  188,  208,  191,  210,
 738       213,  144,  214,  190,  216,  199,  218,  221,  204,  233,
 739       215,  221,  223,  224,  217,  227,  225,  201,  222,  227,
 740       153,  234,  311,  152,  144,  220,  228,  152,  229,  230,
 741       152,  233,  229,  269,  152,  238,  238,  238,  238,  231,
 742       144,  232,  241,  241,  241,  241,  137,  144,  138,  138,
 743
 744       138,  139,  137,  247,  139,  139,  139,  139,  137,  260,
 745       141,  141,  141,  141,  149,  153,  144,  152,  149,  144,
 746       144,  152,  153,  254,  261,  255,  144,  249,  170,  250,
 747       262,  256,  170,  279,  270,  271,  265,  144,  144,  257,
 748       183,  183,  183,  183,  144,  258,  184,  184,  184,  184,
 749       144,  144,  144,  280,  144,  144,  144,  288,  281,  153,
 750       150,  186,  151,  289,  290,  144,  144,  171,  144,  144,
 751       153,  144,  144,  144,  144,  144,  144,  292,  291,  144,
 752       144,  144,  294,  297,  144,  300,  144,  293,  295,  298,
 753       144,  296,  302,  144,  144,  299,  301,  304,  312,  314,
 754
 755       307,  144,  303,  144,  306,  144,  144,  305,  310,  318,
 756       560,  221,  144,  294,  313,  221,  316,  144,  317,  144,
 757       315,  144,  222,  319,  321,  223,  224,  223,  224,  225,
 758       144,  223,  144,  320,  322,  223,  224,  227,  144,  223,
 759       144,  227,  229,  230,  332,  348,  229,  144,  228,  334,
 760       325,  230,  331,  231,  325,  324,  238,  238,  238,  238,
 761       241,  241,  241,  241,  342,  333,  144,  144,  358,  359,
 762       144,  144,  358,  349,  144,  343,  144,  144,  355,  184,
 763       184,  184,  184,  144,  144,  144,  144,  144,  144,  144,
 764       144,  356,  144,  144,  186,  144,  144,  364,  357,  366,
 765
 766       144,  361,  365,  360,  367,  362,  144,  363,  144,  144,
 767       144,  379,  144,  372,  368,  144,  370,  377,  144,  374,
 768       371,  369,  373,  375,  144,  381,  144,  376,  382,  144,
 769       144,  384,  144,  144,  144,  383,  393,  394,  378,  380,
 770       393,  388,  144,  390,  144,  385,  387,  386,  144,  389,
 771       144,  392,  325,  230,  396,  405,  325,  144,  144,  391,
 772       144,  258,  358,  359,  144,  144,  358,  144,  144,  144,
 773       144,  410,  144,  398,  399,  144,  144,  144,  144,  400,
 774       144,  409,  144,  419,  144,  413,  144,  144,  144,  357,
 775       144,  416,  420,  421,  144,  414,  430,  415,  422,  418,
 776
 777       417,  424,  426,  428,  423,  425,  427,  144,  144,  144,
 778       431,  429,  144,  144,  144,  144,  144,  144,  144,  432,
 779       433,  434,  393,  394,  393,  394,  393,  437,  393,  393,
 780       394,  425,  435,  393,  436,  450,  144,  144,  438,  446,
 781       144,  144,  396,  144,  144,  144,  447,  144,  144,  144,
 782       144,  144,  451,  452,  144,  144,  144,  144,  453,  456,
 783       457,  144,  463,  459,  462,  144,  144,  458,  466,  144,
 784       144,  455,  454,  144,  144,  461,  144,  144,  464,  144,
 785       460,  470,  144,  144,  441,  144,  144,  465,  441,  483,
 786       467,  478,  144,  477,  468,  144,  481,  469,  473,  473,
 787
 788       473,  473,  484,  482,  144,  144,  144,  488,  485,  486,
 789       144,  489,  487,  144,  501,  144,  144,  144,  490,  144,
 790       262,  144,  495,  499,  144,  144,  144,  499,  144,  491,
 791       493,  494,  503,  144,  144,  508,  492,  473,  473,  473,
 792       473,  509,  511,  144,  512,  496,  504,  144,  507,  144,
 793       525,  144,  526,  529,  525,  514,  526,  529,  510,  144,
 794       144,  515,  144,  513,  527,  528,  528,  531,  144,  144,
 795       144,  516,  144,  144,  144,  144,  530,  525,  526,  517,
 796       144,  525,  526,  144,  546,  144,  518,  144,  532,  534,
 797       525,  144,  547,  548,  525,  144,  533,  535,  546,  526,
 798
 799       549,  552,  537,  526,  542,  542,  542,  542,  551,  557,
 800       536,  558,  254,  543,  543,  543,  543,  544,  544,  544,
 801       544,  545,  144,  550,  557,  544,  544,  544,  544,  553,
 802       554,  144,  555,  553,  543,  543,  543,  543,  539,  559,
 803       144,  144,  557,  542,  542,  542,  542,  545,  144,  144,
 804       541,  544,  544,  544,  544,  553,  554,  557,  565,  553,
 805       561,  561,  561,  561,  562,  564,  261,  561,  561,  561,
 806       561,  566,  566,  566,  566,  567,  568,  567,  568,  567,
 807       540,  567,  539,  144,  144,  144,  144,  524,  523,  566,
 808       566,  566,  566,   45,   45,   45,   45,   45,   45,   45,
 809
 810        45,   45,   45,   51,   51,   51,   51,   51,   51,   51,
 811        51,   51,   51,   62,   62,   62,   62,   62,   62,   62,
 812        62,   62,   62,   74,   74,   74,   74,   74,   74,   74,
 813        74,   74,   74,  116,  116,  116,  116,  116,  116,  116,
 814       116,  116,  116,  122,  122,  122,  122,  122,  122,  122,
 815       122,  122,  122,  128,  128,  128,  128,  128,  128,  128,
 816       128,  128,  128,  132,  132,  522,  132,  132,  132,  132,
 817       132,  132,  132,  142,  142,  143,  143,  143,  143,  169,
 818       169,  521,  169,  169,  169,  169,  169,  169,  169,  173,
 819       173,  520,  173,  173,  173,  173,  173,  173,  173,  179,
 820
 821       179,  519,  179,  179,  179,  179,  179,  179,  179,  185,
 822       144,  185,  185,  185,  236,  236,  144,  236,  236,  236,
 823       236,  236,  236,  236,  239,  239,  239,  239,  239,  239,
 824       239,  239,  239,  239,  242,  144,  242,  243,  243,  243,
 825       243,  246,  246,  246,  267,  267,  144,  267,  267,  267,
 826       267,  267,  267,  267,  274,  274,  274,  274,  274,  274,
 827       274,  274,  274,  274,  277,  277,  277,  277,  277,  277,
 828       277,  277,  277,  277,  284,  284,  284,  284,  284,  284,
 829       284,  284,  284,  284,  286,  506,  286,  286,  286,  308,
 830       308,  308,  308,  308,  308,  308,  308,  308,  308,  323,
 831
 832       323,  505,  502,  500,  498,  323,  323,  326,  326,  327,
 833       327,  327,  327,  329,  329,  329,  329,  395,  395,  497,
 834       144,  395,  395,  395,  395,  397,  397,  397,  397,  448,
 835       448,  144,  448,  448,  448,  448,  448,  448,  448,  538,
 836       538,  144,  144,  144,  538,  538,  538,  538,  538,  556,
 837       556,  480,  556,  479,  556,  556,  556,  556,  556,  476,
 838       475,  257,  474,  472,  471,  144,  144,  144,  144,  144,
 839       449,  445,  444,  343,  443,  442,  440,  439,  144,  144,
 840       144,  244,  144,  144,  144,  144,  144,  144,  144,  144,
 841       144,  412,  411,  408,  407,  406,  404,  403,  402,  401,
 842
 843       144,  569,  330,  245,  328,  244,  309,  144,  186,  285,
 844       278,  354,  275,  353,  352,  351,  350,  347,  346,  345,
 845       344,  341,  340,  339,  338,  337,  336,  335,  330,  328,
 846       244,  240,  235,  235,  324,  309,  287,  186,  285,  283,
 847       282,  278,  276,  275,  273,  272,  268,  259,  253,  252,
 848       251,  245,  144,  244,  240,  237,  235,  233,  233,  226,
 849       220,  172,  162,  161,  144,  133,  569,   41,   41,   25,
 850       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 851       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 852       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 853
 854       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 855       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
 856       569,  569,  569,  569,  569,  569,  569,  569,  569
 857     } ;
 858
 859 static yyconst flex_int16_t yy_chk[1430] =
 860     {   0,
 861         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 862         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 863         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 864         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 865         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 866         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
 867         3,   37,    3,    2,   41,    2,    2,    4,   41,    4,
 868         3,    5,    4,    5,   32,    5,   32,    4,    5,   39,
 869         9,  114,    7,    5,    7,   37,    7,    8,    9,    8,
 870         4,    8,    8,   10,   10,   11,   44,   11,    5,   11,
 871
 872       565,   10,   19,   39,   19,    2,   41,    2,    9,    7,
 873         9,    9,   19,   44,    8,   12,   43,   12,  114,   12,
 874        12,   10,   11,   10,   10,    9,    5,    5,    6,   71,
 875         6,    9,    6,    6,    6,    6,  146,  403,   10,   15,
 876         6,  403,   12,   15,   10,   16,   43,   21,   16,   21,
 877        20,   20,   16,   20,   20,    6,   20,   21,   56,   71,
 878        56,   20,   69,   15,   69,   15,   15,   22,   22,  146,
 879        22,   22,   16,   22,   16,   16,   72,   23,   22,   23,
 880        38,   87,   55,    6,    6,   13,   15,   23,   70,   24,
 881        92,   24,   13,   13,   24,   16,   72,   85,   13,   24,
 882
 883        31,   31,   31,   31,   89,   55,   38,   13,   87,   88,
 884        38,   13,   70,   13,   13,   13,   13,   49,   82,   13,
 885        82,   49,   13,  160,   92,   13,   13,   85,   89,   13,
 886        13,   13,   13,   55,   55,   88,   13,   13,   17,  108,
 887        40,   93,   17,   17,   40,   33,   17,   33,   33,   33,
 888        33,   34,  160,   34,   34,   34,   34,   67,   60,   49,
 889        79,   67,   60,  108,   79,   17,   17,   17,   17,   17,
 890       157,   93,   17,  563,   93,   17,   17,   17,   17,   17,
 891       157,  560,   17,   17,   17,   17,   40,   33,   40,   42,
 892        81,   42,   81,   81,   81,   81,   42,   60,   86,   67,
 893
 894        60,   90,   79,   91,   42,   83,   83,   83,   83,   84,
 895        84,   84,   84,   94,   42,   95,   96,  103,   86,  103,
 896       104,  106,   86,  107,   84,   86,  105,   90,  120,  109,
 897        91,  115,  120,   94,   94,  113,  208,   96,  106,  110,
 898       111,   95,  109,   96,  104,   94,  105,  104,  106,  107,
 899       109,  112,  110,  105,  111,  113,  113,  119,  115,  130,
 900       110,  119,  121,  121,  112,  125,  121,  113,  119,  125,
 901       120,  130,  208,  126,  559,  121,  125,  126,  127,  127,
 902       131,  131,  127,  164,  131,  134,  134,  134,  134,  127,
 903       145,  127,  137,  137,  137,  137,  138,  147,  138,  138,
 904
 905       138,  138,  139,  145,  139,  139,  139,  139,  141,  156,
 906       141,  141,  141,  141,  149,  126,  148,  152,  149,  159,
 907       176,  152,  131,  154,  156,  154,  177,  147,  170,  148,
 908       156,  154,  170,  176,  164,  164,  159,  178,  187,  154,
 909       183,  183,  183,  183,  191,  154,  184,  184,  184,  184,
 910       188,  189,  190,  177,  192,  193,  194,  187,  178,  152,
 911       149,  184,  149,  188,  189,  195,  196,  170,  197,  199,
 912       170,  198,  201,  200,  203,  207,  202,  191,  190,  204,
 913       209,  210,  193,  196,  212,  198,  211,  192,  194,  197,
 914       213,  195,  200,  214,  215,  197,  199,  202,  209,  211,
 915
 916       204,  216,  201,  217,  203,  218,  219,  202,  207,  215,
 917       552,  221,  551,  211,  210,  221,  213,  549,  214,  248,
 918       212,  247,  221,  216,  218,  222,  222,  223,  223,  222,
 919       250,  223,  265,  217,  219,  225,  225,  227,  249,  225,
 920       266,  227,  228,  228,  248,  265,  228,  279,  227,  250,
 921       229,  229,  247,  228,  229,  228,  238,  238,  238,  238,
 922       241,  241,  241,  241,  259,  249,  280,  281,  283,  283,
 923       288,  289,  283,  266,  290,  259,  291,  293,  279,  287,
 924       287,  287,  287,  292,  297,  296,  294,  298,  299,  300,
 925       303,  280,  301,  302,  287,  307,  305,  292,  281,  294,
 926
 927       304,  289,  293,  288,  296,  290,  306,  291,  311,  310,
 928       313,  307,  314,  300,  297,  312,  299,  305,  318,  302,
 929       299,  298,  301,  303,  315,  311,  316,  304,  312,  317,
 930       320,  314,  319,  321,  322,  313,  323,  323,  306,  310,
 931       323,  318,  331,  320,  333,  315,  317,  316,  334,  319,
 932       349,  322,  325,  325,  323,  340,  325,  348,  355,  321,
 933       360,  340,  358,  358,  362,  363,  358,  364,  366,  368,
 934       369,  349,  373,  331,  333,  370,  371,  372,  378,  334,
 935       376,  348,  380,  369,  377,  360,  382,  375,  374,  355,
 936       384,  364,  370,  371,  381,  362,  380,  363,  372,  368,
 937
 938       366,  374,  375,  377,  373,  374,  376,  385,  383,  386,
 939       381,  378,  389,  390,  391,  409,  410,  414,  413,  382,
 940       383,  384,  393,  393,  395,  395,  393,  389,  395,  396,
 941       396,  391,  385,  396,  386,  413,  416,  418,  390,  409,
 942       419,  420,  395,  424,  421,  422,  410,  425,  426,  428,
 943       431,  429,  414,  416,  432,  433,  434,  435,  418,  421,
 944       422,  436,  431,  425,  429,  437,  446,  424,  434,  438,
 945       450,  420,  419,  453,  447,  428,  455,  456,  432,  463,
 946       426,  438,  451,  462,  441,  454,  464,  433,  441,  453,
 947       435,  447,  465,  446,  436,  461,  450,  437,  441,  441,
 948
 949       441,  441,  454,  451,  466,  467,  468,  462,  455,  456,
 950       469,  463,  461,  470,  475,  478,  481,  477,  464,  482,
 951       475,  485,  469,  473,  483,  486,  489,  473,  487,  465,
 952       467,  468,  477,  491,  492,  482,  466,  473,  473,  473,
 953       473,  483,  486,  490,  487,  470,  478,  495,  481,  496,
 954       503,  511,  504,  506,  503,  490,  504,  506,  485,  508,
 955       513,  491,  514,  489,  505,  505,  505,  511,  503,  516,
 956       504,  492,  515,  517,  518,  532,  508,  519,  520,  495,
 957       533,  519,  520,  535,  529,  547,  496,  548,  513,  515,
 958       525,  537,  532,  533,  525,  536,  514,  516,  529,  526,
 959
 960       535,  541,  518,  526,  525,  525,  525,  525,  537,  546,
 961       517,  548,  540,  526,  526,  526,  526,  527,  527,  527,
 962       527,  528,  550,  536,  546,  528,  528,  528,  528,  542,
 963       542,  558,  543,  542,  543,  543,  543,  543,  538,  550,
 964       534,  562,  556,  542,  542,  542,  542,  544,  531,  530,
 965       524,  544,  544,  544,  544,  553,  553,  556,  562,  553,
 966       555,  555,  555,  555,  558,  561,  523,  561,  561,  561,
 967       561,  564,  564,  564,  564,  566,  566,  567,  567,  566,
 968       522,  567,  521,  512,  510,  509,  507,  502,  501,  566,
 969       566,  566,  566,  570,  570,  570,  570,  570,  570,  570,
 970
 971       570,  570,  570,  571,  571,  571,  571,  571,  571,  571,
 972       571,  571,  571,  572,  572,  572,  572,  572,  572,  572,
 973       572,  572,  572,  573,  573,  573,  573,  573,  573,  573,
 974       573,  573,  573,  574,  574,  574,  574,  574,  574,  574,
 975       574,  574,  574,  575,  575,  575,  575,  575,  575,  575,
 976       575,  575,  575,  576,  576,  576,  576,  576,  576,  576,
 977       576,  576,  576,  577,  577,  500,  577,  577,  577,  577,
 978       577,  577,  577,  578,  578,  579,  579,  579,  579,  580,
 979       580,  499,  580,  580,  580,  580,  580,  580,  580,  581,
 980       581,  498,  581,  581,  581,  581,  581,  581,  581,  582,
 981
 982       582,  497,  582,  582,  582,  582,  582,  582,  582,  583,
 983       494,  583,  583,  583,  584,  584,  493,  584,  584,  584,
 984       584,  584,  584,  584,  585,  585,  585,  585,  585,  585,
 985       585,  585,  585,  585,  586,  488,  586,  587,  587,  587,
 986       587,  588,  588,  588,  589,  589,  484,  589,  589,  589,
 987       589,  589,  589,  589,  590,  590,  590,  590,  590,  590,
 988       590,  590,  590,  590,  591,  591,  591,  591,  591,  591,
 989       591,  591,  591,  591,  592,  592,  592,  592,  592,  592,
 990       592,  592,  592,  592,  593,  480,  593,  593,  593,  594,
 991       594,  594,  594,  594,  594,  594,  594,  594,  594,  595,
 992
 993       595,  479,  476,  474,  472,  595,  595,  596,  596,  597,
 994       597,  597,  597,  598,  598,  598,  598,  599,  599,  471,
 995       460,  599,  599,  599,  599,  600,  600,  600,  600,  601,
 996       601,  459,  601,  601,  601,  601,  601,  601,  601,  602,
 997       602,  458,  457,  452,  602,  602,  602,  602,  602,  603,
 998       603,  449,  603,  448,  603,  603,  603,  603,  603,  445,
 999       444,  443,  442,  440,  439,  430,  427,  423,  417,  415,
1000       412,  408,  407,  406,  405,  404,  402,  401,  400,  399,
1001       398,  397,  392,  388,  387,  379,  367,  365,  361,  357,
1002       356,  354,  350,  347,  344,  342,  339,  337,  336,  335,
1003
1004       332,  330,  329,  328,  327,  326,  308,  295,  286,  284,
1005       277,  276,  274,  271,  270,  269,  267,  264,  263,  261,
1006       260,  257,  256,  255,  254,  253,  252,  251,  246,  245,
1007       243,  239,  237,  236,  231,  206,  186,  185,  182,  181,
1008       180,  175,  171,  168,  166,  165,  163,  155,  153,  151,
1009       150,  144,  143,  142,  136,  133,  132,  129,  128,  124,
1010       118,   61,   50,   48,   36,   30,   25,   18,   14,  569,
1011       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
1012       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
1013       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
1014
1015       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
1016       569,  569,  569,  569,  569,  569,  569,  569,  569,  569,
1017       569,  569,  569,  569,  569,  569,  569,  569,  569
1018     } ;
1019
1020 extern int yy_flex_debug;
1021 int yy_flex_debug = 0;
1022
1023 static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
1024 static char *yy_full_match;
1025 static int yy_lp;
1026 #define REJECT \
1027 { \
1028 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
1029 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
1030 ++(yy_lp); \
1031 goto find_rule; \
1032 }
1033
1034 #define yymore() yymore_used_but_not_detected
1035 #define YY_MORE_ADJ 0
1036 #define YY_RESTORE_YY_MORE_OFFSET
1037 char *yytext;
1038 #line 1 "lexer.l"
1039 /* GOB C Preprocessor
1040  * Copyright (C) 1999-2000 the Free Software Foundation.
1041  * Copyright (C) 2000 Eazel, Inc.
1042  * Copyright (C) 2001-2011 George (Jiri) Lebl
1043  *
1044  * Author: George Lebl
1045  *
1046  * This program is free software; you can redistribute it and/or modify
1047  * it under the terms of the GNU General Public License as published by
1048  * the Free Software Foundation; either version 2 of the License, or
1049  * (at your option) any later version.
1050  *
1051  * This program is distributed in the hope that it will be useful,
1052  * but WITHOUT ANY WARRANTY; without even the implied warranty of
1053  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1054  * GNU General Public License for more details.
1055  *
1056  * You should have received a copy of the GNU General Public License
1057  * along with this program; if not, write to the  Free Software
1058  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
1059  * USA.
1060  */
1061 #line 24 "lexer.l"
1062
1063 #include "config.h"
1064 #include <stdlib.h>
1065 #include <string.h>
1066 #include <ctype.h>
1067 #include <glib.h>
1068
1069 #include "treefuncs.h"
1070 #include "parse.h"
1071 #include "main.h"
1072 #include "util.h"
1073
1074 static int parenth_depth = 0;
1075 static int before_comment
1076 /* New flex is on drugs */
1077 #if defined(FLEX_SCANNER) && ! defined(INITIAL)
1078         = 0;
1079 #else
1080         = INITIAL;
1081 #endif
1082 static gboolean class_after_c = FALSE;
1083 static int code_type = CCODE;
1084 static int before_string;
1085 static int property_paren_depth = 0;
1086
1087 /* GTK+ doc stuff */
1088 static char *gtk_doc_func = NULL; /* current gtk-doc func */
1089 GHashTable *gtk_doc_hash = NULL;
1090
1091 static GString *cbuf = NULL;
1092 int ccode_line = 1;
1093
1094 GList *include_files = NULL;
1095 /* 0 no, 1 means yes, 2+ means don't even start looking anymore */
1096 static int look_for_includes = 0;
1097
1098 int line_no = 1;
1099 /* last filename parsed from a #line directive */
1100 char *hline_filename = NULL;
1101
1102 static void
1103 clear_cbuf(void)
1104 {
1105         if(!cbuf) {
1106                 cbuf = g_string_new(NULL);
1107         } else {
1108                 cbuf = g_string_assign(cbuf, "");
1109         }
1110 }
1111
1112 static void
1113 add_to_cbuf(char *s)
1114 {
1115         if(!cbuf) {
1116                 cbuf = g_string_new(s);
1117         } else {
1118                 cbuf = g_string_append(cbuf,s);
1119         }
1120 }
1121
1122 static void
1123 add_gtk_doc_func(void)
1124 {
1125         if(!gtk_doc_func)
1126                 return;
1127
1128         if(!gtk_doc_hash)
1129                 gtk_doc_hash = g_hash_table_new(g_str_hash, g_str_equal);
1130         g_hash_table_insert(gtk_doc_hash, gtk_doc_func, g_strdup(cbuf->str));
1131         clear_cbuf();
1132
1133         gtk_doc_func = NULL;
1134 }
1135
1136 /* Ugly warning / error avoidings */
1137 #ifdef FLEX_SCANNER
1138 int yylex(void);
1139 int yywrap(void) { return 1; }
1140 #endif
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153 #line 1154 "lexer.c"
1154
1155 #define INITIAL 0
1156 #define COMMENT 1
1157 #define C_CODE 2
1158 #define CODE_STRING 3
1159 #define CLASS_CODE 4
1160 #define CLASS_STRING 5
1161 #define CLASS_CODE_I 6
1162 #define PROPERTY_CODE 7
1163 #define PROPERTY_CODE_I 8
1164 #define GTK_DOC_BEFORE_NAME 9
1165 #define GTK_DOC 10
1166 #define GTK_DOC_LINE 11
1167
1168 #ifndef YY_NO_UNISTD_H
1169 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1170  * down here because we want the user's section 1 to have been scanned first.
1171  * The user has a chance to override it with an option.
1172  */
1173 #include <unistd.h>
1174 #endif
1175
1176 #ifndef YY_EXTRA_TYPE
1177 #define YY_EXTRA_TYPE void *
1178 #endif
1179
1180 static int yy_init_globals (void );
1181
1182 /* Accessor methods to globals.
1183    These are made visible to non-reentrant scanners for convenience. */
1184
1185 int yylex_destroy (void );
1186
1187 int yyget_debug (void );
1188
1189 void yyset_debug (int debug_flag  );
1190
1191 YY_EXTRA_TYPE yyget_extra (void );
1192
1193 void yyset_extra (YY_EXTRA_TYPE user_defined  );
1194
1195 FILE *yyget_in (void );
1196
1197 void yyset_in  (FILE * in_str  );
1198
1199 FILE *yyget_out (void );
1200
1201 void yyset_out  (FILE * out_str  );
1202
1203 yy_size_t yyget_leng (void );
1204
1205 char *yyget_text (void );
1206
1207 int yyget_lineno (void );
1208
1209 void yyset_lineno (int line_number  );
1210
1211 /* Macros after this point can all be overridden by user definitions in
1212  * section 1.
1213  */
1214
1215 #ifndef YY_SKIP_YYWRAP
1216 #ifdef __cplusplus
1217 extern "C" int yywrap (void );
1218 #else
1219 extern int yywrap (void );
1220 #endif
1221 #endif
1222
1223     static void yyunput (int c,char *buf_ptr  );
1224
1225 #ifndef yytext_ptr
1226 static void yy_flex_strncpy (char *,yyconst char *,int );
1227 #endif
1228
1229 #ifdef YY_NEED_STRLEN
1230 static int yy_flex_strlen (yyconst char * );
1231 #endif
1232
1233 #ifndef YY_NO_INPUT
1234
1235 #ifdef __cplusplus
1236 static int yyinput (void );
1237 #else
1238 static int input (void );
1239 #endif
1240
1241 #endif
1242
1243 /* Amount of stuff to slurp up with each read. */
1244 #ifndef YY_READ_BUF_SIZE
1245 #define YY_READ_BUF_SIZE 8192
1246 #endif
1247
1248 /* Copy whatever the last rule matched to the standard output. */
1249 #ifndef ECHO
1250 /* This used to be an fputs(), but since the string might contain NUL's,
1251  * we now use fwrite().
1252  */
1253 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1254 #endif
1255
1256 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1257  * is returned in "result".
1258  */
1259 #ifndef YY_INPUT
1260 #define YY_INPUT(buf,result,max_size) \
1261         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1262                 { \
1263                 int c = '*'; \
1264                 size_t n; \
1265                 for ( n = 0; n < max_size && \
1266                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1267                         buf[n] = (char) c; \
1268                 if ( c == '\n' ) \
1269                         buf[n++] = (char) c; \
1270                 if ( c == EOF && ferror( yyin ) ) \
1271                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1272                 result = n; \
1273                 } \
1274         else \
1275                 { \
1276                 errno=0; \
1277                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1278                         { \
1279                         if( errno != EINTR) \
1280                                 { \
1281                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1282                                 break; \
1283                                 } \
1284                         errno=0; \
1285                         clearerr(yyin); \
1286                         } \
1287                 }\
1288 \
1289
1290 #endif
1291
1292 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1293  * we don't want an extra ';' after the "return" because that will cause
1294  * some compilers to complain about unreachable statements.
1295  */
1296 #ifndef yyterminate
1297 #define yyterminate() return YY_NULL
1298 #endif
1299
1300 /* Number of entries by which start-condition stack grows. */
1301 #ifndef YY_START_STACK_INCR
1302 #define YY_START_STACK_INCR 25
1303 #endif
1304
1305 /* Report a fatal error. */
1306 #ifndef YY_FATAL_ERROR
1307 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1308 #endif
1309
1310 /* end tables serialization structures and prototypes */
1311
1312 /* Default declaration of generated scanner - a define so the user can
1313  * easily add parameters.
1314  */
1315 #ifndef YY_DECL
1316 #define YY_DECL_IS_OURS 1
1317
1318 extern int yylex (void);
1319
1320 #define YY_DECL int yylex (void)
1321 #endif /* !YY_DECL */
1322
1323 /* Code executed at the beginning of each rule, after yytext and yyleng
1324  * have been set up.
1325  */
1326 #ifndef YY_USER_ACTION
1327 #define YY_USER_ACTION
1328 #endif
1329
1330 /* Code executed at the end of each rule. */
1331 #ifndef YY_BREAK
1332 #define YY_BREAK break;
1333 #endif
1334
1335 #define YY_RULE_SETUP \
1336         if ( yyleng > 0 ) \
1337                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1338                                 (yytext[yyleng - 1] == '\n'); \
1339         YY_USER_ACTION
1340
1341 /** The main scanner function which does all the work.
1342  */
1343 YY_DECL
1344 {
1345         register yy_state_type yy_current_state;
1346         register char *yy_cp, *yy_bp;
1347         register int yy_act;
1348
1349 #line 120 "lexer.l"
1350
1351
1352
1353 /* Avoid warning from flex, cuz flex sucks */
1354 #ifdef FLEX_SCANNER
1355 yy_current_state = 0;
1356 #endif
1357
1358
1359
1360 #line 1361 "lexer.c"
1361
1362         if ( !(yy_init) )
1363                 {
1364                 (yy_init) = 1;
1365
1366 #ifdef YY_USER_INIT
1367                 YY_USER_INIT;
1368 #endif
1369
1370         /* Create the reject buffer large enough to save one state per allowed character. */
1371         if ( ! (yy_state_buf) )
1372             (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
1373             if ( ! (yy_state_buf) )
1374                 YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
1375
1376                 if ( ! (yy_start) )
1377                         (yy_start) = 1; /* first start state */
1378
1379                 if ( ! yyin )
1380                         yyin = stdin;
1381
1382                 if ( ! yyout )
1383                         yyout = stdout;
1384
1385                 if ( ! YY_CURRENT_BUFFER ) {
1386                         yyensure_buffer_stack ();
1387                         YY_CURRENT_BUFFER_LVALUE =
1388                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1389                 }
1390
1391                 yy_load_buffer_state( );
1392                 }
1393
1394         while ( 1 )             /* loops until end-of-file is reached */
1395                 {
1396                 yy_cp = (yy_c_buf_p);
1397
1398                 /* Support of yytext. */
1399                 *yy_cp = (yy_hold_char);
1400
1401                 /* yy_bp points to the position in yy_ch_buf of the start of
1402                  * the current run.
1403                  */
1404                 yy_bp = yy_cp;
1405
1406                 yy_current_state = (yy_start);
1407                 yy_current_state += YY_AT_BOL();
1408
1409                 (yy_state_ptr) = (yy_state_buf);
1410                 *(yy_state_ptr)++ = yy_current_state;
1411
1412 yy_match:
1413                 do
1414                         {
1415                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1416                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1417                                 {
1418                                 yy_current_state = (int) yy_def[yy_current_state];
1419                                 if ( yy_current_state >= 570 )
1420                                         yy_c = yy_meta[(unsigned int) yy_c];
1421                                 }
1422                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1423                         *(yy_state_ptr)++ = yy_current_state;
1424                         ++yy_cp;
1425                         }
1426                 while ( yy_base[yy_current_state] != 1370 );
1427
1428 yy_find_action:
1429                 yy_current_state = *--(yy_state_ptr);
1430                 (yy_lp) = yy_accept[yy_current_state];
1431 find_rule: /* we branch to this label when backing up */
1432                 for ( ; ; ) /* until we find what rule we matched */
1433                         {
1434                         if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
1435                                 {
1436                                 yy_act = yy_acclist[(yy_lp)];
1437                                         {
1438                                         (yy_full_match) = yy_cp;
1439                                         break;
1440                                         }
1441                                 }
1442                         --yy_cp;
1443                         yy_current_state = *--(yy_state_ptr);
1444                         (yy_lp) = yy_accept[yy_current_state];
1445                         }
1446
1447                 YY_DO_BEFORE_ACTION;
1448
1449 do_action:      /* This label is used only to access EOF actions. */
1450
1451                 switch ( yy_act )
1452         { /* beginning of action switch */
1453 case 1:
1454 /* rule 1 can match eol */
1455 YY_RULE_SETUP
1456 #line 130 "lexer.l"
1457 { line_no++; REJECT; }
1458         YY_BREAK
1459 case 2:
1460 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1461 (yy_c_buf_p) = yy_cp -= 1;
1462 YY_DO_BEFORE_ACTION; /* set up yytext again */
1463 YY_RULE_SETUP
1464 #line 132 "lexer.l"
1465 {
1466 /* Thy evil easter egg */
1467 #define QQ(x) long x
1468 #define KK(x) =atoi(__(&,,x,))
1469 #define MM(x,a) {QQ(i);for(i=2;i<x;i++){a}}
1470 #define PP(Q) (P%Q)==0
1471 #define ___(x,y,z) if(x z y)
1472 #define __(a,x,y,z) a(yytext[y] x z)
1473 #define O__O(a,b) fprintf(stderr,"%s is %s!\n",a,b)
1474 QQ(m)=1;___(__(,==,2,'P'),__(,==,5,'M'),&&
1475 ){QQ(P)KK(8);MM(P,___(PP(i),,)m=0;)}__(,=,
1476 7,0);___(,,m){O__O(__( &,,8,),__(&,,2,));}
1477 #undef QQ
1478 #undef KK
1479 #undef MM
1480 #undef PP
1481 #undef ___
1482 #undef __
1483 #undef O__O
1484 REJECT;
1485 }
1486         YY_BREAK
1487 case 3:
1488 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1489 (yy_c_buf_p) = yy_cp -= 1;
1490 YY_DO_BEFORE_ACTION; /* set up yytext again */
1491 YY_RULE_SETUP
1492 #line 154 "lexer.l"
1493 { ; /*comment, ignore*/ }
1494         YY_BREAK
1495 case 4:
1496 YY_RULE_SETUP
1497 #line 156 "lexer.l"
1498 {
1499         char *p;
1500         char *number;
1501         char *filename;
1502         char *str=g_strdup(yytext);
1503
1504         /* find first digit of line number */
1505         p=str;
1506         while(*p&&!isdigit(*p)) p++;
1507         number=p;
1508
1509         /* find end of line number */
1510         while(*p&&isdigit(*p)) p++;
1511         if(*p) *p++=0;
1512
1513         /* find beginning of filename */
1514         p=strchr(p,'"');
1515         if(p) p++;
1516         filename=p;
1517
1518         /* find end of filename */
1519         if(p) p=strchr(p,'"');
1520         if(p) *p=0;
1521
1522         /* stash number (minus one because we don't count this line) */
1523         if(number) line_no=atoi(number)-1;
1524
1525         /* stash filename */
1526         if(filename) {
1527                 if(hline_filename) g_free(hline_filename);
1528                 hline_filename=g_strdup(filename);
1529         }
1530
1531         /* clean up */
1532         g_free(str);
1533 }
1534         YY_BREAK
1535 case 5:
1536 YY_RULE_SETUP
1537 #line 193 "lexer.l"
1538 {
1539         if(look_for_includes==1) {
1540                 char *p;
1541                 char *file;
1542                 char *str = g_strdup(yytext);
1543                 file = strchr(str,'"');
1544                 if(!file) file = strchr(str,'<');
1545                 file++;
1546                 p = strchr(file,'"');
1547                 if(!p) p = strchr(file,'>');
1548                 if (p != NULL) {
1549                         *p = '\0';
1550                         include_files = g_list_prepend(include_files,g_strdup(file));
1551                         g_free(str);
1552                 }
1553         }
1554         REJECT;
1555 }
1556         YY_BREAK
1557 case 6:
1558 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1559 (yy_c_buf_p) = yy_cp -= 1;
1560 YY_DO_BEFORE_ACTION; /* set up yytext again */
1561 YY_RULE_SETUP
1562 #line 212 "lexer.l"
1563 {
1564                         /* eat out gtk doc stuff */
1565                         BEGIN(GTK_DOC_BEFORE_NAME);
1566                         clear_cbuf();
1567                 }
1568         YY_BREAK
1569 case 7:
1570 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1571 (yy_c_buf_p) = yy_cp -= 1;
1572 YY_DO_BEFORE_ACTION; /* set up yytext again */
1573 YY_RULE_SETUP
1574 #line 217 "lexer.l"
1575 {
1576                         /* empty doc lines */
1577                         ;
1578                 }
1579         YY_BREAK
1580 case 8:
1581 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1582 (yy_c_buf_p) = yy_cp -= 1;
1583 YY_DO_BEFORE_ACTION; /* set up yytext again */
1584 YY_RULE_SETUP
1585 #line 221 "lexer.l"
1586 {
1587                         char *p;
1588                         BEGIN(GTK_DOC);
1589                         p = strchr(yytext, '*');
1590                         g_free(gtk_doc_func);
1591                         gtk_doc_func = g_strdup(p+2);
1592                         p = strchr(gtk_doc_func, ':');
1593                         if(p) *p='\0';
1594                         g_strstrip(gtk_doc_func);
1595                 }
1596         YY_BREAK
1597 case 9:
1598 YY_RULE_SETUP
1599 #line 231 "lexer.l"
1600 {
1601                         BEGIN(CLASS_CODE_I);
1602                 }
1603         YY_BREAK
1604 case 10:
1605 YY_RULE_SETUP
1606 #line 234 "lexer.l"
1607 {
1608                         BEGIN(COMMENT);
1609                         before_comment = CLASS_CODE_I;
1610                 }
1611         YY_BREAK
1612 case 11:
1613 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1614 (yy_c_buf_p) = yy_cp -= 1;
1615 YY_DO_BEFORE_ACTION; /* set up yytext again */
1616 YY_RULE_SETUP
1617 #line 238 "lexer.l"
1618 {
1619                         /* empty doc lines */
1620                         add_to_cbuf(" *\n");
1621                 }
1622         YY_BREAK
1623 case 12:
1624 YY_RULE_SETUP
1625 #line 242 "lexer.l"
1626 {
1627                         BEGIN(CLASS_CODE_I);
1628                         add_gtk_doc_func();
1629                 }
1630         YY_BREAK
1631 case 13:
1632 YY_RULE_SETUP
1633 #line 246 "lexer.l"
1634 {
1635                         fflush(stdout);
1636                         add_to_cbuf(" * ");
1637                         BEGIN(GTK_DOC_LINE);
1638                 }
1639         YY_BREAK
1640 case 14:
1641 YY_RULE_SETUP
1642 #line 251 "lexer.l"
1643 {
1644                         BEGIN(CLASS_CODE_I);
1645                 }
1646         YY_BREAK
1647 case 15:
1648 YY_RULE_SETUP
1649 #line 254 "lexer.l"
1650 {
1651                         BEGIN(COMMENT);
1652                         before_comment = CLASS_CODE_I;
1653                 }
1654         YY_BREAK
1655 case 16:
1656 YY_RULE_SETUP
1657 #line 258 "lexer.l"
1658 {
1659                         BEGIN(CLASS_CODE_I);
1660                         add_to_cbuf("\n");
1661                         add_gtk_doc_func();
1662                 }
1663         YY_BREAK
1664 case 17:
1665 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1666 (yy_c_buf_p) = yy_cp -= 1;
1667 YY_DO_BEFORE_ACTION; /* set up yytext again */
1668 YY_RULE_SETUP
1669 #line 263 "lexer.l"
1670 {
1671                         BEGIN(GTK_DOC);
1672                         add_to_cbuf(yytext);
1673                         add_to_cbuf("\n");
1674                 }
1675         YY_BREAK
1676 case 18:
1677 YY_RULE_SETUP
1678 #line 268 "lexer.l"
1679 {
1680                         fflush(stdout);
1681                         add_to_cbuf(yytext);
1682                 }
1683         YY_BREAK
1684 case 19:
1685 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1686 (yy_c_buf_p) = yy_cp -= 1;
1687 YY_DO_BEFORE_ACTION; /* set up yytext again */
1688 YY_RULE_SETUP
1689 #line 273 "lexer.l"
1690 { add_to_cbuf(yytext); /*comment, ignore*/ }
1691         YY_BREAK
1692 case 20:
1693 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1694 (yy_c_buf_p) = yy_cp -= 1;
1695 YY_DO_BEFORE_ACTION; /* set up yytext again */
1696 YY_RULE_SETUP
1697 #line 274 "lexer.l"
1698 { ; /*comment, ignore*/ }
1699         YY_BREAK
1700 case 21:
1701 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1702 (yy_c_buf_p) = yy_cp -= 1;
1703 YY_DO_BEFORE_ACTION; /* set up yytext again */
1704 YY_RULE_SETUP
1705 #line 275 "lexer.l"
1706 { ; /*comment, ignore*/ }
1707         YY_BREAK
1708 case 22:
1709 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1710 (yy_c_buf_p) = yy_cp -= 1;
1711 YY_DO_BEFORE_ACTION; /* set up yytext again */
1712 YY_RULE_SETUP
1713 #line 276 "lexer.l"
1714 { ; /*comment, ignore*/ }
1715         YY_BREAK
1716 case 23:
1717 YY_RULE_SETUP
1718 #line 277 "lexer.l"
1719 {BEGIN(COMMENT); before_comment = INITIAL; }
1720         YY_BREAK
1721 case 24:
1722 YY_RULE_SETUP
1723 #line 278 "lexer.l"
1724 {
1725         add_to_cbuf(yytext);
1726         BEGIN(COMMENT);
1727         before_comment = C_CODE;
1728 }
1729         YY_BREAK
1730 case 25:
1731 YY_RULE_SETUP
1732 #line 283 "lexer.l"
1733 {BEGIN(COMMENT); before_comment = CLASS_CODE; }
1734         YY_BREAK
1735 case 26:
1736 YY_RULE_SETUP
1737 #line 284 "lexer.l"
1738 {BEGIN(COMMENT); before_comment = CLASS_CODE_I; }
1739         YY_BREAK
1740 case 27:
1741 YY_RULE_SETUP
1742 #line 285 "lexer.l"
1743 {BEGIN(COMMENT); before_comment = PROPERTY_CODE_I; }
1744         YY_BREAK
1745 case 28:
1746 YY_RULE_SETUP
1747 #line 286 "lexer.l"
1748 {
1749         if(before_comment == C_CODE) add_to_cbuf(yytext);
1750         BEGIN(before_comment);
1751                 }
1752         YY_BREAK
1753 case 29:
1754 YY_RULE_SETUP
1755 #line 290 "lexer.l"
1756 {
1757         /* comment, ignore */
1758         if(before_comment == C_CODE) add_to_cbuf(yytext);
1759                 }
1760         YY_BREAK
1761 case 30:
1762 /* rule 30 can match eol */
1763 YY_RULE_SETUP
1764 #line 294 "lexer.l"
1765 {
1766         /* comment, ignore */
1767         if(before_comment == C_CODE) add_to_cbuf(yytext);
1768                 }
1769         YY_BREAK
1770 case 31:
1771 YY_RULE_SETUP
1772 #line 299 "lexer.l"
1773 {
1774                         BEGIN(C_CODE);
1775                         parenth_depth = 1;
1776                         class_after_c = FALSE;
1777                         code_type = ACODE;
1778                         clear_cbuf();
1779                         ccode_line = line_no;
1780                 }
1781         YY_BREAK
1782 case 32:
1783 YY_RULE_SETUP
1784 #line 307 "lexer.l"
1785 {
1786                         BEGIN(C_CODE);
1787                         parenth_depth = 1;
1788                         class_after_c = FALSE;
1789                         code_type = ATCODE;
1790                         clear_cbuf();
1791                         ccode_line = line_no;
1792                 }
1793         YY_BREAK
1794 case 33:
1795 YY_RULE_SETUP
1796 #line 316 "lexer.l"
1797 {
1798                         BEGIN(C_CODE);
1799                         parenth_depth = 1;
1800                         class_after_c = FALSE;
1801                         code_type = HTCODE;
1802                         clear_cbuf();
1803                         ccode_line = line_no;
1804                 }
1805         YY_BREAK
1806 case 34:
1807 YY_RULE_SETUP
1808 #line 324 "lexer.l"
1809 {
1810                         BEGIN(C_CODE);
1811                         parenth_depth = 1;
1812                         class_after_c = FALSE;
1813                         code_type = PHCODE;
1814                         clear_cbuf();
1815                         ccode_line = line_no;
1816                 }
1817         YY_BREAK
1818 case 35:
1819 YY_RULE_SETUP
1820 #line 332 "lexer.l"
1821 {
1822                         BEGIN(C_CODE);
1823                         parenth_depth = 1;
1824                         class_after_c = FALSE;
1825                         code_type = HCODE;
1826                         clear_cbuf();
1827                         ccode_line = line_no;
1828                 }
1829         YY_BREAK
1830 case 36:
1831 YY_RULE_SETUP
1832 #line 340 "lexer.l"
1833 {
1834                         BEGIN(C_CODE);
1835                         parenth_depth = 1;
1836                         class_after_c = FALSE;
1837                         code_type = CCODE;
1838                         clear_cbuf();
1839                         ccode_line = line_no;
1840                         if(look_for_includes==0)
1841                                 look_for_includes=1;
1842                 }
1843         YY_BREAK
1844 case 37:
1845 YY_RULE_SETUP
1846 #line 350 "lexer.l"
1847 {
1848                         BEGIN(C_CODE);
1849                         parenth_depth = 1;
1850                         class_after_c = FALSE;
1851                         code_type = CTCODE;
1852                         clear_cbuf();
1853                         ccode_line = line_no;
1854                         if(look_for_includes==0)
1855                                 look_for_includes=1;
1856                 }
1857         YY_BREAK
1858 case 38:
1859 YY_RULE_SETUP
1860 #line 360 "lexer.l"
1861 {
1862                         BEGIN(C_CODE);
1863                         parenth_depth = 1;
1864                         class_after_c = FALSE;
1865                         code_type = ADCODE;
1866                         clear_cbuf();
1867                         ccode_line = line_no;
1868                 }
1869         YY_BREAK
1870 case 39:
1871 YY_RULE_SETUP
1872 #line 368 "lexer.l"
1873 {
1874                         BEGIN(INITIAL);
1875                         yylval.cbuf = cbuf;
1876                         cbuf = NULL;
1877                         if(look_for_includes==1)
1878                                 look_for_includes=0;
1879                         return code_type;
1880                 }
1881         YY_BREAK
1882 case 40:
1883 YY_RULE_SETUP
1884 #line 377 "lexer.l"
1885 { add_to_cbuf(yytext); }
1886         YY_BREAK
1887 case 41:
1888 YY_RULE_SETUP
1889 #line 378 "lexer.l"
1890 { add_to_cbuf(yytext); }
1891         YY_BREAK
1892 case 42:
1893 YY_RULE_SETUP
1894 #line 379 "lexer.l"
1895 { add_to_cbuf(yytext); }
1896         YY_BREAK
1897 case 43:
1898 YY_RULE_SETUP
1899 #line 380 "lexer.l"
1900 { add_to_cbuf(yytext); }
1901         YY_BREAK
1902 case 44:
1903 YY_RULE_SETUP
1904 #line 381 "lexer.l"
1905 { add_to_cbuf(yytext); }
1906         YY_BREAK
1907 case 45:
1908 YY_RULE_SETUP
1909 #line 382 "lexer.l"
1910 { add_to_cbuf(yytext); }
1911         YY_BREAK
1912 case 46:
1913 YY_RULE_SETUP
1914 #line 384 "lexer.l"
1915 { add_to_cbuf(yytext); }
1916         YY_BREAK
1917 case 47:
1918 YY_RULE_SETUP
1919 #line 387 "lexer.l"
1920 {
1921                         BEGIN(CODE_STRING);
1922                         before_string = C_CODE;
1923                         add_to_cbuf(yytext);
1924                 }
1925         YY_BREAK
1926 case 48:
1927 YY_RULE_SETUP
1928 #line 392 "lexer.l"
1929 {
1930                         BEGIN(CODE_STRING);
1931                         before_string = PROPERTY_CODE_I;
1932                         add_to_cbuf(yytext);
1933                 }
1934         YY_BREAK
1935 case 49:
1936 YY_RULE_SETUP
1937 #line 397 "lexer.l"
1938 { add_to_cbuf(yytext); }
1939         YY_BREAK
1940 case 50:
1941 YY_RULE_SETUP
1942 #line 398 "lexer.l"
1943 {
1944                         BEGIN(before_string);
1945                         add_to_cbuf(yytext);
1946                         if (before_string == PROPERTY_CODE_I) {
1947                                 yylval.id = cbuf->str;
1948                                 g_string_free (cbuf, FALSE);
1949                                 cbuf = NULL;
1950                                 return STRING;
1951                         }
1952                 }
1953         YY_BREAK
1954 case 51:
1955 YY_RULE_SETUP
1956 #line 408 "lexer.l"
1957 { add_to_cbuf(yytext); }
1958         YY_BREAK
1959 case 52:
1960 /* rule 52 can match eol */
1961 YY_RULE_SETUP
1962 #line 409 "lexer.l"
1963 { add_to_cbuf(yytext); }
1964         YY_BREAK
1965 case 53:
1966 YY_RULE_SETUP
1967 #line 411 "lexer.l"
1968 {
1969                         parenth_depth++;
1970                         add_to_cbuf(yytext);
1971                 }
1972         YY_BREAK
1973 case 54:
1974 YY_RULE_SETUP
1975 #line 415 "lexer.l"
1976 {
1977                         parenth_depth--;
1978                         if(parenth_depth<0) {
1979                                 REJECT;
1980                         } else if(parenth_depth==0 && class_after_c) {
1981                                 BEGIN(CLASS_CODE_I);
1982                                 yylval.cbuf = cbuf;
1983                                 cbuf = NULL;
1984                                 return CCODE;
1985                         }
1986                         add_to_cbuf(yytext);
1987                 }
1988         YY_BREAK
1989 case 55:
1990 YY_RULE_SETUP
1991 #line 428 "lexer.l"
1992 { add_to_cbuf(yytext); }
1993         YY_BREAK
1994 case 56:
1995 /* rule 56 can match eol */
1996 YY_RULE_SETUP
1997 #line 429 "lexer.l"
1998 { add_to_cbuf(yytext); }
1999         YY_BREAK
2000 case 57:
2001 YY_RULE_SETUP
2002 #line 431 "lexer.l"
2003 {
2004                         static int found_classes = 0;
2005                         look_for_includes = 2;
2006                         BEGIN(CLASS_CODE);
2007
2008                         if(++found_classes > 1) {
2009                                 error_print(GOB_ERROR, line_no,
2010                                             "Only one class per file allowed");
2011                         }
2012
2013                         return CLASS;
2014                 }
2015         YY_BREAK
2016 case 58:
2017 YY_RULE_SETUP
2018 #line 444 "lexer.l"
2019 { return ERROR; }
2020         YY_BREAK
2021 case 59:
2022 YY_RULE_SETUP
2023 #line 445 "lexer.l"
2024 { return ENUM; }
2025         YY_BREAK
2026 case 60:
2027 YY_RULE_SETUP
2028 #line 446 "lexer.l"
2029 { return FLAGS; }
2030         YY_BREAK
2031 case 61:
2032 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2033 (yy_c_buf_p) = yy_cp -= 1;
2034 YY_DO_BEFORE_ACTION; /* set up yytext again */
2035 YY_RULE_SETUP
2036 #line 448 "lexer.l"
2037 {
2038                         int maj = 0, min = 0, pl = 0;
2039                         int rmaj = 0, rmin = 0, rpl = 0;
2040                         int effective_maj = 0;
2041                         int effective_rmaj = 0;
2042                         char *p;
2043
2044                         sscanf (VERSION, "%d.%d.%d", &rmaj, &rmin, &rpl);
2045                         effective_rmaj = rmaj;
2046                         if (rmin >= 90)
2047                                 effective_rmaj = rmaj + 1;
2048
2049                         p = strchr (yytext,'r');
2050                         g_assert (p); /* we MUST have found it */
2051                         sscanf (p, "requires %d.%d.%d", &maj, &min, &pl);
2052                         effective_maj = maj;
2053                         if (min >= 90)
2054                                 effective_maj = maj + 1;
2055
2056                         if(rmaj < maj ||
2057                            (rmaj == maj && rmin < min) ||
2058                            (rmaj == maj && rmin == min && rpl < pl)) {
2059                                 error_printf (GOB_ERROR, line_no,
2060                                               "GOB version at least %d.%d.%d required "
2061                                               "(this is %s)\n"
2062                                               "To upgrade your gob, see: "
2063                                               "http://www.5z.com/jirka/gob.html",
2064                                               maj, min, pl, VERSION);
2065                         }
2066
2067                         if(effective_rmaj != effective_maj) {
2068                                 error_printf(GOB_ERROR, line_no,
2069                                              "GOB major version %d required "
2070                                              "(this is %s)\n"
2071                                              "To upgrade your gob, see: "
2072                                              "http://www.5z.com/jirka/gob.html",
2073                                              effective_maj, VERSION);
2074                         }
2075
2076                 }
2077         YY_BREAK
2078 case 62:
2079 YY_RULE_SETUP
2080 #line 489 "lexer.l"
2081 {
2082                         if(for_cpp) {
2083                                 error_printf(GOB_WARN, line_no,
2084                                              "'%s' keyword should not "
2085                                              "be used when generating "
2086                                              "C++ code", yytext);
2087                         }
2088                         REJECT;
2089                 }
2090         YY_BREAK
2091 case 63:
2092 YY_RULE_SETUP
2093 #line 499 "lexer.l"
2094 {return FROM;}
2095         YY_BREAK
2096 case 64:
2097 YY_RULE_SETUP
2098 #line 500 "lexer.l"
2099 {
2100                         BEGIN(CLASS_STRING);
2101                         before_string = CLASS_CODE;
2102                         add_to_cbuf(yytext);
2103                 }
2104         YY_BREAK
2105 case 65:
2106 YY_RULE_SETUP
2107 #line 505 "lexer.l"
2108 { add_to_cbuf(yytext); }
2109         YY_BREAK
2110 case 66:
2111 YY_RULE_SETUP
2112 #line 506 "lexer.l"
2113 {
2114                         BEGIN(before_string);
2115                         add_to_cbuf(yytext);
2116                         yylval.id = cbuf->str;
2117                         g_string_free (cbuf, FALSE);
2118                         cbuf = NULL;
2119                         return STRING;
2120                 }
2121         YY_BREAK
2122 case 67:
2123 YY_RULE_SETUP
2124 #line 514 "lexer.l"
2125 { add_to_cbuf(yytext); }
2126         YY_BREAK
2127 case 68:
2128 /* rule 68 can match eol */
2129 YY_RULE_SETUP
2130 #line 515 "lexer.l"
2131 { add_to_cbuf(yytext); }
2132         YY_BREAK
2133 case 69:
2134 YY_RULE_SETUP
2135 #line 517 "lexer.l"
2136 {
2137                         BEGIN(CLASS_STRING);
2138                         before_string = CLASS_CODE_I;
2139                         add_to_cbuf(yytext);
2140                 }
2141         YY_BREAK
2142 case 70:
2143 YY_RULE_SETUP
2144 #line 523 "lexer.l"
2145 {return VOID;}
2146         YY_BREAK
2147 case 71:
2148 YY_RULE_SETUP
2149 #line 524 "lexer.l"
2150 {return STRUCT;}
2151         YY_BREAK
2152 case 72:
2153 YY_RULE_SETUP
2154 #line 525 "lexer.l"
2155 {return UNION;}
2156         YY_BREAK
2157 case 73:
2158 YY_RULE_SETUP
2159 #line 526 "lexer.l"
2160 {return ENUM;}
2161         YY_BREAK
2162 case 74:
2163 YY_RULE_SETUP
2164 #line 527 "lexer.l"
2165 {return SIGNED;}
2166         YY_BREAK
2167 case 75:
2168 YY_RULE_SETUP
2169 #line 528 "lexer.l"
2170 {return UNSIGNED;}
2171         YY_BREAK
2172 case 76:
2173 YY_RULE_SETUP
2174 #line 529 "lexer.l"
2175 {return LONG;}
2176         YY_BREAK
2177 case 77:
2178 YY_RULE_SETUP
2179 #line 530 "lexer.l"
2180 {return SHORT;}
2181         YY_BREAK
2182 case 78:
2183 YY_RULE_SETUP
2184 #line 531 "lexer.l"
2185 {return INT;}
2186         YY_BREAK
2187 case 79:
2188 YY_RULE_SETUP
2189 #line 532 "lexer.l"
2190 {return FLOAT;}
2191         YY_BREAK
2192 case 80:
2193 YY_RULE_SETUP
2194 #line 533 "lexer.l"
2195 {return DOUBLE;}
2196         YY_BREAK
2197 case 81:
2198 YY_RULE_SETUP
2199 #line 534 "lexer.l"
2200 {return CHAR;}
2201         YY_BREAK
2202 case 82:
2203 YY_RULE_SETUP
2204 #line 535 "lexer.l"
2205 {return CONST;}
2206         YY_BREAK
2207 case 83:
2208 YY_RULE_SETUP
2209 #line 537 "lexer.l"
2210 {return THREEDOTS;}
2211         YY_BREAK
2212 case 84:
2213 YY_RULE_SETUP
2214 #line 539 "lexer.l"
2215 {yylval.line = line_no; return PUBLIC;}
2216         YY_BREAK
2217 case 85:
2218 YY_RULE_SETUP
2219 #line 540 "lexer.l"
2220 {yylval.line = line_no; return PRIVATE;}
2221         YY_BREAK
2222 case 86:
2223 YY_RULE_SETUP
2224 #line 541 "lexer.l"
2225 {yylval.line = line_no; return PROTECTED;}
2226         YY_BREAK
2227 case 87:
2228 YY_RULE_SETUP
2229 #line 542 "lexer.l"
2230 {yylval.line = line_no; return CLASSWIDE;}
2231         YY_BREAK
2232 case 88:
2233 YY_RULE_SETUP
2234 #line 543 "lexer.l"
2235 {yylval.line = line_no; return ARGUMENT;}
2236         YY_BREAK
2237 case 89:
2238 YY_RULE_SETUP
2239 #line 544 "lexer.l"
2240 {yylval.line = line_no; return VIRTUAL;}
2241         YY_BREAK
2242 case 90:
2243 YY_RULE_SETUP
2244 #line 545 "lexer.l"
2245 {yylval.line = line_no; return SIGNAL;}
2246         YY_BREAK
2247 case 91:
2248 YY_RULE_SETUP
2249 #line 546 "lexer.l"
2250 {yylval.line = line_no; return OVERRIDE;}
2251         YY_BREAK
2252 case 92:
2253 YY_RULE_SETUP
2254 #line 547 "lexer.l"
2255 {
2256                                 yylval.line = line_no;
2257                                 BEGIN(PROPERTY_CODE);
2258                                 return PROPERTY;
2259                         }
2260         YY_BREAK
2261 case 93:
2262 YY_RULE_SETUP
2263 #line 552 "lexer.l"
2264 { yylval.line = line_no; return NICK; }
2265         YY_BREAK
2266 case 94:
2267 YY_RULE_SETUP
2268 #line 553 "lexer.l"
2269 { yylval.line = line_no; return NAME; }
2270         YY_BREAK
2271 case 95:
2272 YY_RULE_SETUP
2273 #line 554 "lexer.l"
2274 { yylval.line = line_no; return BLURB; }
2275         YY_BREAK
2276 case 96:
2277 YY_RULE_SETUP
2278 #line 555 "lexer.l"
2279 { yylval.line = line_no; return MAXIMUM; }
2280         YY_BREAK
2281 case 97:
2282 YY_RULE_SETUP
2283 #line 556 "lexer.l"
2284 { yylval.line = line_no; return MINIMUM; }
2285         YY_BREAK
2286 case 98:
2287 YY_RULE_SETUP
2288 #line 557 "lexer.l"
2289 { yylval.line = line_no; return DEFAULT_VALUE; }
2290         YY_BREAK
2291 case 99:
2292 YY_RULE_SETUP
2293 #line 558 "lexer.l"
2294 { yylval.line = line_no; return FLAGS; }
2295         YY_BREAK
2296 case 100:
2297 YY_RULE_SETUP
2298 #line 559 "lexer.l"
2299 { yylval.line = line_no; return TYPE; }
2300         YY_BREAK
2301 case 101:
2302 YY_RULE_SETUP
2303 #line 560 "lexer.l"
2304 { yylval.line = line_no; return FLAGS_TYPE; }
2305         YY_BREAK
2306 case 102:
2307 YY_RULE_SETUP
2308 #line 561 "lexer.l"
2309 { yylval.line = line_no; return ENUM_TYPE; }
2310         YY_BREAK
2311 case 103:
2312 YY_RULE_SETUP
2313 #line 562 "lexer.l"
2314 { yylval.line = line_no; return PARAM_TYPE; }
2315         YY_BREAK
2316 case 104:
2317 YY_RULE_SETUP
2318 #line 563 "lexer.l"
2319 { yylval.line = line_no; return BOXED_TYPE; }
2320         YY_BREAK
2321 case 105:
2322 YY_RULE_SETUP
2323 #line 564 "lexer.l"
2324 { yylval.line = line_no; return OBJECT_TYPE; }
2325         YY_BREAK
2326 case 106:
2327 YY_RULE_SETUP
2328 #line 565 "lexer.l"
2329 {
2330                 yylval.line = line_no;
2331                 property_paren_depth = 1;
2332                 BEGIN(PROPERTY_CODE_I);
2333                 return '(';
2334                         }
2335         YY_BREAK
2336 case 107:
2337 YY_RULE_SETUP
2338 #line 571 "lexer.l"
2339 {
2340                 yylval.line = line_no;
2341                 property_paren_depth++;
2342                 return '(';
2343                         }
2344         YY_BREAK
2345 case 108:
2346 YY_RULE_SETUP
2347 #line 576 "lexer.l"
2348 {
2349                 yylval.line = line_no;
2350                 property_paren_depth--;
2351                 if (property_paren_depth == 0) {
2352                         BEGIN(CLASS_CODE_I);
2353                 }
2354                 return ')';
2355                         }
2356         YY_BREAK
2357 case 109:
2358 YY_RULE_SETUP
2359 #line 585 "lexer.l"
2360 {
2361                         yylval.id = g_strdup(yytext);
2362                         return NUMBER;
2363                 }
2364         YY_BREAK
2365 case 110:
2366 YY_RULE_SETUP
2367 #line 589 "lexer.l"
2368 {
2369                         /* This is cpp kind of token thingie */
2370                         if (for_cpp) {
2371                                 yylval.id = g_strdup(yytext);
2372                                 return TOKEN;
2373                         } else {
2374                                 REJECT;
2375                         }
2376                 }
2377         YY_BREAK
2378 case 111:
2379 YY_RULE_SETUP
2380 #line 598 "lexer.l"
2381 {
2382                         /* this one is for a classname with a namespace */
2383                         yylval.id = g_strdup(yytext);
2384                         return TYPETOKEN;
2385                 }
2386         YY_BREAK
2387 case 112:
2388 YY_RULE_SETUP
2389 #line 603 "lexer.l"
2390 {
2391                         /* this is for a classname with an empty namespace */
2392                         yylval.id = g_strdup(yytext);
2393                         return TYPETOKEN;
2394                 }
2395         YY_BREAK
2396 case 113:
2397 YY_RULE_SETUP
2398 #line 608 "lexer.l"
2399 {
2400                         yylval.id = g_strdup(yytext);
2401                         return TOKEN;
2402                 }
2403         YY_BREAK
2404 case 114:
2405 YY_RULE_SETUP
2406 #line 612 "lexer.l"
2407 {
2408                         yylval.id = g_strdup(yytext);
2409                         return SINGLE_CHAR;
2410                 }
2411         YY_BREAK
2412 case 115:
2413 YY_RULE_SETUP
2414 #line 617 "lexer.l"
2415 {
2416                         yylval.id = g_strdup(yytext);
2417                         return ARRAY_DIM;
2418                 }
2419         YY_BREAK
2420 case 116:
2421 YY_RULE_SETUP
2422 #line 621 "lexer.l"
2423 {
2424                         /* cheat for bitfield */
2425                         yylval.id = g_strdup(yytext);
2426                         return ARRAY_DIM;
2427                 }
2428         YY_BREAK
2429 case 117:
2430 YY_RULE_SETUP
2431 #line 626 "lexer.l"
2432 {
2433                         BEGIN(CLASS_CODE_I);
2434                         return '{';
2435                 }
2436         YY_BREAK
2437 case 118:
2438 YY_RULE_SETUP
2439 #line 630 "lexer.l"
2440 {
2441                         BEGIN(C_CODE);
2442                         parenth_depth=1;
2443                         class_after_c = TRUE;
2444                         yylval.line = line_no;
2445                         clear_cbuf();
2446                         ccode_line = line_no;
2447                         return '{';
2448                 }
2449         YY_BREAK
2450 case 119:
2451 YY_RULE_SETUP
2452 #line 639 "lexer.l"
2453 {
2454                                 BEGIN(INITIAL);
2455                                 return '}';
2456                         }
2457         YY_BREAK
2458 case 120:
2459 YY_RULE_SETUP
2460 #line 644 "lexer.l"
2461 ;  /*ignore*/
2462         YY_BREAK
2463 case 121:
2464 /* rule 121 can match eol */
2465 YY_RULE_SETUP
2466 #line 646 "lexer.l"
2467 ;  /*ignore*/
2468         YY_BREAK
2469 case 122:
2470 YY_RULE_SETUP
2471 #line 649 "lexer.l"
2472 {
2473                         yylval.line = line_no;
2474                         return yytext[0];
2475                 }
2476         YY_BREAK
2477 case 123:
2478 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2479 (yy_c_buf_p) = yy_cp -= 1;
2480 YY_DO_BEFORE_ACTION; /* set up yytext again */
2481 YY_RULE_SETUP
2482 #line 654 "lexer.l"
2483 {
2484                         char *p;
2485                         int t;
2486                         p = strchr (yytext,'p');
2487                         g_assert (p); /* we MUST have found it */
2488                         sscanf (p, "prealloc %d", &t);
2489                         prealloc=t;
2490                 }
2491         YY_BREAK
2492 case 124:
2493 YY_RULE_SETUP
2494 #line 663 "lexer.l"
2495 ECHO;
2496         YY_BREAK
2497 #line 2498 "lexer.c"
2498                         case YY_STATE_EOF(INITIAL):
2499                         case YY_STATE_EOF(COMMENT):
2500                         case YY_STATE_EOF(C_CODE):
2501                         case YY_STATE_EOF(CODE_STRING):
2502                         case YY_STATE_EOF(CLASS_CODE):
2503                         case YY_STATE_EOF(CLASS_STRING):
2504                         case YY_STATE_EOF(CLASS_CODE_I):
2505                         case YY_STATE_EOF(PROPERTY_CODE):
2506                         case YY_STATE_EOF(PROPERTY_CODE_I):
2507                         case YY_STATE_EOF(GTK_DOC_BEFORE_NAME):
2508                         case YY_STATE_EOF(GTK_DOC):
2509                         case YY_STATE_EOF(GTK_DOC_LINE):
2510                                 yyterminate();
2511
2512         case YY_END_OF_BUFFER:
2513                 {
2514                 /* Amount of text matched not including the EOB char. */
2515                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2516
2517                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2518                 *yy_cp = (yy_hold_char);
2519                 YY_RESTORE_YY_MORE_OFFSET
2520
2521                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2522                         {
2523                         /* We're scanning a new file or input source.  It's
2524                          * possible that this happened because the user
2525                          * just pointed yyin at a new source and called
2526                          * yylex().  If so, then we have to assure
2527                          * consistency between YY_CURRENT_BUFFER and our
2528                          * globals.  Here is the right place to do so, because
2529                          * this is the first action (other than possibly a
2530                          * back-up) that will match for the new input source.
2531                          */
2532                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2533                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
2534                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2535                         }
2536
2537                 /* Note that here we test for yy_c_buf_p "<=" to the position
2538                  * of the first EOB in the buffer, since yy_c_buf_p will
2539                  * already have been incremented past the NUL character
2540                  * (since all states make transitions on EOB to the
2541                  * end-of-buffer state).  Contrast this with the test
2542                  * in input().
2543                  */
2544                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2545                         { /* This was really a NUL. */
2546                         yy_state_type yy_next_state;
2547
2548                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2549
2550                         yy_current_state = yy_get_previous_state(  );
2551
2552                         /* Okay, we're now positioned to make the NUL
2553                          * transition.  We couldn't have
2554                          * yy_get_previous_state() go ahead and do it
2555                          * for us because it doesn't know how to deal
2556                          * with the possibility of jamming (and we don't
2557                          * want to build jamming into it because then it
2558                          * will run more slowly).
2559                          */
2560
2561                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2562
2563                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2564
2565                         if ( yy_next_state )
2566                                 {
2567                                 /* Consume the NUL. */
2568                                 yy_cp = ++(yy_c_buf_p);
2569                                 yy_current_state = yy_next_state;
2570                                 goto yy_match;
2571                                 }
2572
2573                         else
2574                                 {
2575                                 yy_cp = (yy_c_buf_p);
2576                                 goto yy_find_action;
2577                                 }
2578                         }
2579
2580                 else switch ( yy_get_next_buffer(  ) )
2581                         {
2582                         case EOB_ACT_END_OF_FILE:
2583                                 {
2584                                 (yy_did_buffer_switch_on_eof) = 0;
2585
2586                                 if ( yywrap( ) )
2587                                         {
2588                                         /* Note: because we've taken care in
2589                                          * yy_get_next_buffer() to have set up
2590                                          * yytext, we can now set up
2591                                          * yy_c_buf_p so that if some total
2592                                          * hoser (like flex itself) wants to
2593                                          * call the scanner after we return the
2594                                          * YY_NULL, it'll still work - another
2595                                          * YY_NULL will get returned.
2596                                          */
2597                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2598
2599                                         yy_act = YY_STATE_EOF(YY_START);
2600                                         goto do_action;
2601                                         }
2602
2603                                 else
2604                                         {
2605                                         if ( ! (yy_did_buffer_switch_on_eof) )
2606                                                 YY_NEW_FILE;
2607                                         }
2608                                 break;
2609                                 }
2610
2611                         case EOB_ACT_CONTINUE_SCAN:
2612                                 (yy_c_buf_p) =
2613                                         (yytext_ptr) + yy_amount_of_matched_text;
2614
2615                                 yy_current_state = yy_get_previous_state(  );
2616
2617                                 yy_cp = (yy_c_buf_p);
2618                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2619                                 goto yy_match;
2620
2621                         case EOB_ACT_LAST_MATCH:
2622                                 (yy_c_buf_p) =
2623                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2624
2625                                 yy_current_state = yy_get_previous_state(  );
2626
2627                                 yy_cp = (yy_c_buf_p);
2628                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2629                                 goto yy_find_action;
2630                         }
2631                 break;
2632                 }
2633
2634         default:
2635                 YY_FATAL_ERROR(
2636                         "fatal flex scanner internal error--no action found" );
2637         } /* end of action switch */
2638                 } /* end of scanning one token */
2639 } /* end of yylex */
2640
2641 /* yy_get_next_buffer - try to read in a new buffer
2642  *
2643  * Returns a code representing an action:
2644  *      EOB_ACT_LAST_MATCH -
2645  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2646  *      EOB_ACT_END_OF_FILE - end of file
2647  */
2648 static int yy_get_next_buffer (void)
2649 {
2650         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2651         register char *source = (yytext_ptr);
2652         register int number_to_move, i;
2653         int ret_val;
2654
2655         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2656                 YY_FATAL_ERROR(
2657                 "fatal flex scanner internal error--end of buffer missed" );
2658
2659         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2660                 { /* Don't try to fill the buffer, so this is an EOF. */
2661                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2662                         {
2663                         /* We matched a single character, the EOB, so
2664                          * treat this as a final EOF.
2665                          */
2666                         return EOB_ACT_END_OF_FILE;
2667                         }
2668
2669                 else
2670                         {
2671                         /* We matched some text prior to the EOB, first
2672                          * process it.
2673                          */
2674                         return EOB_ACT_LAST_MATCH;
2675                         }
2676                 }
2677
2678         /* Try to read more data. */
2679
2680         /* First move last chars to start of buffer. */
2681         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2682
2683         for ( i = 0; i < number_to_move; ++i )
2684                 *(dest++) = *(source++);
2685
2686         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2687                 /* don't do the read, it's not guaranteed to return an EOF,
2688                  * just force an EOF
2689                  */
2690                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2691
2692         else
2693                 {
2694                         yy_size_t num_to_read =
2695                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2696
2697                 while ( num_to_read <= 0 )
2698                         { /* Not enough room in the buffer - grow it. */
2699
2700                         YY_FATAL_ERROR(
2701 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2702
2703                         }
2704
2705                 if ( num_to_read > YY_READ_BUF_SIZE )
2706                         num_to_read = YY_READ_BUF_SIZE;
2707
2708                 /* Read in more data. */
2709                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2710                         (yy_n_chars), num_to_read );
2711
2712                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2713                 }
2714
2715         if ( (yy_n_chars) == 0 )
2716                 {
2717                 if ( number_to_move == YY_MORE_ADJ )
2718                         {
2719                         ret_val = EOB_ACT_END_OF_FILE;
2720                         yyrestart(yyin  );
2721                         }
2722
2723                 else
2724                         {
2725                         ret_val = EOB_ACT_LAST_MATCH;
2726                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2727                                 YY_BUFFER_EOF_PENDING;
2728                         }
2729                 }
2730
2731         else
2732                 ret_val = EOB_ACT_CONTINUE_SCAN;
2733
2734         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2735                 /* Extend the array by 50%, plus the number we really need. */
2736                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2737                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
2738                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2739                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2740         }
2741
2742         (yy_n_chars) += number_to_move;
2743         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2744         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2745
2746         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2747
2748         return ret_val;
2749 }
2750
2751 /* yy_get_previous_state - get the state just before the EOB char was reached */
2752
2753     static yy_state_type yy_get_previous_state (void)
2754 {
2755         register yy_state_type yy_current_state;
2756         register char *yy_cp;
2757
2758         yy_current_state = (yy_start);
2759         yy_current_state += YY_AT_BOL();
2760
2761         (yy_state_ptr) = (yy_state_buf);
2762         *(yy_state_ptr)++ = yy_current_state;
2763
2764         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2765                 {
2766                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2767                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2768                         {
2769                         yy_current_state = (int) yy_def[yy_current_state];
2770                         if ( yy_current_state >= 570 )
2771                                 yy_c = yy_meta[(unsigned int) yy_c];
2772                         }
2773                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2774                 *(yy_state_ptr)++ = yy_current_state;
2775                 }
2776
2777         return yy_current_state;
2778 }
2779
2780 /* yy_try_NUL_trans - try to make a transition on the NUL character
2781  *
2782  * synopsis
2783  *      next_state = yy_try_NUL_trans( current_state );
2784  */
2785     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2786 {
2787         register int yy_is_jam;
2788
2789         register YY_CHAR yy_c = 1;
2790         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2791                 {
2792                 yy_current_state = (int) yy_def[yy_current_state];
2793                 if ( yy_current_state >= 570 )
2794                         yy_c = yy_meta[(unsigned int) yy_c];
2795                 }
2796         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2797         yy_is_jam = (yy_current_state == 569);
2798         if ( ! yy_is_jam )
2799                 *(yy_state_ptr)++ = yy_current_state;
2800
2801                 return yy_is_jam ? 0 : yy_current_state;
2802 }
2803
2804     static void yyunput (int c, register char * yy_bp )
2805 {
2806         register char *yy_cp;
2807
2808     yy_cp = (yy_c_buf_p);
2809
2810         /* undo effects of setting up yytext */
2811         *yy_cp = (yy_hold_char);
2812
2813         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2814                 { /* need to shift things up to make room */
2815                 /* +2 for EOB chars. */
2816                 register yy_size_t number_to_move = (yy_n_chars) + 2;
2817                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2818                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2819                 register char *source =
2820                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2821
2822                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2823                         *--dest = *--source;
2824
2825                 yy_cp += (int) (dest - source);
2826                 yy_bp += (int) (dest - source);
2827                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2828                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2829
2830                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2831                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2832                 }
2833
2834         *--yy_cp = (char) c;
2835
2836         (yytext_ptr) = yy_bp;
2837         (yy_hold_char) = *yy_cp;
2838         (yy_c_buf_p) = yy_cp;
2839 }
2840
2841 #ifndef YY_NO_INPUT
2842 #ifdef __cplusplus
2843     static int yyinput (void)
2844 #else
2845     static int input  (void)
2846 #endif
2847
2848 {
2849         int c;
2850
2851         *(yy_c_buf_p) = (yy_hold_char);
2852
2853         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2854                 {
2855                 /* yy_c_buf_p now points to the character we want to return.
2856                  * If this occurs *before* the EOB characters, then it's a
2857                  * valid NUL; if not, then we've hit the end of the buffer.
2858                  */
2859                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2860                         /* This was really a NUL. */
2861                         *(yy_c_buf_p) = '\0';
2862
2863                 else
2864                         { /* need more input */
2865                         yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2866                         ++(yy_c_buf_p);
2867
2868                         switch ( yy_get_next_buffer(  ) )
2869                                 {
2870                                 case EOB_ACT_LAST_MATCH:
2871                                         /* This happens because yy_g_n_b()
2872                                          * sees that we've accumulated a
2873                                          * token and flags that we need to
2874                                          * try matching the token before
2875                                          * proceeding.  But for input(),
2876                                          * there's no matching to consider.
2877                                          * So convert the EOB_ACT_LAST_MATCH
2878                                          * to EOB_ACT_END_OF_FILE.
2879                                          */
2880
2881                                         /* Reset buffer status. */
2882                                         yyrestart(yyin );
2883
2884                                         /*FALLTHROUGH*/
2885
2886                                 case EOB_ACT_END_OF_FILE:
2887                                         {
2888                                         if ( yywrap( ) )
2889                                                 return EOF;
2890
2891                                         if ( ! (yy_did_buffer_switch_on_eof) )
2892                                                 YY_NEW_FILE;
2893 #ifdef __cplusplus
2894                                         return yyinput();
2895 #else
2896                                         return input();
2897 #endif
2898                                         }
2899
2900                                 case EOB_ACT_CONTINUE_SCAN:
2901                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2902                                         break;
2903                                 }
2904                         }
2905                 }
2906
2907         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2908         *(yy_c_buf_p) = '\0';   /* preserve yytext */
2909         (yy_hold_char) = *++(yy_c_buf_p);
2910
2911         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2912
2913         return c;
2914 }
2915 #endif  /* ifndef YY_NO_INPUT */
2916
2917 /** Immediately switch to a different input stream.
2918  * @param input_file A readable stream.
2919  *
2920  * @note This function does not reset the start condition to @c INITIAL .
2921  */
2922     void yyrestart  (FILE * input_file )
2923 {
2924
2925         if ( ! YY_CURRENT_BUFFER ){
2926         yyensure_buffer_stack ();
2927                 YY_CURRENT_BUFFER_LVALUE =
2928             yy_create_buffer(yyin,YY_BUF_SIZE );
2929         }
2930
2931         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2932         yy_load_buffer_state( );
2933 }
2934
2935 /** Switch to a different input buffer.
2936  * @param new_buffer The new input buffer.
2937  *
2938  */
2939     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2940 {
2941
2942         /* TODO. We should be able to replace this entire function body
2943          * with
2944          *              yypop_buffer_state();
2945          *              yypush_buffer_state(new_buffer);
2946      */
2947         yyensure_buffer_stack ();
2948         if ( YY_CURRENT_BUFFER == new_buffer )
2949                 return;
2950
2951         if ( YY_CURRENT_BUFFER )
2952                 {
2953                 /* Flush out information for old buffer. */
2954                 *(yy_c_buf_p) = (yy_hold_char);
2955                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2956                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2957                 }
2958
2959         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2960         yy_load_buffer_state( );
2961
2962         /* We don't actually know whether we did this switch during
2963          * EOF (yywrap()) processing, but the only time this flag
2964          * is looked at is after yywrap() is called, so it's safe
2965          * to go ahead and always set it.
2966          */
2967         (yy_did_buffer_switch_on_eof) = 1;
2968 }
2969
2970 static void yy_load_buffer_state  (void)
2971 {
2972         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2973         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2974         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2975         (yy_hold_char) = *(yy_c_buf_p);
2976 }
2977
2978 /** Allocate and initialize an input buffer state.
2979  * @param file A readable stream.
2980  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2981  *
2982  * @return the allocated buffer state.
2983  */
2984     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2985 {
2986         YY_BUFFER_STATE b;
2987
2988         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2989         if ( ! b )
2990                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2991
2992         b->yy_buf_size = size;
2993
2994         /* yy_ch_buf has to be 2 characters longer than the size given because
2995          * we need to put in 2 end-of-buffer characters.
2996          */
2997         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2998         if ( ! b->yy_ch_buf )
2999                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3000
3001         b->yy_is_our_buffer = 1;
3002
3003         yy_init_buffer(b,file );
3004
3005         return b;
3006 }
3007
3008 /** Destroy the buffer.
3009  * @param b a buffer created with yy_create_buffer()
3010  *
3011  */
3012     void yy_delete_buffer (YY_BUFFER_STATE  b )
3013 {
3014
3015         if ( ! b )
3016                 return;
3017
3018         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3019                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3020
3021         if ( b->yy_is_our_buffer )
3022                 yyfree((void *) b->yy_ch_buf  );
3023
3024         yyfree((void *) b  );
3025 }
3026
3027 /* Initializes or reinitializes a buffer.
3028  * This function is sometimes called more than once on the same buffer,
3029  * such as during a yyrestart() or at EOF.
3030  */
3031     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
3032
3033 {
3034         int oerrno = errno;
3035
3036         yy_flush_buffer(b );
3037
3038         b->yy_input_file = file;
3039         b->yy_fill_buffer = 1;
3040
3041     /* If b is the current buffer, then yy_init_buffer was _probably_
3042      * called from yyrestart() or through yy_get_next_buffer.
3043      * In that case, we don't want to reset the lineno or column.
3044      */
3045     if (b != YY_CURRENT_BUFFER){
3046         b->yy_bs_lineno = 1;
3047         b->yy_bs_column = 0;
3048     }
3049
3050         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3051
3052         errno = oerrno;
3053 }
3054
3055 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
3056  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
3057  *
3058  */
3059     void yy_flush_buffer (YY_BUFFER_STATE  b )
3060 {
3061         if ( ! b )
3062                 return;
3063
3064         b->yy_n_chars = 0;
3065
3066         /* We always need two end-of-buffer characters.  The first causes
3067          * a transition to the end-of-buffer state.  The second causes
3068          * a jam in that state.
3069          */
3070         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3071         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3072
3073         b->yy_buf_pos = &b->yy_ch_buf[0];
3074
3075         b->yy_at_bol = 1;
3076         b->yy_buffer_status = YY_BUFFER_NEW;
3077
3078         if ( b == YY_CURRENT_BUFFER )
3079                 yy_load_buffer_state( );
3080 }
3081
3082 /** Pushes the new state onto the stack. The new state becomes
3083  *  the current state. This function will allocate the stack
3084  *  if necessary.
3085  *  @param new_buffer The new state.
3086  *
3087  */
3088 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
3089 {
3090         if (new_buffer == NULL)
3091                 return;
3092
3093         yyensure_buffer_stack();
3094
3095         /* This block is copied from yy_switch_to_buffer. */
3096         if ( YY_CURRENT_BUFFER )
3097                 {
3098                 /* Flush out information for old buffer. */
3099                 *(yy_c_buf_p) = (yy_hold_char);
3100                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3101                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3102                 }
3103
3104         /* Only push if top exists. Otherwise, replace top. */
3105         if (YY_CURRENT_BUFFER)
3106                 (yy_buffer_stack_top)++;
3107         YY_CURRENT_BUFFER_LVALUE = new_buffer;
3108
3109         /* copied from yy_switch_to_buffer. */
3110         yy_load_buffer_state( );
3111         (yy_did_buffer_switch_on_eof) = 1;
3112 }
3113
3114 /** Removes and deletes the top of the stack, if present.
3115  *  The next element becomes the new top.
3116  *
3117  */
3118 void yypop_buffer_state (void)
3119 {
3120         if (!YY_CURRENT_BUFFER)
3121                 return;
3122
3123         yy_delete_buffer(YY_CURRENT_BUFFER );
3124         YY_CURRENT_BUFFER_LVALUE = NULL;
3125         if ((yy_buffer_stack_top) > 0)
3126                 --(yy_buffer_stack_top);
3127
3128         if (YY_CURRENT_BUFFER) {
3129                 yy_load_buffer_state( );
3130                 (yy_did_buffer_switch_on_eof) = 1;
3131         }
3132 }
3133
3134 /* Allocates the stack if it does not exist.
3135  *  Guarantees space for at least one push.
3136  */
3137 static void yyensure_buffer_stack (void)
3138 {
3139         yy_size_t num_to_alloc;
3140
3141         if (!(yy_buffer_stack)) {
3142
3143                 /* First allocation is just for 2 elements, since we don't know if this
3144                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
3145                  * immediate realloc on the next call.
3146          */
3147                 num_to_alloc = 1;
3148                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
3149                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
3150                                                                 );
3151                 if ( ! (yy_buffer_stack) )
3152                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3153
3154                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3155
3156                 (yy_buffer_stack_max) = num_to_alloc;
3157                 (yy_buffer_stack_top) = 0;
3158                 return;
3159         }
3160
3161         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3162
3163                 /* Increase the buffer to prepare for a possible push. */
3164                 int grow_size = 8 /* arbitrary grow size */;
3165
3166                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
3167                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
3168                                                                 ((yy_buffer_stack),
3169                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
3170                                                                 );
3171                 if ( ! (yy_buffer_stack) )
3172                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3173
3174                 /* zero only the new slots.*/
3175                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3176                 (yy_buffer_stack_max) = num_to_alloc;
3177         }
3178 }
3179
3180 /** Setup the input buffer state to scan directly from a user-specified character buffer.
3181  * @param base the character buffer
3182  * @param size the size in bytes of the character buffer
3183  *
3184  * @return the newly allocated buffer state object.
3185  */
3186 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
3187 {
3188         YY_BUFFER_STATE b;
3189
3190         if ( size < 2 ||
3191              base[size-2] != YY_END_OF_BUFFER_CHAR ||
3192              base[size-1] != YY_END_OF_BUFFER_CHAR )
3193                 /* They forgot to leave room for the EOB's. */
3194                 return 0;
3195
3196         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
3197         if ( ! b )
3198                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3199
3200         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
3201         b->yy_buf_pos = b->yy_ch_buf = base;
3202         b->yy_is_our_buffer = 0;
3203         b->yy_input_file = 0;
3204         b->yy_n_chars = b->yy_buf_size;
3205         b->yy_is_interactive = 0;
3206         b->yy_at_bol = 1;
3207         b->yy_fill_buffer = 0;
3208         b->yy_buffer_status = YY_BUFFER_NEW;
3209
3210         yy_switch_to_buffer(b  );
3211
3212         return b;
3213 }
3214
3215 /** Setup the input buffer state to scan a string. The next call to yylex() will
3216  * scan from a @e copy of @a str.
3217  * @param yystr a NUL-terminated string to scan
3218  *
3219  * @return the newly allocated buffer state object.
3220  * @note If you want to scan bytes that may contain NUL values, then use
3221  *       yy_scan_bytes() instead.
3222  */
3223 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
3224 {
3225
3226         return yy_scan_bytes(yystr,strlen(yystr) );
3227 }
3228
3229 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
3230  * scan from a @e copy of @a bytes.
3231  * @param yybytes the byte buffer to scan
3232  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
3233  *
3234  * @return the newly allocated buffer state object.
3235  */
3236 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
3237 {
3238         YY_BUFFER_STATE b;
3239         char *buf;
3240         yy_size_t n;
3241         yy_size_t i;
3242
3243         /* Get memory for full buffer, including space for trailing EOB's. */
3244         n = _yybytes_len + 2;
3245         buf = (char *) yyalloc(n  );
3246         if ( ! buf )
3247                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3248
3249         for ( i = 0; i < _yybytes_len; ++i )
3250                 buf[i] = yybytes[i];
3251
3252         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3253
3254         b = yy_scan_buffer(buf,n );
3255         if ( ! b )
3256                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3257
3258         /* It's okay to grow etc. this buffer, and we should throw it
3259          * away when we're done.
3260          */
3261         b->yy_is_our_buffer = 1;
3262
3263         return b;
3264 }
3265
3266 #ifndef YY_EXIT_FAILURE
3267 #define YY_EXIT_FAILURE 2
3268 #endif
3269
3270 static void yy_fatal_error (yyconst char* msg )
3271 {
3272         (void) fprintf( stderr, "%s\n", msg );
3273         exit( YY_EXIT_FAILURE );
3274 }
3275
3276 /* Redefine yyless() so it works in section 3 code. */
3277
3278 #undef yyless
3279 #define yyless(n) \
3280         do \
3281                 { \
3282                 /* Undo effects of setting up yytext. */ \
3283         int yyless_macro_arg = (n); \
3284         YY_LESS_LINENO(yyless_macro_arg);\
3285                 yytext[yyleng] = (yy_hold_char); \
3286                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
3287                 (yy_hold_char) = *(yy_c_buf_p); \
3288                 *(yy_c_buf_p) = '\0'; \
3289                 yyleng = yyless_macro_arg; \
3290                 } \
3291         while ( 0 )
3292
3293 /* Accessor  methods (get/set functions) to struct members. */
3294
3295 /** Get the current line number.
3296  *
3297  */
3298 int yyget_lineno  (void)
3299 {
3300
3301     return yylineno;
3302 }
3303
3304 /** Get the input stream.
3305  *
3306  */
3307 FILE *yyget_in  (void)
3308 {
3309         return yyin;
3310 }
3311
3312 /** Get the output stream.
3313  *
3314  */
3315 FILE *yyget_out  (void)
3316 {
3317         return yyout;
3318 }
3319
3320 /** Get the length of the current token.
3321  *
3322  */
3323 yy_size_t yyget_leng  (void)
3324 {
3325         return yyleng;
3326 }
3327
3328 /** Get the current token.
3329  *
3330  */
3331
3332 char *yyget_text  (void)
3333 {
3334         return yytext;
3335 }
3336
3337 /** Set the current line number.
3338  * @param line_number
3339  *
3340  */
3341 void yyset_lineno (int  line_number )
3342 {
3343
3344     yylineno = line_number;
3345 }
3346
3347 /** Set the input stream. This does not discard the current
3348  * input buffer.
3349  * @param in_str A readable stream.
3350  *
3351  * @see yy_switch_to_buffer
3352  */
3353 void yyset_in (FILE *  in_str )
3354 {
3355         yyin = in_str ;
3356 }
3357
3358 void yyset_out (FILE *  out_str )
3359 {
3360         yyout = out_str ;
3361 }
3362
3363 int yyget_debug  (void)
3364 {
3365         return yy_flex_debug;
3366 }
3367
3368 void yyset_debug (int  bdebug )
3369 {
3370         yy_flex_debug = bdebug ;
3371 }
3372
3373 static int yy_init_globals (void)
3374 {
3375         /* Initialization is the same as for the non-reentrant scanner.
3376      * This function is called from yylex_destroy(), so don't allocate here.
3377      */
3378
3379     (yy_buffer_stack) = 0;
3380     (yy_buffer_stack_top) = 0;
3381     (yy_buffer_stack_max) = 0;
3382     (yy_c_buf_p) = (char *) 0;
3383     (yy_init) = 0;
3384     (yy_start) = 0;
3385
3386     (yy_state_buf) = 0;
3387     (yy_state_ptr) = 0;
3388     (yy_full_match) = 0;
3389     (yy_lp) = 0;
3390
3391 /* Defined in main.c */
3392 #ifdef YY_STDINIT
3393     yyin = stdin;
3394     yyout = stdout;
3395 #else
3396     yyin = (FILE *) 0;
3397     yyout = (FILE *) 0;
3398 #endif
3399
3400     /* For future reference: Set errno on error, since we are called by
3401      * yylex_init()
3402      */
3403     return 0;
3404 }
3405
3406 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
3407 int yylex_destroy  (void)
3408 {
3409
3410     /* Pop the buffer stack, destroying each element. */
3411         while(YY_CURRENT_BUFFER){
3412                 yy_delete_buffer(YY_CURRENT_BUFFER  );
3413                 YY_CURRENT_BUFFER_LVALUE = NULL;
3414                 yypop_buffer_state();
3415         }
3416
3417         /* Destroy the stack itself. */
3418         yyfree((yy_buffer_stack) );
3419         (yy_buffer_stack) = NULL;
3420
3421     yyfree ( (yy_state_buf) );
3422     (yy_state_buf)  = NULL;
3423
3424     /* Reset the globals. This is important in a non-reentrant scanner so the next time
3425      * yylex() is called, initialization will occur. */
3426     yy_init_globals( );
3427
3428     return 0;
3429 }
3430
3431 /*
3432  * Internal utility routines.
3433  */
3434
3435 #ifndef yytext_ptr
3436 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
3437 {
3438         register int i;
3439         for ( i = 0; i < n; ++i )
3440                 s1[i] = s2[i];
3441 }
3442 #endif
3443
3444 #ifdef YY_NEED_STRLEN
3445 static int yy_flex_strlen (yyconst char * s )
3446 {
3447         register int n;
3448         for ( n = 0; s[n]; ++n )
3449                 ;
3450
3451         return n;
3452 }
3453 #endif
3454
3455 void *yyalloc (yy_size_t  size )
3456 {
3457         return (void *) malloc( size );
3458 }
3459
3460 void *yyrealloc  (void * ptr, yy_size_t  size )
3461 {
3462         /* The cast to (char *) in the following accommodates both
3463          * implementations that use char* generic pointers, and those
3464          * that use void* generic pointers.  It works with the latter
3465          * because both ANSI C and C++ allow castless assignment from
3466          * any pointer type to void*, and deal with argument conversions
3467          * as though doing an assignment.
3468          */
3469         return (void *) realloc( (char *) ptr, size );
3470 }
3471
3472 void yyfree (void * ptr )
3473 {
3474         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
3475 }
3476
3477 #define YYTABLES_NAME "yytables"
3478
3479 #line 663 "lexer.l"
3480
3481
3482