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