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