contrib/gcc-4.7/gcc/gengtype-lex.c

   1 #include "bconfig.h"
   2 #line 2 "gengtype-lex.c"
   3
   4 #line 4 "gengtype-lex.c"
   5
   6 #define  YY_INT_ALIGNED short int
   7
   8 /* A lexical scanner generated by flex */
   9
  10 #define FLEX_SCANNER
  11 #define YY_FLEX_MAJOR_VERSION 2
  12 #define YY_FLEX_MINOR_VERSION 5
  13 #define YY_FLEX_SUBMINOR_VERSION 35
  14 #if YY_FLEX_SUBMINOR_VERSION > 0
  15 #define FLEX_BETA
  16 #endif
  17
  18 /* First, we deal with  platform-specific or compiler-specific issues. */
  19
  20 /* begin standard C headers. */
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <stdlib.h>
  25
  26 /* end standard C headers. */
  27
  28 /* flex integer type definitions */
  29
  30 #ifndef FLEXINT_H
  31 #define FLEXINT_H
  32
  33 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  34
  35 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  36
  37 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  38  * if you want the limit (max/min) macros for int types.
  39  */
  40 #ifndef __STDC_LIMIT_MACROS
  41 #define __STDC_LIMIT_MACROS 1
  42 #endif
  43
  44 #include <inttypes.h>
  45 typedef int8_t flex_int8_t;
  46 typedef uint8_t flex_uint8_t;
  47 typedef int16_t flex_int16_t;
  48 typedef uint16_t flex_uint16_t;
  49 typedef int32_t flex_int32_t;
  50 typedef uint32_t flex_uint32_t;
  51 #else
  52 typedef signed char flex_int8_t;
  53 typedef short int flex_int16_t;
  54 typedef int flex_int32_t;
  55 typedef unsigned char flex_uint8_t;
  56 typedef unsigned short int flex_uint16_t;
  57 typedef unsigned int flex_uint32_t;
  58 #endif /* ! C99 */
  59
  60 /* Limits of integral types. */
  61 #ifndef INT8_MIN
  62 #define INT8_MIN               (-128)
  63 #endif
  64 #ifndef INT16_MIN
  65 #define INT16_MIN              (-32767-1)
  66 #endif
  67 #ifndef INT32_MIN
  68 #define INT32_MIN              (-2147483647-1)
  69 #endif
  70 #ifndef INT8_MAX
  71 #define INT8_MAX               (127)
  72 #endif
  73 #ifndef INT16_MAX
  74 #define INT16_MAX              (32767)
  75 #endif
  76 #ifndef INT32_MAX
  77 #define INT32_MAX              (2147483647)
  78 #endif
  79 #ifndef UINT8_MAX
  80 #define UINT8_MAX              (255U)
  81 #endif
  82 #ifndef UINT16_MAX
  83 #define UINT16_MAX             (65535U)
  84 #endif
  85 #ifndef UINT32_MAX
  86 #define UINT32_MAX             (4294967295U)
  87 #endif
  88
  89 #endif /* ! FLEXINT_H */
  90
  91 #ifdef __cplusplus
  92
  93 /* The "const" storage-class-modifier is valid. */
  94 #define YY_USE_CONST
  95
  96 #else   /* ! __cplusplus */
  97
  98 /* C99 requires __STDC__ to be defined as 1. */
  99 #if defined (__STDC__)
 100
 101 #define YY_USE_CONST
 102
 103 #endif  /* defined (__STDC__) */
 104 #endif  /* ! __cplusplus */
 105
 106 #ifdef YY_USE_CONST
 107 #define yyconst const
 108 #else
 109 #define yyconst
 110 #endif
 111
 112 /* Returned upon end-of-file. */
 113 #define YY_NULL 0
 114
 115 /* Promotes a possibly negative, possibly signed char to an unsigned
 116  * integer for use as an array index.  If the signed char is negative,
 117  * we want to instead treat it as an 8-bit unsigned char, hence the
 118  * double cast.
 119  */
 120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 121
 122 /* Enter a start condition.  This macro really ought to take a parameter,
 123  * but we do it the disgusting crufty way forced on us by the ()-less
 124  * definition of BEGIN.
 125  */
 126 #define BEGIN (yy_start) = 1 + 2 *
 127
 128 /* Translate the current start state into a value that can be later handed
 129  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 130  * compatibility.
 131  */
 132 #define YY_START (((yy_start) - 1) / 2)
 133 #define YYSTATE YY_START
 134
 135 /* Action number for EOF rule of a given start state. */
 136 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 137
 138 /* Special action meaning "start processing a new file". */
 139 #define YY_NEW_FILE yyrestart(yyin  )
 140
 141 #define YY_END_OF_BUFFER_CHAR 0
 142
 143 /* Size of default input buffer. */
 144 #ifndef YY_BUF_SIZE
 145 #define YY_BUF_SIZE 16384
 146 #endif
 147
 148 /* The state buf must be large enough to hold one state per character in the main buffer.
 149  */
 150 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 151
 152 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 153 #define YY_TYPEDEF_YY_BUFFER_STATE
 154 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 155 #endif
 156
 157 extern int yyleng;
 158
 159 extern FILE *yyin, *yyout;
 160
 161 #define EOB_ACT_CONTINUE_SCAN 0
 162 #define EOB_ACT_END_OF_FILE 1
 163 #define EOB_ACT_LAST_MATCH 2
 164
 165     #define YY_LESS_LINENO(n)
 166
 167 /* Return all but the first "n" matched characters back to the input stream. */
 168 #define yyless(n) \
 169         do \
 170                 { \
 171                 /* Undo effects of setting up yytext. */ \
 172         int yyless_macro_arg = (n); \
 173         YY_LESS_LINENO(yyless_macro_arg);\
 174                 *yy_cp = (yy_hold_char); \
 175                 YY_RESTORE_YY_MORE_OFFSET \
 176                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 177                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 178                 } \
 179         while ( 0 )
 180
 181 #define unput(c) yyunput( c, (yytext_ptr)  )
 182
 183 #ifndef YY_TYPEDEF_YY_SIZE_T
 184 #define YY_TYPEDEF_YY_SIZE_T
 185 typedef size_t yy_size_t;
 186 #endif
 187
 188 #ifndef YY_STRUCT_YY_BUFFER_STATE
 189 #define YY_STRUCT_YY_BUFFER_STATE
 190 struct yy_buffer_state
 191         {
 192         FILE *yy_input_file;
 193
 194         char *yy_ch_buf;                /* input buffer */
 195         char *yy_buf_pos;               /* current position in input buffer */
 196
 197         /* Size of input buffer in bytes, not including room for EOB
 198          * characters.
 199          */
 200         yy_size_t yy_buf_size;
 201
 202         /* Number of characters read into yy_ch_buf, not including EOB
 203          * characters.
 204          */
 205         int yy_n_chars;
 206
 207         /* Whether we "own" the buffer - i.e., we know we created it,
 208          * and can realloc() it to grow it, and should free() it to
 209          * delete it.
 210          */
 211         int yy_is_our_buffer;
 212
 213         /* Whether this is an "interactive" input source; if so, and
 214          * if we're using stdio for input, then we want to use getc()
 215          * instead of fread(), to make sure we stop fetching input after
 216          * each newline.
 217          */
 218         int yy_is_interactive;
 219
 220         /* Whether we're considered to be at the beginning of a line.
 221          * If so, '^' rules will be active on the next match, otherwise
 222          * not.
 223          */
 224         int yy_at_bol;
 225
 226     int yy_bs_lineno; /**< The line count. */
 227     int yy_bs_column; /**< The column count. */
 228
 229         /* Whether to try to fill the input buffer when we reach the
 230          * end of it.
 231          */
 232         int yy_fill_buffer;
 233
 234         int yy_buffer_status;
 235
 236 #define YY_BUFFER_NEW 0
 237 #define YY_BUFFER_NORMAL 1
 238         /* When an EOF's been seen but there's still some text to process
 239          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 240          * shouldn't try reading from the input source any more.  We might
 241          * still have a bunch of tokens to match, though, because of
 242          * possible backing-up.
 243          *
 244          * When we actually see the EOF, we change the status to "new"
 245          * (via yyrestart()), so that the user can continue scanning by
 246          * just pointing yyin at a new input file.
 247          */
 248 #define YY_BUFFER_EOF_PENDING 2
 249
 250         };
 251 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 252
 253 /* Stack of input buffers. */
 254 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 255 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 256 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 257
 258 /* We provide macros for accessing buffer states in case in the
 259  * future we want to put the buffer states in a more general
 260  * "scanner state".
 261  *
 262  * Returns the top of the stack, or NULL.
 263  */
 264 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 265                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 266                           : NULL)
 267
 268 /* Same as previous macro, but useful when we know that the buffer stack is not
 269  * NULL or when we need an lvalue. For internal use only.
 270  */
 271 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 272
 273 /* yy_hold_char holds the character lost when yytext is formed. */
 274 static char yy_hold_char;
 275 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 276 int yyleng;
 277
 278 /* Points to current character in buffer. */
 279 static char *yy_c_buf_p = (char *) 0;
 280 static int yy_init = 0;         /* whether we need to initialize */
 281 static int yy_start = 0;        /* start state number */
 282
 283 /* Flag which is used to allow yywrap()'s to do buffer switches
 284  * instead of setting up a fresh yyin.  A bit of a hack ...
 285  */
 286 static int yy_did_buffer_switch_on_eof;
 287
 288 void yyrestart (FILE *input_file  );
 289 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 290 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 291 void yy_delete_buffer (YY_BUFFER_STATE b  );
 292 void yy_flush_buffer (YY_BUFFER_STATE b  );
 293 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 294 void yypop_buffer_state (void );
 295
 296 static void yyensure_buffer_stack (void );
 297 static void yy_load_buffer_state (void );
 298 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 299
 300 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 301
 302 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 303 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 304 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 305
 306 void *yyalloc (yy_size_t  );
 307 void *yyrealloc (void *,yy_size_t  );
 308 void yyfree (void *  );
 309
 310 #define yy_new_buffer yy_create_buffer
 311
 312 #define yy_set_interactive(is_interactive) \
 313         { \
 314         if ( ! YY_CURRENT_BUFFER ){ \
 315         yyensure_buffer_stack (); \
 316                 YY_CURRENT_BUFFER_LVALUE =    \
 317             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 318         } \
 319         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 320         }
 321
 322 #define yy_set_bol(at_bol) \
 323         { \
 324         if ( ! YY_CURRENT_BUFFER ){\
 325         yyensure_buffer_stack (); \
 326                 YY_CURRENT_BUFFER_LVALUE =    \
 327             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 328         } \
 329         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 330         }
 331
 332 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 333
 334 /* Begin user sect3 */
 335
 336 #define yywrap(n) 1
 337 #define YY_SKIP_YYWRAP
 338
 339 typedef unsigned char YY_CHAR;
 340
 341 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 342
 343 typedef int yy_state_type;
 344
 345 extern int yylineno;
 346
 347 int yylineno = 1;
 348
 349 extern char *yytext;
 350 #define yytext_ptr yytext
 351
 352 static yy_state_type yy_get_previous_state (void );
 353 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 354 static int yy_get_next_buffer (void );
 355 static void yy_fatal_error (yyconst char msg[]  );
 356
 357 /* Done after the current pattern has been matched and before the
 358  * corresponding action - sets up yytext.
 359  */
 360 #define YY_DO_BEFORE_ACTION \
 361         (yytext_ptr) = yy_bp; \
 362         yyleng = (size_t) (yy_cp - yy_bp); \
 363         (yy_hold_char) = *yy_cp; \
 364         *yy_cp = '\0'; \
 365         (yy_c_buf_p) = yy_cp;
 366
 367 #define YY_NUM_RULES 48
 368 #define YY_END_OF_BUFFER 49
 369 /* This struct is not used in this scanner,
 370    but its presence is necessary. */
 371 struct yy_trans_info
 372         {
 373         flex_int32_t yy_verify;
 374         flex_int32_t yy_nxt;
 375         };
 376 static yyconst flex_int16_t yy_accept[458] =
 377     {   0,
 378         0,    0,    0,    0,    0,    0,    0,    0,   49,   36,
 379        33,   45,   36,   45,   34,   36,   36,   34,   34,   34,
 380        34,   34,   31,   10,   10,   31,   29,   31,   31,   31,
 381        20,   31,   31,   31,   31,   31,   31,   31,   31,   31,
 382        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
 383        10,   31,   41,   39,   46,   46,    0,   37,    0,    0,
 384         0,   38,   32,   34,    0,    0,    0,    0,    0,    0,
 385         0,    0,    0,   34,   34,   34,   34,   34,   10,    0,
 386        25,    0,    0,    0,    0,    9,   20,   24,    0,    0,
 387         0,    0,    0,    0,    0,    0,    0,   26,   11,    0,
 388
 389         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 390         0,    0,    0,   10,    0,    0,    0,    0,   42,   44,
 391        43,   35,    0,    0,    0,    0,    0,    0,   34,   34,
 392        34,   34,   34,   34,   27,   28,    0,    0,    0,    0,
 393         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 394         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 395         0,   30,    0,    0,    0,    0,    0,    0,    0,    0,
 396         0,   34,   34,   34,   34,   34,   34,    0,    0,    0,
 397        13,    0,    0,   14,    0,    0,    0,    0,   22,   22,
 398         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 399
 400         0,    0,    0,    0,    0,    0,    0,   34,   34,   34,
 401        34,   34,   34,    0,    0,    0,    0,    0,    0,   17,
 402         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 403         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 404         0,    0,    0,    0,    0,    0,   34,   34,   34,   34,
 405        34,    3,    0,    0,    0,    0,    0,   12,    0,    0,
 406         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 407         0,    0,    0,    0,    0,   15,    0,    0,    0,    0,
 408         0,    0,    0,   34,    4,    5,    2,   34,    0,    0,
 409         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 410
 411         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 412        16,    0,    0,    0,    0,   34,    1,    0,    0,    0,
 413         0,    0,    0,    0,    0,    0,    0,    0,   22,   22,
 414         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 415        34,   34,   34,    0,    0,    0,    0,    0,    0,    0,
 416         0,    0,    0,    0,    0,   21,    0,    0,    0,    0,
 417         0,    0,   34,    7,    6,    0,    0,    0,    0,    0,
 418         0,    0,    0,    0,    0,    0,   18,    0,    0,    0,
 419        34,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 420         0,   19,    0,    0,   47,   34,    0,    0,    0,    0,
 421
 422         0,    0,    0,    0,    0,    0,    0,   34,    0,    0,
 423         0,    0,    0,    0,    0,    0,    0,   34,    0,   24,
 424        24,    0,    0,    0,    0,    0,    0,    0,    0,   34,
 425         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 426         0,    0,    8,    0,   23,    0,    0,    0,    0,    0,
 427        40,    0,    0,    0,    0,    0,    0
 428     } ;
 429
 430 static yyconst flex_int32_t yy_ec[256] =
 431     {   0,
 432         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 433         2,    2,    2,    1,    1,    1,    1,    1,    1,    1,
 434         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 435         1,    2,    1,    4,    5,    1,    6,    1,    7,    8,
 436         9,   10,    1,    6,    6,   11,   12,   13,   13,   13,
 437        13,   13,   13,   13,   13,   13,   13,    6,    6,    6,
 438         6,    6,    1,    1,   14,   15,   16,   17,   18,   19,
 439        20,   21,   22,   23,   23,   24,   25,   26,   27,   28,
 440        23,   29,   30,   31,   32,   33,   34,   23,   35,   23,
 441        36,   37,   38,    1,   39,    1,   40,   41,   42,   43,
 442
 443        44,   45,   46,   47,   48,   49,   49,   50,   51,   52,
 444        53,   54,   49,   55,   56,   57,   58,   59,   49,   60,
 445        61,   62,    6,    6,    6,    1,    1,    1,    1,    1,
 446         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 447         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 448         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 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,    1,    1,    1,    1,    1,
 452         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 453
 454         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 455         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 456         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 457         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 458         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 459         1,    1,    1,    1,    1
 460     } ;
 461
 462 static yyconst flex_int32_t yy_meta[63] =
 463     {   0,
 464         1,    2,    3,    1,    1,    1,    1,    1,    4,    5,
 465         1,    1,    6,    7,    7,    7,    7,    7,    7,    7,
 466         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
 467         7,    7,    7,    7,    7,    8,    1,    1,    9,    9,
 468         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 469         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 470         9,    9
 471     } ;
 472
 473 static yyconst flex_int16_t yy_base[496] =
 474     {   0,
 475         0,   38,   96,   12,   12,   13,   15,   16, 1038, 1444,
 476      1444,   16, 1000, 1026,    0,  157,   19, 1017,  974,  976,
 477       971,  979, 1444,   25,   27,   20, 1444,  993, 1018, 1018,
 478      1014,  215,  253,    4,    7,   25,   40,   41,  988, 1022,
 479         8,   31,   33,   36,   37,   38,   39,  133,  134,  136,
 480        67, 1022,    0, 1444, 1011, 1010,  160, 1444,    0, 1014,
 481      1017, 1444, 1444,    0,  187,  163, 1001,  958,  960,  940,
 482       948,  164,  955,  979,  940,   31,  942,  947,   77,  163,
 483      1444,  991,  986,  989,  980, 1444,  977, 1444,  962,  961,
 484        65,   58,   46,  141,  142,  159,  949, 1444, 1444,  149,
 485
 486       144,  151,  150,  152,  181,  153,  156,  184,  213,  214,
 487       220,  215,  221,  191,  984,  983,  291,    0, 1444, 1444,
 488      1444, 1444,  965,  926,  195,  928,  933,  935,  940,  919,
 489       905,  903,  916,  906, 1444, 1444,  171,  256,  160,  353,
 490       219,  201,  391,  354,  350,  222,  246,  355,  247,  429,
 491       339,  172,  244,  248,  352,  356,  340,  351,  359,  394,
 492       429, 1444,    0,    0,  919,  913,  899,  897,  910,  900,
 493       904,  918,  895,  901,  906,  904,  894,  249,  347,  348,
 494      1444,  349,  383, 1444,  386,  387,  491,  388, 1444,  528,
 495       419,  396,  384,  391,  477,  422,  478,  398,  479,    0,
 496
 497       912,  889,  895,  900,  898,  873,  872,  905,  870,  879,
 498       863,  875,  586,  437,  495,  492,  252,  203,  624, 1444,
 499         0,  891,  889,  496,  863,  868,  870,  861,  859,  322,
 500       859,  481,  499,  484,  489,  399,  488,  662,    0,  892,
 501       857,  866,  850,  862,    0,  861,  888,  700,  738,  776,
 502       858, 1444,  431,  344,  432,  433,  435, 1444,  860,  858,
 503       856,  854,  830,  842,  822,  363,  828,  826,  471,  822,
 504       508,  523,  491,  510,  814, 1444,    0,  861,    0,    0,
 505         0,  831,  511,  836, 1444, 1444, 1444,  852,  515,  513,
 506       524,  521,  536,  850,  857,  855,  840,  820,  814,  829,
 507
 508       828,  554,  820,  810,  797,  804,  799,  527,  545,  533,
 509      1444,    0,  807,    0,  562,  552, 1444,  353,  572,  540,
 510       573,  550,  806,  823,  804,  803,  784,  783, 1444,    0,
 511       782,  794,  798,  790,  548,  890,  558,    0,  589,  804,
 512       810,  928,  966,  582,  586,  588,  591,  610,  818,  818,
 513       802,  796,  786,  771,  592, 1444, 1004,    0,  803,    0,
 514         0,  776,  786, 1444, 1444,  621,  618,  623,  624,  625,
 515       631,  787,  779,  789,  784, 1042, 1444,    0,  781,  796,
 516       776,  619,  580,  630,  628,  648,  650,  771,  762,  780,
 517       782, 1444,    0,  771, 1444,  781,  661,  662,  664,  657,
 518
 519       655,  777,  765,  755,  775,    0,  776,  752,  666,  724,
 520       668,  768,  767,  743,  683,    0,  733,  692,  658,  713,
 521       715,  665,  753,  750,  751,  736,  743,    0,  701, 1080,
 522       703,  750,  722,  752,  754,  740,  709,  702,  692,  664,
 523         0,    0, 1444,  757, 1444,  759,  627,  602,  561,  530,
 524      1444,  438,  393,  378,  202,   56, 1444, 1118, 1127, 1136,
 525      1145, 1154, 1158, 1167, 1176, 1185, 1194, 1202, 1211, 1220,
 526      1229, 1238, 1247, 1256, 1265, 1273, 1282, 1290, 1298, 1306,
 527      1314, 1323, 1331, 1340, 1349, 1357, 1365, 1374, 1383, 1392,
 528      1400, 1409, 1417, 1426, 1435
 529
 530     } ;
 531
 532 static yyconst flex_int16_t yy_def[496] =
 533     {   0,
 534       458,  458,  457,    3,  459,  459,  459,  459,  457,  457,
 535       457,  460,  461,  462,  463,  457,  457,  463,  463,  463,
 536       463,  463,  457,  457,  457,  464,  457,  465,  457,  457,
 537       457,  466,  466,   33,   33,   33,   33,   33,  467,  457,
 538        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
 539       457,  468,  469,  457,  470,  470,  460,  457,  460,  457,
 540       461,  457,  457,  463,  457,  457,  457,  457,  457,  457,
 541       457,  457,  457,  463,  463,  463,  463,  463,  457,  464,
 542       457,  464,  457,  465,  457,  457,  457,  457,   33,   33,
 543        33,   33,   33,   33,   33,   33,  467,  457,  457,   33,
 544
 545        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
 546        33,   33,   33,  457,  468,  468,  457,  471,  457,  457,
 547       457,  457,  457,  457,  457,  457,  457,  457,  463,  463,
 548       463,  463,  463,  463,  457,  457,   33,   33,   33,  466,
 549        33,   33,  466,   33,   33,   33,   33,   33,   33,  466,
 550        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
 551       117,  457,  117,  472,  457,  457,  457,  457,  457,  457,
 552       457,  463,  463,  463,  463,  463,  463,   33,   33,   33,
 553       457,   33,   33,  457,   33,   33,  466,   33,  457,  457,
 554        33,   33,   33,   33,   33,   33,   33,   33,   33,  473,
 555
 556       457,  457,  457,  457,  457,  457,  457,  463,  463,  463,
 557       463,  463,  463,   33,   33,   33,   33,   33,  466,  457,
 558       190,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 559       457,   33,   33,   33,   33,   33,   33,  466,  474,  457,
 560       457,  457,  457,  457,  475,  457,  463,  463,  463,  463,
 561       463,  457,   33,   33,   33,   33,   33,  457,  457,  457,
 562       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 563        33,   33,   33,   33,  466,  457,  476,  457,  477,  478,
 564       479,  457,  457,  463,  457,  457,  457,  463,   33,   33,
 565        33,   33,   33,  457,  457,  457,  457,  457,  457,  457,
 566
 567       457,  480,  457,  457,  457,  457,  457,   33,   33,   33,
 568       457,  481,  457,  482,  457,  463,  457,   33,   33,   33,
 569        33,   33,  457,  457,  457,  457,  457,  457,  457,  190,
 570       457,  457,  457,  457,   33,  466,   33,  483,  457,  457,
 571       463,  463,  463,   33,   33,   33,   33,   33,  457,  457,
 572       457,  457,  457,  457,   33,  457,  466,  484,  457,  485,
 573       486,  457,  463,  457,  457,   33,   33,   33,   33,   33,
 574        33,  457,  457,  457,  457,  466,  457,  487,  457,  457,
 575       463,   33,   33,   33,   33,   33,   33,  457,  457,  457,
 576       457,  457,  488,  457,  457,  463,   33,   33,   33,   33,
 577
 578        33,  457,  457,  457,  457,  489,  457,  463,   33,   33,
 579        33,  457,  457,  457,  457,  490,  457,  463,   33,  457,
 580       491,   33,  457,  457,  457,  457,  457,  492,  457,  463,
 581        33,  457,  491,  491,  493,  457,  457,  457,  457,  457,
 582       494,  495,  457,  457,  457,  493,  457,  457,  457,  457,
 583       457,  457,  457,  457,  457,  457,    0,  457,  457,  457,
 584       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 585       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 586       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 587       457,  457,  457,  457,  457
 588
 589     } ;
 590
 591 static yyconst flex_int16_t yy_nxt[1507] =
 592     {   0,
 593        10,   10,   11,   12,   10,   10,   13,   10,   10,   10,
 594        10,   14,   10,   51,   54,   54,   52,   54,   54,   58,
 595        72,   55,   55,   81,   56,   56,   79,   79,   79,   79,
 596        89,   91,   92,   89,   89,   10,   10,   10,   10,   16,
 597        11,   12,   17,   10,   13,   10,   10,   10,   10,   14,
 598        10,   89,   59,   94,   18,   93,   82,   89,   96,   89,
 599       100,   73,   89,   89,   89,   89,   95,   89,  114,   79,
 600       131,  115,   89,   10,   10,   10,  103,  101,   79,   79,
 601       140,   19,  107,  102,   89,  132,  302,  104,  105,  139,
 602       106,   89,  138,   20,   21,   22,   23,   24,   25,   26,
 603
 604        23,   27,   28,   27,   27,   27,   29,   30,   31,   32,
 605        33,   34,   32,   35,   32,   36,   37,   32,   32,   32,
 606        32,   32,   32,   32,   32,   32,   32,   32,   38,   32,
 607        32,   39,   40,   23,   32,   32,   41,   42,   43,   44,
 608        32,   32,   32,   45,   32,   46,   32,   47,   32,   48,
 609        32,   49,   32,   50,   32,   32,   32,   32,   65,   89,
 610        89,   66,   89,   58,   72,   72,   81,   89,   89,  141,
 611        89,  142,  108,   67,  143,   89,   89,   89,   89,   89,
 612       110,  111,   89,  145,  180,   89,   89,  113,   65,  109,
 613       112,   66,  114,   79,  178,  115,   59,   89,   89,   82,
 614
 615        68,  144,  146,   67,  151,   73,   73,   89,  147,  148,
 616        89,  152,   69,   70,   71,   88,   88,   88,   88,   88,
 617        88,   88,   88,   88,   88,   88,   88,   89,  191,   89,
 618        68,  183,  302,  149,  167,  182,  257,  150,  153,   89,
 619        89,   89,   69,   70,   71,   89,   89,   89,   89,  168,
 620        88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
 621        88,   88,   88,   88,   88,  156,  155,  154,  159,  158,
 622        89,  179,   89,   89,   89,   89,  160,  185,   89,   90,
 623       256,  157,   89,  192,  186,  188,  193,  214,   88,   88,
 624        88,  161,  161,  162,  161,  161,  161,  161,  161,  161,
 625
 626       161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
 627       161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
 628       161,  161,  161,  161,  161,  161,  161,  161,  161,  163,
 629       163,  163,  163,  163,  163,  163,  163,  163,  163,  163,
 630       163,  163,  163,  163,  163,  163,  163,  163,  163,  163,
 631       163,  163,  163,  181,  181,  181,  181,  181,  181,  181,
 632       181,  181,  181,  181,  181,   89,   89,  215,  268,  269,
 633        89,  344,  290,   89,   89,   89,   89,   89,   89,   89,
 634        89,   89,   89,  196,  150,   89,  216,  217,  181,  181,
 635       181,  184,  184,  184,  184,  184,  184,  184,  184,  184,
 636
 637       184,  184,  184,  150,  150,  187,  194,  195,  197,   89,
 638        89,  198,   89,   89,   89,  301,  456,   89,  455,  302,
 639        89,  218,   89,  234,   89,   89,  184,  184,  184,  189,
 640       190,  190,  189,  189,  189,  189,  189,  189,  189,  189,
 641       189,  199,  219,  150,  150,   89,  233,  150,   89,  238,
 642       292,  253,  289,  291,  454,  150,  293,   89,   89,   89,
 643       236,   89,  232,   89,  189,  189,  189,  161,  161,  161,
 644       161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
 645       161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
 646       161,  220,  220,  220,  220,  220,  220,  220,  220,  220,
 647
 648       220,  220,  220,   89,   89,   89,  255,   89,  254,  261,
 649        89,  272,  315,  315,   89,   89,  305,   89,   89,  237,
 650       235,   89,  262,  271,  156,   89,  220,  220,  220,  221,
 651       221,  150,  306,  274,   89,  272,   89,  273,  309,   89,
 652       321,   89,  222,  223,  275,  318,  308,   89,  224,   89,
 653        89,  319,  322,   89,  320,  330,  330,  310,  346,   89,
 654       302,  273,   89,  315,  315,  341,   89,  348,  225,  226,
 655       227,   89,  337,  342,   89,  228,   89,  229,  343,  343,
 656       335,  340,  453,  230,   89,  231,  252,  252,  252,  252,
 657       252,  252,  252,  252,  252,  252,  252,  252,   89,   89,
 658
 659       336,  345,  359,  366,  355,  398,   89,  367,   89,  368,
 660       360,  347,   89,  357,   89,  361,  361,   89,   89,  452,
 661       369,  252,  252,  252,  258,  258,  258,  258,  258,  258,
 662       258,  258,  258,  258,  258,  258,   89,  383,  382,  370,
 663       384,  385,  397,  302,   89,   89,  376,   89,  371,   89,
 664        89,   89,  387,  399,   89,  386,   89,   89,  150,  258,
 665       258,  258,  276,  276,  276,  276,  276,  276,  276,  276,
 666       276,  276,  276,  276,   89,  401,   89,  150,  411,  409,
 667       410,   89,  419,   89,   89,  150,  400,   89,   89,  450,
 668        89,   89,   89,  422,   89,  150,  431,  276,  276,  276,
 669
 670       285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
 671       285,  285,  426,  430,  432,  432,  434,  434,  430,  430,
 672       433,  427,  442,  434,  434,  420,  420,  442,  442,   89,
 673       449,  421,  302,  150,  448,  285,  285,  285,  286,  286,
 674       286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
 675        89,  432,  432,  434,  434,  444,  444,  433,  444,  444,
 676       444,  444,  445,  447,  440,  445,  439,  445,  438,  437,
 677       436,  429,  425,  286,  286,  286,  287,  287,  287,  287,
 678       287,  287,  287,  287,  287,  287,  287,  287,  424,  423,
 679       418,  417,  415,  414,  413,  412,  408,  407,  405,  404,
 680
 681       403,  402,  396,  395,  394,  391,  390,  389,  388,  381,
 682       380,  287,  287,  287,  311,  311,  311,  311,  311,  311,
 683       311,  311,  311,  311,  311,  311,  379,  302,  302,  375,
 684       374,  373,  372,  363,  362,  305,  354,  353,  302,  302,
 685       302,  352,  351,  350,  349,  339,  334,  333,  332,  311,
 686       311,  311,  317,  317,  317,  317,  317,  317,  317,  317,
 687       317,  317,  317,  317,  331,  302,  328,  327,  302,  302,
 688       326,  325,  324,  323,  316,  314,  313,  307,  304,  303,
 689       300,  299,  298,  297,  296,  295,  294,  317,  317,  317,
 690       356,  356,  356,  356,  356,  356,  356,  356,  356,  356,
 691
 692       356,  356,  288,  284,  283,  282,  281,  280,  279,  278,
 693       270,  267,  266,  265,  264,  263,  260,  259,  251,  250,
 694       249,  248,  247,  246,  245,  356,  356,  356,  364,  364,
 695       364,  364,  364,  364,  364,  364,  364,  364,  364,  364,
 696       244,  243,  242,  241,  240,  213,  212,  211,  210,  209,
 697       208,  207,  206,  205,  204,  203,  202,  201,  177,  176,
 698       175,  174,  173,  364,  364,  364,  365,  365,  365,  365,
 699       365,  365,  365,  365,  365,  365,  365,  365,  172,  171,
 700       170,  169,  166,  165,  116,  116,   98,  137,   89,   87,
 701       136,  457,  135,  457,  134,  133,  130,  129,  128,  127,
 702
 703       126,  365,  365,  365,  377,  377,  377,  377,  377,  377,
 704       377,  377,  377,  377,  377,  377,  125,  124,  123,  457,
 705       122,  121,  120,  116,   99,   98,   87,   86,   85,   84,
 706        78,   77,   76,   75,   74,   63,   61,  457,  457,  377,
 707       377,  377,  392,  392,  392,  392,  392,  392,  392,  392,
 708       392,  392,  392,  392,  457,  457,  457,  457,  457,  457,
 709       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 710       457,  457,  457,  457,  457,  457,  457,  392,  392,  392,
 711       443,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 712       443,  443,  457,  457,  457,  457,  457,  457,  457,  457,
 713
 714       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 715       457,  457,  457,  457,  457,  443,  443,  443,   15,   15,
 716        15,   15,   15,   15,   15,   15,   15,   53,   53,   53,
 717        53,   53,   53,   53,   53,   53,   57,   57,   57,   57,
 718        57,   57,   57,   57,   57,   60,   60,   60,   60,   60,
 719        60,   60,   60,   60,   62,   62,   62,   62,   62,   62,
 720        62,   62,   62,   64,   64,  457,   64,   80,   80,   80,
 721        80,   80,   80,   80,   80,   80,   83,   83,   83,   83,
 722        83,   83,   83,   83,   83,   89,   89,   89,   89,   89,
 723        89,   89,   89,   89,   97,   97,   97,   97,   97,   97,
 724
 725        97,  457,   97,  117,  457,  457,  457,  457,  457,  457,
 726       117,  118,  118,  457,  118,  457,  118,  118,  118,  118,
 727       119,  119,  119,  119,  119,  119,  119,  119,  119,  164,
 728       164,  457,  164,  457,  164,  164,  164,  164,  200,  200,
 729       457,  200,  457,  200,  200,  200,  200,  239,  239,  457,
 730       239,  457,  239,  239,  239,  239,  277,  277,  457,  277,
 731       457,  277,  277,  277,  277,  252,  252,  252,  252,  252,
 732       457,  457,  252,  312,  312,  457,  312,  457,  312,  312,
 733       312,  312,  285,  285,  285,  285,  285,  457,  457,  285,
 734       286,  286,  286,  286,  286,  457,  457,  286,  287,  287,
 735
 736       287,  287,  287,  457,  457,  287,  329,  329,  329,  329,
 737       329,  457,  457,  329,  338,  338,  457,  338,  457,  338,
 738       338,  338,  338,  317,  317,  317,  317,  317,  457,  457,
 739       317,  358,  358,  457,  358,  457,  358,  358,  358,  358,
 740       378,  378,  457,  378,  457,  378,  378,  378,  378,  364,
 741       364,  364,  364,  364,  457,  457,  364,  365,  365,  365,
 742       365,  365,  457,  457,  365,  393,  393,  457,  393,  457,
 743       393,  393,  393,  393,  406,  406,  457,  406,  457,  406,
 744       406,  406,  406,  416,  416,  457,  416,  457,  416,  416,
 745       416,  416,  428,  428,  457,  428,  457,  428,  428,  428,
 746
 747       428,  435,  435,  457,  457,  457,  435,  457,  435,  441,
 748       441,  457,  441,  457,  441,  441,  441,  441,  446,  446,
 749       446,  457,  446,  446,  457,  446,  451,  451,  457,  451,
 750       457,  451,  451,  451,  451,  443,  443,  443,  443,  443,
 751       457,  457,  443,    9,  457,  457,  457,  457,  457,  457,
 752       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 753       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 754       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 755       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 756       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 757
 758       457,  457,  457,  457,  457,  457
 759     } ;
 760
 761 static yyconst flex_int16_t yy_chk[1507] =
 762     {   0,
 763         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 764         1,    1,    1,    4,    5,    6,    4,    7,    8,   12,
 765        17,    5,    6,   26,    7,    8,   24,   24,   25,   25,
 766        34,   34,   35,   35,   41,    1,    1,    1,    2,    2,
 767         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 768         2,   36,   12,   37,    2,   36,   26,   42,   38,   43,
 769        41,   17,   44,   45,   46,   47,   37,   38,   51,   51,
 770        76,   51,   93,    2,    2,    2,   43,   42,   79,   79,
 771        93,    2,   47,   42,   92,   76,  456,   44,   45,   92,
 772        46,   91,   91,    2,    2,    2,    3,    3,    3,    3,
 773
 774         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 775         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 776         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 777         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 778         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 779         3,    3,    3,    3,    3,    3,    3,    3,   16,   48,
 780        49,   16,   50,   57,   66,   72,   80,   94,   95,   94,
 781       101,   95,   48,   16,   96,  100,  103,  102,  104,  106,
 782        49,   49,  107,  101,  139,   96,  139,   50,   65,   48,
 783        49,   65,  114,  114,  137,  114,   57,  137,  152,   80,
 784
 785        16,  100,  102,   65,  106,   66,   72,  105,  103,  104,
 786       108,  107,   16,   16,   16,   32,   32,   32,   32,   32,
 787        32,   32,   32,   32,   32,   32,   32,  142,  152,  218,
 788        65,  142,  455,  105,  125,  141,  218,  105,  108,  109,
 789       110,  112,   65,   65,   65,  141,  111,  113,  146,  125,
 790        32,   32,   32,   33,   33,   33,   33,   33,   33,   33,
 791        33,   33,   33,   33,   33,  111,  110,  109,  113,  112,
 792       153,  138,  147,  149,  154,  178,  113,  146,  217,   33,
 793       217,  111,  138,  153,  147,  149,  154,  178,   33,   33,
 794        33,  117,  117,  117,  117,  117,  117,  117,  117,  117,
 795
 796       117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
 797       117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
 798       117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
 799       117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
 800       117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
 801       117,  117,  117,  140,  140,  140,  140,  140,  140,  140,
 802       140,  140,  140,  140,  140,  151,  157,  179,  230,  230,
 803       254,  318,  254,  179,  180,  182,  145,  158,  155,  318,
 804       144,  148,  156,  157,  151,  159,  180,  182,  140,  140,
 805       140,  143,  143,  143,  143,  143,  143,  143,  143,  143,
 806
 807       143,  143,  143,  144,  145,  148,  155,  156,  158,  183,
 808       193,  159,  185,  186,  188,  266,  454,  194,  453,  266,
 809       160,  183,  192,  193,  198,  236,  143,  143,  143,  150,
 810       150,  150,  150,  150,  150,  150,  150,  150,  150,  150,
 811       150,  160,  185,  186,  188,  191,  192,  194,  196,  198,
 812       256,  214,  253,  255,  452,  236,  257,  253,  255,  256,
 813       196,  257,  191,  214,  150,  150,  150,  161,  161,  161,
 814       161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
 815       161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
 816       161,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 817
 818       187,  187,  187,  195,  197,  199,  216,  232,  215,  224,
 819       234,  233,  283,  283,  237,  235,  269,  273,  216,  197,
 820       195,  215,  224,  232,  199,  233,  187,  187,  187,  190,
 821       190,  235,  269,  234,  271,  272,  274,  233,  273,  290,
 822       292,  289,  190,  190,  237,  289,  271,  292,  190,  272,
 823       291,  290,  293,  308,  291,  302,  302,  274,  320,  310,
 824       450,  272,  293,  315,  315,  316,  320,  322,  190,  190,
 825       190,  309,  310,  316,  335,  190,  322,  190,  316,  316,
 826       308,  315,  449,  190,  337,  190,  213,  213,  213,  213,
 827       213,  213,  213,  213,  213,  213,  213,  213,  319,  321,
 828
 829       309,  319,  339,  344,  335,  383,  383,  345,  344,  346,
 830       339,  321,  345,  337,  346,  339,  339,  347,  355,  448,
 831       347,  213,  213,  213,  219,  219,  219,  219,  219,  219,
 832       219,  219,  219,  219,  219,  219,  348,  367,  366,  348,
 833       368,  369,  382,  447,  367,  382,  355,  366,  348,  368,
 834       369,  370,  371,  384,  385,  370,  384,  371,  385,  219,
 835       219,  219,  238,  238,  238,  238,  238,  238,  238,  238,
 836       238,  238,  238,  238,  386,  387,  387,  397,  400,  398,
 837       399,  401,  409,  400,  419,  401,  386,  397,  398,  440,
 838       399,  422,  409,  411,  411,  422,  419,  238,  238,  238,
 839
 840       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
 841       248,  248,  415,  418,  420,  420,  421,  421,  418,  418,
 842       420,  415,  429,  433,  433,  410,  410,  429,  429,  431,
 843       439,  410,  438,  431,  437,  248,  248,  248,  249,  249,
 844       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
 845       410,  432,  432,  434,  434,  435,  435,  432,  444,  444,
 846       446,  446,  435,  436,  427,  444,  426,  446,  425,  424,
 847       423,  417,  414,  249,  249,  249,  250,  250,  250,  250,
 848       250,  250,  250,  250,  250,  250,  250,  250,  413,  412,
 849       408,  407,  405,  404,  403,  402,  396,  394,  391,  390,
 850
 851       389,  388,  381,  380,  379,  375,  374,  373,  372,  363,
 852       362,  250,  250,  250,  275,  275,  275,  275,  275,  275,
 853       275,  275,  275,  275,  275,  275,  359,  354,  353,  352,
 854       351,  350,  349,  341,  340,  334,  333,  332,  331,  328,
 855       327,  326,  325,  324,  323,  313,  307,  306,  305,  275,
 856       275,  275,  288,  288,  288,  288,  288,  288,  288,  288,
 857       288,  288,  288,  288,  304,  303,  301,  300,  299,  298,
 858       297,  296,  295,  294,  284,  282,  278,  270,  268,  267,
 859       265,  264,  263,  262,  261,  260,  259,  288,  288,  288,
 860       336,  336,  336,  336,  336,  336,  336,  336,  336,  336,
 861
 862       336,  336,  251,  247,  246,  244,  243,  242,  241,  240,
 863       231,  229,  228,  227,  226,  225,  223,  222,  212,  211,
 864       210,  209,  208,  207,  206,  336,  336,  336,  342,  342,
 865       342,  342,  342,  342,  342,  342,  342,  342,  342,  342,
 866       205,  204,  203,  202,  201,  177,  176,  175,  174,  173,
 867       172,  171,  170,  169,  168,  167,  166,  165,  134,  133,
 868       132,  131,  130,  342,  342,  342,  343,  343,  343,  343,
 869       343,  343,  343,  343,  343,  343,  343,  343,  129,  128,
 870       127,  126,  124,  123,  116,  115,   97,   90,   89,   87,
 871        85,   84,   83,   82,   78,   77,   75,   74,   73,   71,
 872
 873        70,  343,  343,  343,  357,  357,  357,  357,  357,  357,
 874       357,  357,  357,  357,  357,  357,   69,   68,   67,   61,
 875        60,   56,   55,   52,   40,   39,   31,   30,   29,   28,
 876        22,   21,   20,   19,   18,   14,   13,    9,    0,  357,
 877       357,  357,  376,  376,  376,  376,  376,  376,  376,  376,
 878       376,  376,  376,  376,    0,    0,    0,    0,    0,    0,
 879         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 880         0,    0,    0,    0,    0,    0,    0,  376,  376,  376,
 881       430,  430,  430,  430,  430,  430,  430,  430,  430,  430,
 882       430,  430,    0,    0,    0,    0,    0,    0,    0,    0,
 883
 884         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 885         0,    0,    0,    0,    0,  430,  430,  430,  458,  458,
 886       458,  458,  458,  458,  458,  458,  458,  459,  459,  459,
 887       459,  459,  459,  459,  459,  459,  460,  460,  460,  460,
 888       460,  460,  460,  460,  460,  461,  461,  461,  461,  461,
 889       461,  461,  461,  461,  462,  462,  462,  462,  462,  462,
 890       462,  462,  462,  463,  463,    0,  463,  464,  464,  464,
 891       464,  464,  464,  464,  464,  464,  465,  465,  465,  465,
 892       465,  465,  465,  465,  465,  466,  466,  466,  466,  466,
 893       466,  466,  466,  466,  467,  467,  467,  467,  467,  467,
 894
 895       467,    0,  467,  468,    0,    0,    0,    0,    0,    0,
 896       468,  469,  469,    0,  469,    0,  469,  469,  469,  469,
 897       470,  470,  470,  470,  470,  470,  470,  470,  470,  471,
 898       471,    0,  471,    0,  471,  471,  471,  471,  472,  472,
 899         0,  472,    0,  472,  472,  472,  472,  473,  473,    0,
 900       473,    0,  473,  473,  473,  473,  474,  474,    0,  474,
 901         0,  474,  474,  474,  474,  475,  475,  475,  475,  475,
 902         0,    0,  475,  476,  476,    0,  476,    0,  476,  476,
 903       476,  476,  477,  477,  477,  477,  477,    0,    0,  477,
 904       478,  478,  478,  478,  478,    0,    0,  478,  479,  479,
 905
 906       479,  479,  479,    0,    0,  479,  480,  480,  480,  480,
 907       480,    0,    0,  480,  481,  481,    0,  481,    0,  481,
 908       481,  481,  481,  482,  482,  482,  482,  482,    0,    0,
 909       482,  483,  483,    0,  483,    0,  483,  483,  483,  483,
 910       484,  484,    0,  484,    0,  484,  484,  484,  484,  485,
 911       485,  485,  485,  485,    0,    0,  485,  486,  486,  486,
 912       486,  486,    0,    0,  486,  487,  487,    0,  487,    0,
 913       487,  487,  487,  487,  488,  488,    0,  488,    0,  488,
 914       488,  488,  488,  489,  489,    0,  489,    0,  489,  489,
 915       489,  489,  490,  490,    0,  490,    0,  490,  490,  490,
 916
 917       490,  491,  491,    0,    0,    0,  491,    0,  491,  492,
 918       492,    0,  492,    0,  492,  492,  492,  492,  493,  493,
 919       493,    0,  493,  493,    0,  493,  494,  494,    0,  494,
 920         0,  494,  494,  494,  494,  495,  495,  495,  495,  495,
 921         0,    0,  495,  457,  457,  457,  457,  457,  457,  457,
 922       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 923       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 924       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 925       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 926       457,  457,  457,  457,  457,  457,  457,  457,  457,  457,
 927
 928       457,  457,  457,  457,  457,  457
 929     } ;
 930
 931 static yy_state_type yy_last_accepting_state;
 932 static char *yy_last_accepting_cpos;
 933
 934 extern int yy_flex_debug;
 935 int yy_flex_debug = 0;
 936
 937 /* The intent behind this definition is that it'll catch
 938  * any uses of REJECT which flex missed.
 939  */
 940 #define REJECT reject_used_but_not_detected
 941 #define yymore() yymore_used_but_not_detected
 942 #define YY_MORE_ADJ 0
 943 #define YY_RESTORE_YY_MORE_OFFSET
 944 char *yytext;
 945 #line 1 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
 946 /* -*- indented-text -*- */
 947 /* Process source files and output type information.
 948    Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
 949    Free Software Foundation, Inc.
 950
 951 This file is part of GCC.
 952
 953 GCC is free software; you can redistribute it and/or modify it under
 954 the terms of the GNU General Public License as published by the Free
 955 Software Foundation; either version 3, or (at your option) any later
 956 version.
 957
 958 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 959 WARRANTY; without even the implied warranty of MERCHANTABILITY or
 960 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 961 for more details.
 962
 963 You should have received a copy of the GNU General Public License
 964 along with GCC; see the file COPYING3.  If not see
 965 <http://www.gnu.org/licenses/>.  */
 966 #define YY_NO_INPUT 1
 967 #line 25 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
 968 #ifdef GENERATOR_FILE
 969 #include "bconfig.h"
 970 #else
 971 #include "config.h"
 972 #endif
 973 #include "system.h"
 974
 975 #define malloc xmalloc
 976 #define realloc xrealloc
 977
 978 #include "gengtype.h"
 979
 980 #define YY_DECL int yylex (const char **yylval)
 981 #define yyterminate() return EOF_TOKEN
 982
 983 struct fileloc lexer_line;
 984 int lexer_toplevel_done;
 985
 986 static void
 987 update_lineno (const char *l, size_t len)
 988 {
 989   while (len-- > 0)
 990     if (*l++ == '\n')
 991       lexer_line.line++;
 992 }
 993
 994
 995 #line 995 "gengtype-lex.c"
 996
 997 #define INITIAL 0
 998 #define in_struct 1
 999 #define in_struct_comment 2
