src/lexer.c

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