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