1000 #define in_comment 3
1001
1002 #ifndef YY_NO_UNISTD_H
1003 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1004  * down here because we want the user's section 1 to have been scanned first.
1005  * The user has a chance to override it with an option.
1006  */
1007 #include <unistd.h>
1008 #endif
1009
1010 #ifndef YY_EXTRA_TYPE
1011 #define YY_EXTRA_TYPE void *
1012 #endif
1013
1014 static int yy_init_globals (void );
1015
1016 /* Accessor methods to globals.
1017    These are made visible to non-reentrant scanners for convenience. */
1018
1019 int yylex_destroy (void );
1020
1021 int yyget_debug (void );
1022
1023 void yyset_debug (int debug_flag  );
1024
1025 YY_EXTRA_TYPE yyget_extra (void );
1026
1027 void yyset_extra (YY_EXTRA_TYPE user_defined  );
1028
1029 FILE *yyget_in (void );
1030
1031 void yyset_in  (FILE * in_str  );
1032
1033 FILE *yyget_out (void );
1034
1035 void yyset_out  (FILE * out_str  );
1036
1037 int yyget_leng (void );
1038
1039 char *yyget_text (void );
1040
1041 int yyget_lineno (void );
1042
1043 void yyset_lineno (int line_number  );
1044
1045 /* Macros after this point can all be overridden by user definitions in
1046  * section 1.
1047  */
1048
1049 #ifndef YY_SKIP_YYWRAP
1050 #ifdef __cplusplus
1051 extern "C" int yywrap (void );
1052 #else
1053 extern int yywrap (void );
1054 #endif
1055 #endif
1056
1057 #ifndef yytext_ptr
1058 static void yy_flex_strncpy (char *,yyconst char *,int );
1059 #endif
1060
1061 #ifdef YY_NEED_STRLEN
1062 static int yy_flex_strlen (yyconst char * );
1063 #endif
1064
1065 #ifndef YY_NO_INPUT
1066
1067 #ifdef __cplusplus
1068 static int yyinput (void );
1069 #else
1070 static int input (void );
1071 #endif
1072
1073 #endif
1074
1075 /* Amount of stuff to slurp up with each read. */
1076 #ifndef YY_READ_BUF_SIZE
1077 #define YY_READ_BUF_SIZE 8192
1078 #endif
1079
1080 /* Copy whatever the last rule matched to the standard output. */
1081 #ifndef ECHO
1082 /* This used to be an fputs(), but since the string might contain NUL's,
1083  * we now use fwrite().
1084  */
1085 #define ECHO fwrite( yytext, yyleng, 1, yyout )
1086 #endif
1087
1088 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1089  * is returned in "result".
1090  */
1091 #ifndef YY_INPUT
1092 #define YY_INPUT(buf,result,max_size) \
1093         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1094                 { \
1095                 int c = '*'; \
1096                 int n; \
1097                 for ( n = 0; n < max_size && \
1098                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1099                         buf[n] = (char) c; \
1100                 if ( c == '\n' ) \
1101                         buf[n++] = (char) c; \
1102                 if ( c == EOF && ferror( yyin ) ) \
1103                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1104                 result = n; \
1105                 } \
1106         else \
1107                 { \
1108                 errno=0; \
1109                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1110                         { \
1111                         if( errno != EINTR) \
1112                                 { \
1113                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1114                                 break; \
1115                                 } \
1116                         errno=0; \
1117                         clearerr(yyin); \
1118                         } \
1119                 }\
1120 \
1121
1122 #endif
1123
1124 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1125  * we don't want an extra ';' after the "return" because that will cause
1126  * some compilers to complain about unreachable statements.
1127  */
1128 #ifndef yyterminate
1129 #define yyterminate() return YY_NULL
1130 #endif
1131
1132 /* Number of entries by which start-condition stack grows. */
1133 #ifndef YY_START_STACK_INCR
1134 #define YY_START_STACK_INCR 25
1135 #endif
1136
1137 /* Report a fatal error. */
1138 #ifndef YY_FATAL_ERROR
1139 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1140 #endif
1141
1142 /* end tables serialization structures and prototypes */
1143
1144 /* Default declaration of generated scanner - a define so the user can
1145  * easily add parameters.
1146  */
1147 #ifndef YY_DECL
1148 #define YY_DECL_IS_OURS 1
1149
1150 extern int yylex (void);
1151
1152 #define YY_DECL int yylex (void)
1153 #endif /* !YY_DECL */
1154
1155 /* Code executed at the beginning of each rule, after yytext and yyleng
1156  * have been set up.
1157  */
1158 #ifndef YY_USER_ACTION
1159 #define YY_USER_ACTION
1160 #endif
1161
1162 /* Code executed at the end of each rule. */
1163 #ifndef YY_BREAK
1164 #define YY_BREAK break;
1165 #endif
1166
1167 #define YY_RULE_SETUP \
1168         if ( yyleng > 0 ) \
1169                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1170                                 (yytext[yyleng - 1] == '\n'); \
1171         YY_USER_ACTION
1172
1173 /** The main scanner function which does all the work.
1174  */
1175 YY_DECL
1176 {
1177         register yy_state_type yy_current_state;
1178         register char *yy_cp, *yy_bp;
1179         register int yy_act;
1180
1181 #line 63 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1182
1183   /* Do this on entry to yylex():  */
1184   *yylval = 0;
1185   if (lexer_toplevel_done)
1186     {
1187       BEGIN(INITIAL);
1188       lexer_toplevel_done = 0;
1189     }
1190
1191   /* Things we look for in skipping mode: */
1192 #line 1192 "gengtype-lex.c"
1193
1194         if ( !(yy_init) )
1195                 {
1196                 (yy_init) = 1;
1197
1198 #ifdef YY_USER_INIT
1199                 YY_USER_INIT;
1200 #endif
1201
1202                 if ( ! (yy_start) )
1203                         (yy_start) = 1; /* first start state */
1204
1205                 if ( ! yyin )
1206                         yyin = stdin;
1207
1208                 if ( ! yyout )
1209                         yyout = stdout;
1210
1211                 if ( ! YY_CURRENT_BUFFER ) {
1212                         yyensure_buffer_stack ();
1213                         YY_CURRENT_BUFFER_LVALUE =
1214                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1215                 }
1216
1217                 yy_load_buffer_state( );
1218                 }
1219
1220         while ( 1 )             /* loops until end-of-file is reached */
1221                 {
1222                 yy_cp = (yy_c_buf_p);
1223
1224                 /* Support of yytext. */
1225                 *yy_cp = (yy_hold_char);
1226
1227                 /* yy_bp points to the position in yy_ch_buf of the start of
1228                  * the current run.
1229                  */
1230                 yy_bp = yy_cp;
1231
1232                 yy_current_state = (yy_start);
1233                 yy_current_state += YY_AT_BOL();
1234 yy_match:
1235                 do
1236                         {
1237                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1238                         if ( yy_accept[yy_current_state] )
1239                                 {
1240                                 (yy_last_accepting_state) = yy_current_state;
1241                                 (yy_last_accepting_cpos) = yy_cp;
1242                                 }
1243                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1244                                 {
1245                                 yy_current_state = (int) yy_def[yy_current_state];
1246                                 if ( yy_current_state >= 458 )
1247                                         yy_c = yy_meta[(unsigned int) yy_c];
1248                                 }
1249                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1250                         ++yy_cp;
1251                         }
1252                 while ( yy_current_state != 457 );
1253                 yy_cp = (yy_last_accepting_cpos);
1254                 yy_current_state = (yy_last_accepting_state);
1255
1256 yy_find_action:
1257                 yy_act = yy_accept[yy_current_state];
1258
1259                 YY_DO_BEFORE_ACTION;
1260
1261 do_action:      /* This label is used only to access EOF actions. */
1262
1263                 switch ( yy_act )
1264         { /* beginning of action switch */
1265                         case 0: /* must back up */
1266                         /* undo the effects of YY_DO_BEFORE_ACTION */
1267                         *yy_cp = (yy_hold_char);
1268                         yy_cp = (yy_last_accepting_cpos);
1269                         yy_current_state = (yy_last_accepting_state);
1270                         goto yy_find_action;
1271
1272 case 1:
1273 /* rule 1 can match eol */
1274 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1275 (yy_c_buf_p) = yy_cp -= 1;
1276 YY_DO_BEFORE_ACTION; /* set up yytext again */
1277 YY_RULE_SETUP
1278 #line 74 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1279 {
1280   BEGIN(in_struct);
1281   return TYPEDEF;
1282 }
1283         YY_BREAK
1284 case 2:
1285 /* rule 2 can match eol */
1286 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1287 (yy_c_buf_p) = yy_cp -= 1;
1288 YY_DO_BEFORE_ACTION; /* set up yytext again */
1289 YY_RULE_SETUP
1290 #line 78 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1291 {
1292   BEGIN(in_struct);
1293   return STRUCT;
1294 }
1295         YY_BREAK
1296 case 3:
1297 /* rule 3 can match eol */
1298 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1299 (yy_c_buf_p) = yy_cp -= 1;
1300 YY_DO_BEFORE_ACTION; /* set up yytext again */
1301 YY_RULE_SETUP
1302 #line 82 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1303 {
1304   BEGIN(in_struct);
1305   return UNION;
1306 }
1307         YY_BREAK
1308 case 4:
1309 /* rule 4 can match eol */
1310 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1311 (yy_c_buf_p) = yy_cp -= 1;
1312 YY_DO_BEFORE_ACTION; /* set up yytext again */
1313 YY_RULE_SETUP
1314 #line 86 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1315 {
1316   BEGIN(in_struct);
1317   return EXTERN;
1318 }
1319         YY_BREAK
1320 case 5:
1321 /* rule 5 can match eol */
1322 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1323 (yy_c_buf_p) = yy_cp -= 1;
1324 YY_DO_BEFORE_ACTION; /* set up yytext again */
1325 YY_RULE_SETUP
1326 #line 90 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1327 {
1328   BEGIN(in_struct);
1329   return STATIC;
1330 }
1331         YY_BREAK
1332 case 6:
1333 /* rule 6 can match eol */
1334 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1335 (yy_c_buf_p) = yy_cp -= 1;
1336 YY_DO_BEFORE_ACTION; /* set up yytext again */
1337 YY_RULE_SETUP
1338 #line 95 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1339 {
1340   BEGIN(in_struct);
1341   return DEFVEC_OP;
1342 }
1343         YY_BREAK
1344 case 7:
1345 /* rule 7 can match eol */
1346 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1347 (yy_c_buf_p) = yy_cp -= 1;
1348 YY_DO_BEFORE_ACTION; /* set up yytext again */
1349 YY_RULE_SETUP
1350 #line 99 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1351 {
1352   BEGIN(in_struct);
1353   return DEFVEC_I;
1354 }
1355         YY_BREAK
1356 case 8:
1357 /* rule 8 can match eol */
1358 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1359 (yy_c_buf_p) = yy_cp -= 1;
1360 YY_DO_BEFORE_ACTION; /* set up yytext again */
1361 YY_RULE_SETUP
1362 #line 103 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1363 {
1364   BEGIN(in_struct);
1365   return DEFVEC_ALLOC;
1366 }
1367         YY_BREAK
1368
1369
1370 case 9:
1371 YY_RULE_SETUP
1372 #line 111 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1373 { BEGIN(in_struct_comment); }
1374         YY_BREAK
1375 case 10:
1376 /* rule 10 can match eol */
1377 YY_RULE_SETUP
1378 #line 113 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1379 { update_lineno (yytext, yyleng); }
1380         YY_BREAK
1381 case 11:
1382 /* rule 11 can match eol */
1383 YY_RULE_SETUP
1384 #line 114 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1385 { lexer_line.line++; }
1386         YY_BREAK
1387 case 12:
1388 /* rule 12 can match eol */
1389 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1390 (yy_c_buf_p) = yy_cp = yy_bp + 5;
1391 YY_DO_BEFORE_ACTION; /* set up yytext again */
1392 YY_RULE_SETUP
1393 #line 116 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1394 /* don't care */
1395         YY_BREAK
1396 case 13:
1397 /* rule 13 can match eol */
1398 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1399 (yy_c_buf_p) = yy_cp = yy_bp + 3;
1400 YY_DO_BEFORE_ACTION; /* set up yytext again */
1401 YY_RULE_SETUP
1402 #line 117 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1403 { return GTY_TOKEN; }
1404         YY_BREAK
1405 case 14:
1406 /* rule 14 can match eol */
1407 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1408 (yy_c_buf_p) = yy_cp = yy_bp + 3;
1409 YY_DO_BEFORE_ACTION; /* set up yytext again */
1410 YY_RULE_SETUP
1411 #line 118 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1412 { return VEC_TOKEN; }
1413         YY_BREAK
1414 case 15:
1415 /* rule 15 can match eol */
1416 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1417 (yy_c_buf_p) = yy_cp = yy_bp + 5;
1418 YY_DO_BEFORE_ACTION; /* set up yytext again */
1419 YY_RULE_SETUP
1420 #line 119 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1421 { return UNION; }
1422         YY_BREAK
1423 case 16:
1424 /* rule 16 can match eol */
1425 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1426 (yy_c_buf_p) = yy_cp = yy_bp + 6;
1427 YY_DO_BEFORE_ACTION; /* set up yytext again */
1428 YY_RULE_SETUP
1429 #line 120 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1430 { return STRUCT; }
1431         YY_BREAK
1432 case 17:
1433 /* rule 17 can match eol */
1434 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1435 (yy_c_buf_p) = yy_cp = yy_bp + 4;
1436 YY_DO_BEFORE_ACTION; /* set up yytext again */
1437 YY_RULE_SETUP
1438 #line 121 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1439 { return ENUM; }
1440         YY_BREAK
1441 case 18:
1442 /* rule 18 can match eol */
1443 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1444 (yy_c_buf_p) = yy_cp = yy_bp + 9;
1445 YY_DO_BEFORE_ACTION; /* set up yytext again */
1446 YY_RULE_SETUP
1447 #line 122 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1448 { return PTR_ALIAS; }
1449         YY_BREAK
1450 case 19:
1451 /* rule 19 can match eol */
1452 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1453 (yy_c_buf_p) = yy_cp = yy_bp + 10;
1454 YY_DO_BEFORE_ACTION; /* set up yytext again */
1455 YY_RULE_SETUP
1456 #line 123 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1457 { return NESTED_PTR; }
1458         YY_BREAK
1459 case 20:
1460 YY_RULE_SETUP
1461 #line 124 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1462 { return NUM; }
1463         YY_BREAK
1464 case 21:
1465 /* rule 21 can match eol */
1466 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1467 (yy_c_buf_p) = yy_cp -= 1;
1468 YY_DO_BEFORE_ACTION; /* set up yytext again */
1469 YY_RULE_SETUP
1470 #line 125 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1471 {
1472   *yylval = XDUPVAR (const char, yytext, yyleng, yyleng+1);
1473   return PARAM_IS;
1474 }
1475         YY_BREAK
1476 case 22:
1477 /* rule 22 can match eol */
1478 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1479 (yy_c_buf_p) = yy_cp -= 1;
1480 YY_DO_BEFORE_ACTION; /* set up yytext again */
1481 #line 131 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1482 case 23:
1483 /* rule 23 can match eol */
1484 YY_RULE_SETUP
1485 #line 131 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1486 {
1487   size_t len;
1488
1489   for (len = yyleng; ISSPACE (yytext[len-1]); len--)
1490     ;
1491
1492   *yylval = XDUPVAR (const char, yytext, len, len+1);
1493   update_lineno (yytext, yyleng);
1494   return SCALAR;
1495 }
1496         YY_BREAK
1497 case 24:
1498 /* rule 24 can match eol */
1499 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1500 (yy_c_buf_p) = yy_cp -= 1;
1501 YY_DO_BEFORE_ACTION; /* set up yytext again */
1502 YY_RULE_SETUP
1503 #line 143 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1504 {
1505   *yylval = XDUPVAR (const char, yytext, yyleng, yyleng+1);
1506   return ID;
1507 }
1508         YY_BREAK
1509 case 25:
1510 /* rule 25 can match eol */
1511 YY_RULE_SETUP
1512 #line 148 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1513 {
1514   *yylval = XDUPVAR (const char, yytext+1, yyleng-2, yyleng-1);
1515   return STRING;
1516 }
1517         YY_BREAK
1518 /* This "terminal" avoids having to parse integer constant expressions.  */
1519 case 26:
1520 /* rule 26 can match eol */
1521 YY_RULE_SETUP
1522 #line 153 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1523 {
1524   *yylval = XDUPVAR (const char, yytext+1, yyleng-2, yyleng-1);
1525   return ARRAY;
1526 }
1527         YY_BREAK
1528 case 27:
1529 /* rule 27 can match eol */
1530 YY_RULE_SETUP
1531 #line 157 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1532 {
1533   *yylval = XDUPVAR (const char, yytext+1, yyleng-2, yyleng);
1534   return CHAR;
1535 }
1536         YY_BREAK
1537 case 28:
1538 YY_RULE_SETUP
1539 #line 162 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1540 { return ELLIPSIS; }
1541         YY_BREAK
1542 case 29:
1543 YY_RULE_SETUP
1544 #line 163 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1545 { return yytext[0]; }
1546         YY_BREAK
1547 /* ignore pp-directives */
1548 case 30:
1549 /* rule 30 can match eol */
1550 YY_RULE_SETUP
1551 #line 166 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1552 {lexer_line.line++;}
1553         YY_BREAK
1554 case 31:
1555 YY_RULE_SETUP
1556 #line 168 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1557 {
1558   error_at_line (&lexer_line, "unexpected character `%s'", yytext);
1559 }
1560         YY_BREAK
1561
1562 case 32:
1563 YY_RULE_SETUP
1564 #line 173 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1565 { BEGIN(in_comment); }
1566         YY_BREAK
1567 case 33:
1568 /* rule 33 can match eol */
1569 YY_RULE_SETUP
1570 #line 174 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1571 { lexer_line.line++; }
1572         YY_BREAK
1573 case 34:
1574 #line 176 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1575 case 35:
1576 /* rule 35 can match eol */
1577 #line 177 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1578 case 36:
1579 /* rule 36 can match eol */
1580 YY_RULE_SETUP
1581 #line 177 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1582 /* do nothing */
1583         YY_BREAK
1584 case 37:
1585 /* rule 37 can match eol */
1586 YY_RULE_SETUP
1587 #line 178 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1588 { update_lineno (yytext, yyleng); }
1589         YY_BREAK
1590 case 38:
1591 /* rule 38 can match eol */
1592 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1593 (yy_c_buf_p) = yy_cp = yy_bp + 1;
1594 YY_DO_BEFORE_ACTION; /* set up yytext again */
1595 YY_RULE_SETUP
1596 #line 179 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1597 /* do nothing */
1598         YY_BREAK
1599
1600 case 39:
1601 /* rule 39 can match eol */
1602 YY_RULE_SETUP
1603 #line 182 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1604 { lexer_line.line++; }
1605         YY_BREAK
1606 case 40:
1607 #line 184 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1608 case 41:
1609 YY_RULE_SETUP
1610 #line 184 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1611 /* do nothing */
1612         YY_BREAK
1613 case 42:
1614 /* rule 42 can match eol */
1615 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1616 (yy_c_buf_p) = yy_cp = yy_bp + 1;
1617 YY_DO_BEFORE_ACTION; /* set up yytext again */
1618 YY_RULE_SETUP
1619 #line 185 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1620 /* do nothing */
1621         YY_BREAK
1622
1623 case 43:
1624 YY_RULE_SETUP
1625 #line 187 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1626 { BEGIN(INITIAL); }
1627         YY_BREAK
1628 case 44:
1629 YY_RULE_SETUP
1630 #line 188 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1631 { BEGIN(in_struct); }
1632         YY_BREAK
1633 case 45:
1634 #line 191 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1635 case 46:
1636 YY_RULE_SETUP
1637 #line 191 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1638 {
1639   error_at_line (&lexer_line,
1640                  "unterminated comment or string; unexpected EOF");
1641 }
1642         YY_BREAK
1643 case 47:
1644 /* rule 47 can match eol */
1645 YY_RULE_SETUP
1646 #line 196 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1647 /* do nothing */
1648         YY_BREAK
1649 case 48:
1650 YY_RULE_SETUP
1651 #line 198 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
1652 YY_FATAL_ERROR( "flex scanner jammed" );
1653         YY_BREAK
1654 #line 1654 "gengtype-lex.c"
1655 case YY_STATE_EOF(INITIAL):
1656 case YY_STATE_EOF(in_struct):
1657 case YY_STATE_EOF(in_struct_comment):
1658 case YY_STATE_EOF(in_comment):
1659         yyterminate();
1660
1661         case YY_END_OF_BUFFER:
1662                 {
1663                 /* Amount of text matched not including the EOB char. */
1664                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1665
1666                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1667                 *yy_cp = (yy_hold_char);
1668                 YY_RESTORE_YY_MORE_OFFSET
1669
1670                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1671                         {
1672                         /* We're scanning a new file or input source.  It's
1673                          * possible that this happened because the user
1674                          * just pointed yyin at a new source and called
1675                          * yylex().  If so, then we have to assure
1676                          * consistency between YY_CURRENT_BUFFER and our
1677                          * globals.  Here is the right place to do so, because
1678                          * this is the first action (other than possibly a
1679                          * back-up) that will match for the new input source.
1680                          */
1681                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1682                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1683                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1684                         }
1685
1686                 /* Note that here we test for yy_c_buf_p "<=" to the position
1687                  * of the first EOB in the buffer, since yy_c_buf_p will
1688                  * already have been incremented past the NUL character
1689                  * (since all states make transitions on EOB to the
1690                  * end-of-buffer state).  Contrast this with the test
1691                  * in input().
1692                  */
1693                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1694                         { /* This was really a NUL. */
1695                         yy_state_type yy_next_state;
1696
1697                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1698
1699                         yy_current_state = yy_get_previous_state(  );
1700
1701                         /* Okay, we're now positioned to make the NUL
1702                          * transition.  We couldn't have
1703                          * yy_get_previous_state() go ahead and do it
1704                          * for us because it doesn't know how to deal
1705                          * with the possibility of jamming (and we don't
1706                          * want to build jamming into it because then it
1707                          * will run more slowly).
1708                          */
1709
1710                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1711
1712                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1713
1714                         if ( yy_next_state )
1715                                 {
1716                                 /* Consume the NUL. */
1717                                 yy_cp = ++(yy_c_buf_p);
1718                                 yy_current_state = yy_next_state;
1719                                 goto yy_match;
1720                                 }
1721
1722                         else
1723                                 {
1724                                 yy_cp = (yy_last_accepting_cpos);
1725                                 yy_current_state = (yy_last_accepting_state);
1726                                 goto yy_find_action;
1727                                 }
1728                         }
1729
1730                 else switch ( yy_get_next_buffer(  ) )
1731                         {
1732                         case EOB_ACT_END_OF_FILE:
1733                                 {
1734                                 (yy_did_buffer_switch_on_eof) = 0;
1735
1736                                 if ( yywrap( ) )
1737                                         {
1738                                         /* Note: because we've taken care in
1739                                          * yy_get_next_buffer() to have set up
1740                                          * yytext, we can now set up
1741                                          * yy_c_buf_p so that if some total
1742                                          * hoser (like flex itself) wants to
1743                                          * call the scanner after we return the
1744                                          * YY_NULL, it'll still work - another
1745                                          * YY_NULL will get returned.
1746                                          */
1747                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1748
1749                                         yy_act = YY_STATE_EOF(YY_START);
1750                                         goto do_action;
1751                                         }
1752
1753                                 else
1754                                         {
1755                                         if ( ! (yy_did_buffer_switch_on_eof) )
1756                                                 YY_NEW_FILE;
1757                                         }
1758                                 break;
1759                                 }
1760
1761                         case EOB_ACT_CONTINUE_SCAN:
1762                                 (yy_c_buf_p) =
1763                                         (yytext_ptr) + yy_amount_of_matched_text;
1764
1765                                 yy_current_state = yy_get_previous_state(  );
1766
1767                                 yy_cp = (yy_c_buf_p);
1768                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1769                                 goto yy_match;
1770
1771                         case EOB_ACT_LAST_MATCH:
1772                                 (yy_c_buf_p) =
1773                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1774
1775                                 yy_current_state = yy_get_previous_state(  );
1776
1777                                 yy_cp = (yy_c_buf_p);
1778                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1779                                 goto yy_find_action;
1780                         }
1781                 break;
1782                 }
1783
1784         default:
1785                 YY_FATAL_ERROR(
1786                         "fatal flex scanner internal error--no action found" );
1787         } /* end of action switch */
1788                 } /* end of scanning one token */
1789 } /* end of yylex */
1790
1791 /* yy_get_next_buffer - try to read in a new buffer
1792  *
1793  * Returns a code representing an action:
1794  *      EOB_ACT_LAST_MATCH -
1795  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1796  *      EOB_ACT_END_OF_FILE - end of file
1797  */
1798 static int yy_get_next_buffer (void)
1799 {
1800         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1801         register char *source = (yytext_ptr);
1802         register int number_to_move, i;
1803         int ret_val;
1804
1805         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1806                 YY_FATAL_ERROR(
1807                 "fatal flex scanner internal error--end of buffer missed" );
1808
1809         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1810                 { /* Don't try to fill the buffer, so this is an EOF. */
1811                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1812                         {
1813                         /* We matched a single character, the EOB, so
1814                          * treat this as a final EOF.
1815                          */
1816                         return EOB_ACT_END_OF_FILE;
1817                         }
1818
1819                 else
1820                         {
1821                         /* We matched some text prior to the EOB, first
1822                          * process it.
1823                          */
1824                         return EOB_ACT_LAST_MATCH;
1825                         }
1826                 }
1827
1828         /* Try to read more data. */
1829
1830         /* First move last chars to start of buffer. */
1831         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1832
1833         for ( i = 0; i < number_to_move; ++i )
1834                 *(dest++) = *(source++);
1835
1836         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1837                 /* don't do the read, it's not guaranteed to return an EOF,
1838                  * just force an EOF
1839                  */
1840                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1841
1842         else
1843                 {
1844                         int num_to_read =
1845                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1846
1847                 while ( num_to_read <= 0 )
1848                         { /* Not enough room in the buffer - grow it. */
1849
1850                         /* just a shorter name for the current buffer */
1851                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1852
1853                         int yy_c_buf_p_offset =
1854                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1855
1856                         if ( b->yy_is_our_buffer )
1857                                 {
1858                                 int new_size = b->yy_buf_size * 2;
1859
1860                                 if ( new_size <= 0 )
1861                                         b->yy_buf_size += b->yy_buf_size / 8;
1862                                 else
1863                                         b->yy_buf_size *= 2;
1864
1865                                 b->yy_ch_buf = (char *)
1866                                         /* Include room in for 2 EOB chars. */
1867                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1868                                 }
1869                         else
1870                                 /* Can't grow it, we don't own it. */
1871                                 b->yy_ch_buf = 0;
1872
1873                         if ( ! b->yy_ch_buf )
1874                                 YY_FATAL_ERROR(
1875                                 "fatal error - scanner input buffer overflow" );
1876
1877                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1878
1879                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1880                                                 number_to_move - 1;
1881
1882                         }
1883
1884                 if ( num_to_read > YY_READ_BUF_SIZE )
1885                         num_to_read = YY_READ_BUF_SIZE;
1886
1887                 /* Read in more data. */
1888                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1889                         (yy_n_chars), (size_t) num_to_read );
1890
1891                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1892                 }
1893
1894         if ( (yy_n_chars) == 0 )
1895                 {
1896                 if ( number_to_move == YY_MORE_ADJ )
1897                         {
1898                         ret_val = EOB_ACT_END_OF_FILE;
1899                         yyrestart(yyin  );
1900                         }
1901
1902                 else
1903                         {
1904                         ret_val = EOB_ACT_LAST_MATCH;
1905                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1906                                 YY_BUFFER_EOF_PENDING;
1907                         }
1908                 }
1909
1910         else
1911                 ret_val = EOB_ACT_CONTINUE_SCAN;
1912
1913         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1914                 /* Extend the array by 50%, plus the number we really need. */
1915                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1916                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1917                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1918                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1919         }
1920
1921         (yy_n_chars) += number_to_move;
1922         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1923         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1924
1925         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1926
1927         return ret_val;
1928 }
1929
1930 /* yy_get_previous_state - get the state just before the EOB char was reached */
1931
1932     static yy_state_type yy_get_previous_state (void)
1933 {
1934         register yy_state_type yy_current_state;
1935         register char *yy_cp;
1936
1937         yy_current_state = (yy_start);
1938         yy_current_state += YY_AT_BOL();
1939
1940         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1941                 {
1942                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1943                 if ( yy_accept[yy_current_state] )
1944                         {
1945                         (yy_last_accepting_state) = yy_current_state;
1946                         (yy_last_accepting_cpos) = yy_cp;
1947                         }
1948                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1949                         {
1950                         yy_current_state = (int) yy_def[yy_current_state];
1951                         if ( yy_current_state >= 458 )
1952                                 yy_c = yy_meta[(unsigned int) yy_c];
1953                         }
1954                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1955                 }
1956
1957         return yy_current_state;
1958 }
1959
1960 /* yy_try_NUL_trans - try to make a transition on the NUL character
1961  *
1962  * synopsis
1963  *      next_state = yy_try_NUL_trans( current_state );
1964  */
1965     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1966 {
1967         register int yy_is_jam;
1968         register char *yy_cp = (yy_c_buf_p);
1969
1970         register YY_CHAR yy_c = 1;
1971         if ( yy_accept[yy_current_state] )
1972                 {
1973                 (yy_last_accepting_state) = yy_current_state;
1974                 (yy_last_accepting_cpos) = yy_cp;
1975                 }
1976         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1977                 {
1978                 yy_current_state = (int) yy_def[yy_current_state];
1979                 if ( yy_current_state >= 458 )
1980                         yy_c = yy_meta[(unsigned int) yy_c];
1981                 }
1982         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1983         yy_is_jam = (yy_current_state == 457);
1984
1985         return yy_is_jam ? 0 : yy_current_state;
1986 }
1987
1988 #ifndef YY_NO_INPUT
1989 #ifdef __cplusplus
1990     static int yyinput (void)
1991 #else
1992     static int input  (void)
1993 #endif
1994
1995 {
1996         int c;
1997
1998         *(yy_c_buf_p) = (yy_hold_char);
1999
2000         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2001                 {
2002                 /* yy_c_buf_p now points to the character we want to return.
2003                  * If this occurs *before* the EOB characters, then it's a
2004                  * valid NUL; if not, then we've hit the end of the buffer.
2005                  */
2006                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2007                         /* This was really a NUL. */
2008                         *(yy_c_buf_p) = '\0';
2009
2010                 else
2011                         { /* need more input */
2012                         int offset = (yy_c_buf_p) - (yytext_ptr);
2013                         ++(yy_c_buf_p);
2014
2015                         switch ( yy_get_next_buffer(  ) )
2016                                 {
2017                                 case EOB_ACT_LAST_MATCH:
2018                                         /* This happens because yy_g_n_b()
2019                                          * sees that we've accumulated a
2020                                          * token and flags that we need to
2021                                          * try matching the token before
2022                                          * proceeding.  But for input(),
2023                                          * there's no matching to consider.
2024                                          * So convert the EOB_ACT_LAST_MATCH
2025                                          * to EOB_ACT_END_OF_FILE.
2026                                          */
2027
2028                                         /* Reset buffer status. */
2029                                         yyrestart(yyin );
2030
2031                                         /*FALLTHROUGH*/
2032
2033                                 case EOB_ACT_END_OF_FILE:
2034                                         {
2035                                         if ( yywrap( ) )
2036                                                 return EOF;
2037
2038                                         if ( ! (yy_did_buffer_switch_on_eof) )
2039                                                 YY_NEW_FILE;
2040 #ifdef __cplusplus
2041                                         return yyinput();
2042 #else
2043                                         return input();
2044 #endif
2045                                         }
2046
2047                                 case EOB_ACT_CONTINUE_SCAN:
2048                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2049                                         break;
2050                                 }
2051                         }
2052                 }
2053
2054         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2055         *(yy_c_buf_p) = '\0';   /* preserve yytext */
2056         (yy_hold_char) = *++(yy_c_buf_p);
2057
2058         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2059
2060         return c;
2061 }
2062 #endif  /* ifndef YY_NO_INPUT */
2063
2064 /** Immediately switch to a different input stream.
2065  * @param input_file A readable stream.
2066  *
2067  * @note This function does not reset the start condition to @c INITIAL .
2068  */
2069     void yyrestart  (FILE * input_file )
2070 {
2071
2072         if ( ! YY_CURRENT_BUFFER ){
2073         yyensure_buffer_stack ();
2074                 YY_CURRENT_BUFFER_LVALUE =
2075             yy_create_buffer(yyin,YY_BUF_SIZE );
2076         }
2077
2078         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2079         yy_load_buffer_state( );
2080 }
2081
2082 /** Switch to a different input buffer.
2083  * @param new_buffer The new input buffer.
2084  *
2085  */
2086     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2087 {
2088
2089         /* TODO. We should be able to replace this entire function body
2090          * with
2091          *              yypop_buffer_state();
2092          *              yypush_buffer_state(new_buffer);
2093      */
2094         yyensure_buffer_stack ();
2095         if ( YY_CURRENT_BUFFER == new_buffer )
2096                 return;
2097
2098         if ( YY_CURRENT_BUFFER )
2099                 {
2100                 /* Flush out information for old buffer. */
2101                 *(yy_c_buf_p) = (yy_hold_char);
2102                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2103                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2104                 }
2105
2106         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2107         yy_load_buffer_state( );
2108
2109         /* We don't actually know whether we did this switch during
2110          * EOF (yywrap()) processing, but the only time this flag
2111          * is looked at is after yywrap() is called, so it's safe
2112          * to go ahead and always set it.
2113          */
2114         (yy_did_buffer_switch_on_eof) = 1;
2115 }
2116
2117 static void yy_load_buffer_state  (void)
2118 {
2119         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2120         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2121         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2122         (yy_hold_char) = *(yy_c_buf_p);
2123 }
2124
2125 /** Allocate and initialize an input buffer state.
2126  * @param file A readable stream.
2127  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2128  *
2129  * @return the allocated buffer state.
2130  */
2131     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2132 {
2133         YY_BUFFER_STATE b;
2134
2135         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2136         if ( ! b )
2137                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2138
2139         b->yy_buf_size = size;
2140
2141         /* yy_ch_buf has to be 2 characters longer than the size given because
2142          * we need to put in 2 end-of-buffer characters.
2143          */
2144         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2145         if ( ! b->yy_ch_buf )
2146                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2147
2148         b->yy_is_our_buffer = 1;
2149
2150         yy_init_buffer(b,file );
2151
2152         return b;
2153 }
2154
2155 /** Destroy the buffer.
2156  * @param b a buffer created with yy_create_buffer()
2157  *
2158  */
2159     void yy_delete_buffer (YY_BUFFER_STATE  b )
2160 {
2161
2162         if ( ! b )
2163                 return;
2164
2165         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2166                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2167
2168         if ( b->yy_is_our_buffer )
2169                 yyfree((void *) b->yy_ch_buf  );
2170
2171         yyfree((void *) b  );
2172 }
2173
2174 /* Initializes or reinitializes a buffer.
2175  * This function is sometimes called more than once on the same buffer,
2176  * such as during a yyrestart() or at EOF.
2177  */
2178     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2179
2180 {
2181         int oerrno = errno;
2182
2183         yy_flush_buffer(b );
2184
2185         b->yy_input_file = file;
2186         b->yy_fill_buffer = 1;
2187
2188     /* If b is the current buffer, then yy_init_buffer was _probably_
2189      * called from yyrestart() or through yy_get_next_buffer.
2190      * In that case, we don't want to reset the lineno or column.
2191      */
2192     if (b != YY_CURRENT_BUFFER){
2193         b->yy_bs_lineno = 1;
2194         b->yy_bs_column = 0;
2195     }
2196
2197         b->yy_is_interactive = 0;
2198
2199         errno = oerrno;
2200 }
2201
2202 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2203  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2204  *
2205  */
2206     void yy_flush_buffer (YY_BUFFER_STATE  b )
2207 {
2208         if ( ! b )
2209                 return;
2210
2211         b->yy_n_chars = 0;
2212
2213         /* We always need two end-of-buffer characters.  The first causes
2214          * a transition to the end-of-buffer state.  The second causes
2215          * a jam in that state.
2216          */
2217         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2218         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2219
2220         b->yy_buf_pos = &b->yy_ch_buf[0];
2221
2222         b->yy_at_bol = 1;
2223         b->yy_buffer_status = YY_BUFFER_NEW;
2224
2225         if ( b == YY_CURRENT_BUFFER )
2226                 yy_load_buffer_state( );
2227 }
2228
2229 /** Pushes the new state onto the stack. The new state becomes
2230  *  the current state. This function will allocate the stack
2231  *  if necessary.
2232  *  @param new_buffer The new state.
2233  *
2234  */
2235 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2236 {
2237         if (new_buffer == NULL)
2238                 return;
2239
2240         yyensure_buffer_stack();
2241
2242         /* This block is copied from yy_switch_to_buffer. */
2243         if ( YY_CURRENT_BUFFER )
2244                 {
2245                 /* Flush out information for old buffer. */
2246                 *(yy_c_buf_p) = (yy_hold_char);
2247                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2248                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2249                 }
2250
2251         /* Only push if top exists. Otherwise, replace top. */
2252         if (YY_CURRENT_BUFFER)
2253                 (yy_buffer_stack_top)++;
2254         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2255
2256         /* copied from yy_switch_to_buffer. */
2257         yy_load_buffer_state( );
2258         (yy_did_buffer_switch_on_eof) = 1;
2259 }
2260
2261 /** Removes and deletes the top of the stack, if present.
2262  *  The next element becomes the new top.
2263  *
2264  */
2265 void yypop_buffer_state (void)
2266 {
2267         if (!YY_CURRENT_BUFFER)
2268                 return;
2269
2270         yy_delete_buffer(YY_CURRENT_BUFFER );
2271         YY_CURRENT_BUFFER_LVALUE = NULL;
2272         if ((yy_buffer_stack_top) > 0)
2273                 --(yy_buffer_stack_top);
2274
2275         if (YY_CURRENT_BUFFER) {
2276                 yy_load_buffer_state( );
2277                 (yy_did_buffer_switch_on_eof) = 1;
2278         }
2279 }
2280
2281 /* Allocates the stack if it does not exist.
2282  *  Guarantees space for at least one push.
2283  */
2284 static void yyensure_buffer_stack (void)
2285 {
2286         int num_to_alloc;
2287
2288         if (!(yy_buffer_stack)) {
2289
2290                 /* First allocation is just for 2 elements, since we don't know if this
2291                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2292                  * immediate realloc on the next call.
2293          */
2294                 num_to_alloc = 1;
2295                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2296                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2297                                                                 );
2298                 if ( ! (yy_buffer_stack) )
2299                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2300
2301                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2302
2303                 (yy_buffer_stack_max) = num_to_alloc;
2304                 (yy_buffer_stack_top) = 0;
2305                 return;
2306         }
2307
2308         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2309
2310                 /* Increase the buffer to prepare for a possible push. */
2311                 int grow_size = 8 /* arbitrary grow size */;
2312
2313                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2314                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2315                                                                 ((yy_buffer_stack),
2316                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2317                                                                 );
2318                 if ( ! (yy_buffer_stack) )
2319                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2320
2321                 /* zero only the new slots.*/
2322                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2323                 (yy_buffer_stack_max) = num_to_alloc;
2324         }
2325 }
2326
2327 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2328  * @param base the character buffer
2329  * @param size the size in bytes of the character buffer
2330  *
2331  * @return the newly allocated buffer state object.
2332  */
2333 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2334 {
2335         YY_BUFFER_STATE b;
2336
2337         if ( size < 2 ||
2338              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2339              base[size-1] != YY_END_OF_BUFFER_CHAR )
2340                 /* They forgot to leave room for the EOB's. */
2341                 return 0;
2342
2343         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2344         if ( ! b )
2345                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2346
2347         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2348         b->yy_buf_pos = b->yy_ch_buf = base;
2349         b->yy_is_our_buffer = 0;
2350         b->yy_input_file = 0;
2351         b->yy_n_chars = b->yy_buf_size;
2352         b->yy_is_interactive = 0;
2353         b->yy_at_bol = 1;
2354         b->yy_fill_buffer = 0;
2355         b->yy_buffer_status = YY_BUFFER_NEW;
2356
2357         yy_switch_to_buffer(b  );
2358
2359         return b;
2360 }
2361
2362 /** Setup the input buffer state to scan a string. The next call to yylex() will
2363  * scan from a @e copy of @a str.
2364  * @param yystr a NUL-terminated string to scan
2365  *
2366  * @return the newly allocated buffer state object.
2367  * @note If you want to scan bytes that may contain NUL values, then use
2368  *       yy_scan_bytes() instead.
2369  */
2370 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2371 {
2372
2373         return yy_scan_bytes(yystr,strlen(yystr) );
2374 }
2375
2376 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2377  * scan from a @e copy of @a bytes.
2378  * @param bytes the byte buffer to scan
2379  * @param len the number of bytes in the buffer pointed to by @a bytes.
2380  *
2381  * @return the newly allocated buffer state object.
2382  */
2383 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2384 {
2385         YY_BUFFER_STATE b;
2386         char *buf;
2387         yy_size_t n;
2388         int i;
2389
2390         /* Get memory for full buffer, including space for trailing EOB's. */
2391         n = _yybytes_len + 2;
2392         buf = (char *) yyalloc(n  );
2393         if ( ! buf )
2394                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2395
2396         for ( i = 0; i < _yybytes_len; ++i )
2397                 buf[i] = yybytes[i];
2398
2399         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2400
2401         b = yy_scan_buffer(buf,n );
2402         if ( ! b )
2403                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2404
2405         /* It's okay to grow etc. this buffer, and we should throw it
2406          * away when we're done.
2407          */
2408         b->yy_is_our_buffer = 1;
2409
2410         return b;
2411 }
2412
2413 #ifndef YY_EXIT_FAILURE
2414 #define YY_EXIT_FAILURE 2
2415 #endif
2416
2417 static void yy_fatal_error (yyconst char* msg )
2418 {
2419         (void) fprintf( stderr, "%s\n", msg );
2420         exit( YY_EXIT_FAILURE );
2421 }
2422
2423 /* Redefine yyless() so it works in section 3 code. */
2424
2425 #undef yyless
2426 #define yyless(n) \
2427         do \
2428                 { \
2429                 /* Undo effects of setting up yytext. */ \
2430         int yyless_macro_arg = (n); \
2431         YY_LESS_LINENO(yyless_macro_arg);\
2432                 yytext[yyleng] = (yy_hold_char); \
2433                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
2434                 (yy_hold_char) = *(yy_c_buf_p); \
2435                 *(yy_c_buf_p) = '\0'; \
2436                 yyleng = yyless_macro_arg; \
2437                 } \
2438         while ( 0 )
2439
2440 /* Accessor  methods (get/set functions) to struct members. */
2441
2442 /** Get the current line number.
2443  *
2444  */
2445 int yyget_lineno  (void)
2446 {
2447
2448     return yylineno;
2449 }
2450
2451 /** Get the input stream.
2452  *
2453  */
2454 FILE *yyget_in  (void)
2455 {
2456         return yyin;
2457 }
2458
2459 /** Get the output stream.
2460  *
2461  */
2462 FILE *yyget_out  (void)
2463 {
2464         return yyout;
2465 }
2466
2467 /** Get the length of the current token.
2468  *
2469  */
2470 int yyget_leng  (void)
2471 {
2472         return yyleng;
2473 }
2474
2475 /** Get the current token.
2476  *
2477  */
2478
2479 char *yyget_text  (void)
2480 {
2481         return yytext;
2482 }
2483
2484 /** Set the current line number.
2485  * @param line_number
2486  *
2487  */
2488 void yyset_lineno (int  line_number )
2489 {
2490
2491     yylineno = line_number;
2492 }
2493
2494 /** Set the input stream. This does not discard the current
2495  * input buffer.
2496  * @param in_str A readable stream.
2497  *
2498  * @see yy_switch_to_buffer
2499  */
2500 void yyset_in (FILE *  in_str )
2501 {
2502         yyin = in_str ;
2503 }
2504
2505 void yyset_out (FILE *  out_str )
2506 {
2507         yyout = out_str ;
2508 }
2509
2510 int yyget_debug  (void)
2511 {
2512         return yy_flex_debug;
2513 }
2514
2515 void yyset_debug (int  bdebug )
2516 {
2517         yy_flex_debug = bdebug ;
2518 }
2519
2520 static int yy_init_globals (void)
2521 {
2522         /* Initialization is the same as for the non-reentrant scanner.
2523      * This function is called from yylex_destroy(), so don't allocate here.
2524      */
2525
2526     (yy_buffer_stack) = 0;
2527     (yy_buffer_stack_top) = 0;
2528     (yy_buffer_stack_max) = 0;
2529     (yy_c_buf_p) = (char *) 0;
2530     (yy_init) = 0;
2531     (yy_start) = 0;
2532
2533 /* Defined in main.c */
2534 #ifdef YY_STDINIT
2535     yyin = stdin;
2536     yyout = stdout;
2537 #else
2538     yyin = (FILE *) 0;
2539     yyout = (FILE *) 0;
2540 #endif
2541
2542     /* For future reference: Set errno on error, since we are called by
2543      * yylex_init()
2544      */
2545     return 0;
2546 }
2547
2548 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2549 int yylex_destroy  (void)
2550 {
2551
2552     /* Pop the buffer stack, destroying each element. */
2553         while(YY_CURRENT_BUFFER){
2554                 yy_delete_buffer(YY_CURRENT_BUFFER  );
2555                 YY_CURRENT_BUFFER_LVALUE = NULL;
2556                 yypop_buffer_state();
2557         }
2558
2559         /* Destroy the stack itself. */
2560         yyfree((yy_buffer_stack) );
2561         (yy_buffer_stack) = NULL;
2562
2563     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2564      * yylex() is called, initialization will occur. */
2565     yy_init_globals( );
2566
2567     return 0;
2568 }
2569
2570 /*
2571  * Internal utility routines.
2572  */
2573
2574 #ifndef yytext_ptr
2575 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2576 {
2577         register int i;
2578         for ( i = 0; i < n; ++i )
2579                 s1[i] = s2[i];
2580 }
2581 #endif
2582
2583 #ifdef YY_NEED_STRLEN
2584 static int yy_flex_strlen (yyconst char * s )
2585 {
2586         register int n;
2587         for ( n = 0; s[n]; ++n )
2588                 ;
2589
2590         return n;
2591 }
2592 #endif
2593
2594 void *yyalloc (yy_size_t  size )
2595 {
2596         return (void *) malloc( size );
2597 }
2598
2599 void *yyrealloc  (void * ptr, yy_size_t  size )
2600 {
2601         /* The cast to (char *) in the following accommodates both
2602          * implementations that use char* generic pointers, and those
2603          * that use void* generic pointers.  It works with the latter
2604          * because both ANSI C and C++ allow castless assignment from
2605          * any pointer type to void*, and deal with argument conversions
2606          * as though doing an assignment.
2607          */
2608         return (void *) realloc( (char *) ptr, size );
2609 }
2610
2611 void yyfree (void * ptr )
2612 {
2613         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
2614 }
2615
2616 #define YYTABLES_NAME "yytables"
2617
2618 #line 198 "/space/rguenther/gcc-4.7.3/gcc-4.7.3/gcc/gengtype-lex.l"
2619
2620
2621
2622 void
2623 yybegin (const char *fname)
2624 {
2625   yyin = fopen (fname, "r");
2626   if (yyin == NULL)
2627     {
2628       perror (fname);
2629       exit (1);
2630     }
2631   lexer_line.file = input_file_by_name (fname);
2632   lexer_line.line = 1;
2633 }
2634
2635 void
2636 yyend (void)
2637 {
2638   fclose (yyin);
2639 }
2640