src/lexer.c

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