git.oblomov.eu Git - linux-2.6/blob - scripts/genksyms/lex.c_shipped

   1 #line 2 "scripts/genksyms/lex.c"
   2 /* A lexical scanner generated by flex */
   3
   4 /* Scanner skeleton version:
   5  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
   6  */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION 2
  10 #define YY_FLEX_MINOR_VERSION 5
  11
  12 #include <stdio.h>
  13 #include <unistd.h>
  14
  15
  16 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  17 #ifdef c_plusplus
  18 #ifndef __cplusplus
  19 #define __cplusplus
  20 #endif
  21 #endif
  22
  23
  24 #ifdef __cplusplus
  25
  26 #include <stdlib.h>
  27
  28 /* Use prototypes in function declarations. */
  29 #define YY_USE_PROTOS
  30
  31 /* The "const" storage-class-modifier is valid. */
  32 #define YY_USE_CONST
  33
  34 #else   /* ! __cplusplus */
  35
  36 #if __STDC__
  37
  38 #define YY_USE_PROTOS
  39 #define YY_USE_CONST
  40
  41 #endif  /* __STDC__ */
  42 #endif  /* ! __cplusplus */
  43
  44 #ifdef __TURBOC__
  45  #pragma warn -rch
  46  #pragma warn -use
  47 #include <io.h>
  48 #include <stdlib.h>
  49 #define YY_USE_CONST
  50 #define YY_USE_PROTOS
  51 #endif
  52
  53 #ifdef YY_USE_CONST
  54 #define yyconst const
  55 #else
  56 #define yyconst
  57 #endif
  58
  59
  60 #ifdef YY_USE_PROTOS
  61 #define YY_PROTO(proto) proto
  62 #else
  63 #define YY_PROTO(proto) ()
  64 #endif
  65
  66 /* Returned upon end-of-file. */
  67 #define YY_NULL 0
  68
  69 /* Promotes a possibly negative, possibly signed char to an unsigned
  70  * integer for use as an array index.  If the signed char is negative,
  71  * we want to instead treat it as an 8-bit unsigned char, hence the
  72  * double cast.
  73  */
  74 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  75
  76 /* Enter a start condition.  This macro really ought to take a parameter,
  77  * but we do it the disgusting crufty way forced on us by the ()-less
  78  * definition of BEGIN.
  79  */
  80 #define BEGIN yy_start = 1 + 2 *
  81
  82 /* Translate the current start state into a value that can be later handed
  83  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  84  * compatibility.
  85  */
  86 #define YY_START ((yy_start - 1) / 2)
  87 #define YYSTATE YY_START
  88
  89 /* Action number for EOF rule of a given start state. */
  90 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  91
  92 /* Special action meaning "start processing a new file". */
  93 #define YY_NEW_FILE yyrestart( yyin )
  94
  95 #define YY_END_OF_BUFFER_CHAR 0
  96
  97 /* Size of default input buffer. */
  98 #define YY_BUF_SIZE 16384
  99
 100 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 101
 102 extern int yyleng;
 103 extern FILE *yyin, *yyout;
 104
 105 #define EOB_ACT_CONTINUE_SCAN 0
 106 #define EOB_ACT_END_OF_FILE 1
 107 #define EOB_ACT_LAST_MATCH 2
 108
 109 /* The funky do-while in the following #define is used to turn the definition
 110  * int a single C statement (which needs a semi-colon terminator).  This
 111  * avoids problems with code like:
 112  *
 113  *      if ( condition_holds )
 114  *              yyless( 5 );
 115  *      else
 116  *              do_something_else();
 117  *
 118  * Prior to using the do-while the compiler would get upset at the
 119  * "else" because it interpreted the "if" statement as being all
 120  * done when it reached the ';' after the yyless() call.
 121  */
 122
 123 /* Return all but the first 'n' matched characters back to the input stream. */
 124
 125 #define yyless(n) \
 126         do \
 127                 { \
 128                 /* Undo effects of setting up yytext. */ \
 129                 *yy_cp = yy_hold_char; \
 130                 YY_RESTORE_YY_MORE_OFFSET \
 131                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 132                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 133                 } \
 134         while ( 0 )
 135
 136 #define unput(c) yyunput( c, yytext_ptr )
 137
 138 /* The following is because we cannot portably get our hands on size_t
 139  * (without autoconf's help, which isn't available because we want
 140  * flex-generated scanners to compile on their own).
 141  */
 142 typedef unsigned int yy_size_t;
 143
 144
 145 struct yy_buffer_state
 146         {
 147         FILE *yy_input_file;
 148
 149         char *yy_ch_buf;                /* input buffer */
 150         char *yy_buf_pos;               /* current position in input buffer */
 151
 152         /* Size of input buffer in bytes, not including room for EOB
 153          * characters.
 154          */
 155         yy_size_t yy_buf_size;
 156
 157         /* Number of characters read into yy_ch_buf, not including EOB
 158          * characters.
 159          */
 160         int yy_n_chars;
 161
 162         /* Whether we "own" the buffer - i.e., we know we created it,
 163          * and can realloc() it to grow it, and should free() it to
 164          * delete it.
 165          */
 166         int yy_is_our_buffer;
 167
 168         /* Whether this is an "interactive" input source; if so, and
 169          * if we're using stdio for input, then we want to use getc()
 170          * instead of fread(), to make sure we stop fetching input after
 171          * each newline.
 172          */
 173         int yy_is_interactive;
 174
 175         /* Whether we're considered to be at the beginning of a line.
 176          * If so, '^' rules will be active on the next match, otherwise
 177          * not.
 178          */
 179         int yy_at_bol;
 180
 181         /* Whether to try to fill the input buffer when we reach the
 182          * end of it.
 183          */
 184         int yy_fill_buffer;
 185
 186         int yy_buffer_status;
 187 #define YY_BUFFER_NEW 0
 188 #define YY_BUFFER_NORMAL 1
 189         /* When an EOF's been seen but there's still some text to process
 190          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 191          * shouldn't try reading from the input source any more.  We might
 192          * still have a bunch of tokens to match, though, because of
 193          * possible backing-up.
 194          *
 195          * When we actually see the EOF, we change the status to "new"
 196          * (via yyrestart()), so that the user can continue scanning by
 197          * just pointing yyin at a new input file.
 198          */
 199 #define YY_BUFFER_EOF_PENDING 2
 200         };
 201
 202 static YY_BUFFER_STATE yy_current_buffer = 0;
 203
 204 /* We provide macros for accessing buffer states in case in the
 205  * future we want to put the buffer states in a more general
 206  * "scanner state".
 207  */
 208 #define YY_CURRENT_BUFFER yy_current_buffer
 209
 210
 211 /* yy_hold_char holds the character lost when yytext is formed. */
 212 static char yy_hold_char;
 213
 214 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 215
 216
 217 int yyleng;
 218
 219 /* Points to current character in buffer. */
 220 static char *yy_c_buf_p = (char *) 0;
 221 static int yy_init = 1;         /* whether we need to initialize */
 222 static int yy_start = 0;        /* start state number */
 223
 224 /* Flag which is used to allow yywrap()'s to do buffer switches
 225  * instead of setting up a fresh yyin.  A bit of a hack ...
 226  */
 227 static int yy_did_buffer_switch_on_eof;
 228
 229 void yyrestart YY_PROTO(( FILE *input_file ));
 230
 231 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 232 void yy_load_buffer_state YY_PROTO(( void ));
 233 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 234 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 235 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 236 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 237 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 238
 239 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 240 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 241 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 242
 243 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 244 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 245 static void yy_flex_free YY_PROTO(( void * ));
 246
 247 #define yy_new_buffer yy_create_buffer
 248
 249 #define yy_set_interactive(is_interactive) \
 250         { \
 251         if ( ! yy_current_buffer ) \
 252                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 253         yy_current_buffer->yy_is_interactive = is_interactive; \
 254         }
 255
 256 #define yy_set_bol(at_bol) \
 257         { \
 258         if ( ! yy_current_buffer ) \
 259                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 260         yy_current_buffer->yy_at_bol = at_bol; \
 261         }
 262
 263 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 264
 265
 266 #define yywrap() 1
 267 #define YY_SKIP_YYWRAP
 268
 269 #define FLEX_DEBUG
 270 typedef unsigned char YY_CHAR;
 271 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 272 typedef int yy_state_type;
 273
 274 #define FLEX_DEBUG
 275 extern char *yytext;
 276 #define yytext_ptr yytext
 277
 278 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 279 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 280 static int yy_get_next_buffer YY_PROTO(( void ));
 281 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 282
 283 /* Done after the current pattern has been matched and before the
 284  * corresponding action - sets up yytext.
 285  */
 286 #define YY_DO_BEFORE_ACTION \
 287         yytext_ptr = yy_bp; \
 288         yyleng = (int) (yy_cp - yy_bp); \
 289         yy_hold_char = *yy_cp; \
 290         *yy_cp = '\0'; \
 291         yy_c_buf_p = yy_cp;
 292
 293 #define YY_NUM_RULES 13
 294 #define YY_END_OF_BUFFER 14
 295 static yyconst short int yy_accept[76] =
 296     {   0,
 297         0,    0,    0,    0,   14,   12,    4,    3,   12,    7,
 298        12,   12,    7,   12,   12,   12,   12,   12,    9,    9,
 299        12,   12,   12,    4,    0,    5,    0,    7,    0,    6,
 300         0,    0,    0,    0,    0,    0,    2,    8,   10,   10,
 301         9,    0,    0,    9,    9,    0,    9,    0,    0,   11,
 302         0,    0,    0,   10,    0,   10,    9,    9,    0,    0,
 303         0,    0,    0,    0,    0,   10,   10,    0,    0,    0,
 304         0,    0,    0,    1,    0
 305     } ;
 306
 307 static yyconst int yy_ec[256] =
 308     {   0,
 309         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 310         4,    4,    4,    1,    1,    1,    1,    1,    1,    1,
 311         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 312         1,    2,    1,    5,    6,    7,    8,    9,   10,    1,
 313         1,    8,   11,    1,   12,   13,    8,   14,   15,   15,
 314        15,   15,   15,   15,   15,   16,   16,    1,    1,   17,
 315        18,   19,    1,    1,   20,   20,   20,   20,   21,   22,
 316         7,    7,    7,    7,    7,   23,    7,    7,    7,    7,
 317         7,    7,    7,    7,   24,    7,    7,   25,    7,    7,
 318         1,   26,    1,    8,    7,    1,   20,   20,   20,   20,
 319
 320        21,   22,    7,    7,    7,    7,    7,   27,    7,    7,
 321         7,    7,    7,    7,    7,    7,   24,    7,    7,   25,
 322         7,    7,    1,   28,    1,    8,    1,    1,    1,    1,
 323         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 325         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 330
 331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 336         1,    1,    1,    1,    1
 337     } ;
 338
 339 static yyconst int yy_meta[29] =
 340     {   0,
 341         1,    1,    2,    1,    1,    1,    3,    1,    1,    1,
 342         4,    4,    5,    6,    6,    6,    1,    1,    1,    7,
 343         8,    7,    3,    3,    3,    1,    3,    1
 344     } ;
 345
 346 static yyconst short int yy_base[88] =
 347     {   0,
 348         0,  147,   21,  140,  145,  284,   39,  284,   26,    0,
 349        32,  126,   40,   44,  115,   35,   36,   46,   50,   53,
 350        39,   61,   54,   79,   65,  284,    0,    0,   66,  284,
 351         0,  119,   79,   75,  123,  104,  284,  284,  107,    0,
 352        79,   73,   76,   76,   66,    0,    0,   85,   86,  284,
 353       133,   83,   91,  284,   99,  147,  284,  114,  122,   70,
 354       107,  141,  172,  151,  135,  181,  284,  137,  114,  157,
 355       149,   48,   45,  284,  284,  208,  214,  222,  230,  238,
 356       246,  250,  255,  256,  261,  267,  275
 357     } ;
 358
 359 static yyconst short int yy_def[88] =
 360     {   0,
 361        75,    1,    1,    3,   75,   75,   75,   75,   76,   77,
 362        78,   75,   77,   79,   75,   75,   75,   75,   75,   19,
 363        75,   75,   75,   75,   76,   75,   80,   77,   78,   75,
 364        81,   75,   76,   78,   79,   79,   75,   75,   75,   39,
 365        19,   82,   83,   75,   75,   84,   20,   76,   78,   75,
 366        79,   51,   85,   75,   75,   75,   75,   84,   79,   51,
 367        79,   79,   79,   51,   75,   75,   75,   86,   79,   63,
 368        86,   87,   87,   75,    0,   75,   75,   75,   75,   75,
 369        75,   75,   75,   75,   75,   75,   75
 370     } ;
 371
 372 static yyconst short int yy_nxt[313] =
 373     {   0,
 374         6,    7,    8,    7,    9,    6,   10,    6,    6,   11,
 375         6,    6,   12,    6,    6,    6,    6,    6,    6,   10,
 376        10,   10,   13,   10,   10,    6,   10,    6,   15,   16,
 377        26,   15,   17,   18,   19,   20,   20,   21,   15,   22,
 378        24,   30,   24,   38,   33,   36,   37,   74,   23,   34,
 379        74,   27,   38,   38,   38,   38,   38,   31,   32,   39,
 380        39,   39,   40,   41,   41,   42,   47,   47,   47,   26,
 381        43,   38,   44,   45,   46,   30,   44,   75,   38,   38,
 382        24,   38,   24,   26,   30,   40,   55,   55,   57,   26,
 383        27,   31,   57,   43,   35,   30,   64,   64,   64,   57,
 384
 385        31,   65,   65,   75,   27,   36,   37,   35,   59,   37,
 386        27,   31,   56,   56,   56,   59,   37,   51,   52,   52,
 387        39,   39,   39,   59,   37,   37,   68,   53,   54,   54,
 388        69,   50,   38,   54,   59,   37,   44,   45,   32,   37,
 389        44,   35,   59,   37,   75,   14,   60,   60,   66,   66,
 390        66,   37,   14,   72,   75,   61,   62,   63,   59,   61,
 391        56,   56,   56,   69,   64,   64,   64,   69,   67,   67,
 392        75,   75,   75,   67,   37,   35,   75,   75,   75,   61,
 393        62,   75,   75,   61,   75,   70,   70,   70,   75,   75,
 394        75,   70,   70,   70,   66,   66,   66,   75,   75,   75,
 395
 396        75,   75,   54,   54,   75,   75,   75,   54,   25,   25,
 397        25,   25,   25,   25,   25,   25,   28,   75,   75,   28,
 398        28,   28,   29,   29,   29,   29,   29,   29,   29,   29,
 399        35,   35,   35,   35,   35,   35,   35,   35,   48,   75,
 400        48,   48,   48,   48,   48,   48,   49,   75,   49,   49,
 401        49,   49,   49,   49,   42,   42,   75,   42,   56,   75,
 402        56,   58,   58,   58,   66,   75,   66,   71,   71,   71,
 403        71,   71,   71,   71,   71,   73,   73,   73,   73,   73,
 404        73,   73,   73,    5,   75,   75,   75,   75,   75,   75,
 405        75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
 406
 407        75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
 408        75,   75
 409     } ;
 410
 411 static yyconst short int yy_chk[313] =
 412     {   0,
 413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 415         1,    1,    1,    1,    1,    1,    1,    1,    3,    3,
 416         9,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 417         7,   11,    7,   16,   13,   14,   14,   73,    3,   13,
 418        72,    9,   16,   17,   17,   21,   21,   11,   18,   18,
 419        18,   18,   19,   19,   19,   19,   20,   20,   20,   25,
 420        19,   23,   19,   19,   19,   29,   19,   20,   22,   22,
 421        24,   23,   24,   33,   34,   42,   43,   43,   45,   48,
 422        25,   29,   45,   42,   60,   49,   52,   52,   52,   44,
 423
 424        34,   53,   53,   41,   33,   36,   36,   52,   61,   61,
 425        48,   49,   55,   55,   55,   69,   69,   36,   36,   36,
 426        39,   39,   39,   59,   59,   35,   59,   39,   39,   39,
 427        61,   32,   15,   39,   51,   51,   58,   58,   12,   68,
 428        58,   68,   62,   62,    5,    4,   51,   51,   65,   65,
 429        65,   71,    2,   71,    0,   51,   51,   51,   70,   51,
 430        56,   56,   56,   62,   64,   64,   64,   62,   56,   56,
 431         0,    0,    0,   56,   63,   64,    0,    0,    0,   70,
 432        70,    0,    0,   70,    0,   63,   63,   63,    0,    0,
 433         0,   63,   63,   63,   66,   66,   66,    0,    0,    0,
 434
 435         0,    0,   66,   66,    0,    0,    0,   66,   76,   76,
 436        76,   76,   76,   76,   76,   76,   77,    0,    0,   77,
 437        77,   77,   78,   78,   78,   78,   78,   78,   78,   78,
 438        79,   79,   79,   79,   79,   79,   79,   79,   80,    0,
 439        80,   80,   80,   80,   80,   80,   81,    0,   81,   81,
 440        81,   81,   81,   81,   82,   82,    0,   82,   83,    0,
 441        83,   84,   84,   84,   85,    0,   85,   86,   86,   86,
 442        86,   86,   86,   86,   86,   87,   87,   87,   87,   87,
 443        87,   87,   87,   75,   75,   75,   75,   75,   75,   75,
 444        75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
 445
 446        75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
 447        75,   75
 448     } ;
 449
 450 static yy_state_type yy_last_accepting_state;
 451 static char *yy_last_accepting_cpos;
 452
 453 extern int yy_flex_debug;
 454 int yy_flex_debug = 1;
 455
 456 static yyconst short int yy_rule_linenum[13] =
 457     {   0,
 458        69,   70,   71,   74,   77,   78,   79,   85,   86,   87,
 459        89,   92
 460     } ;
 461
 462 /* The intent behind this definition is that it'll catch
 463  * any uses of REJECT which flex missed.
 464  */
 465 #define REJECT reject_used_but_not_detected
 466 #define yymore() yymore_used_but_not_detected
 467 #define YY_MORE_ADJ 0
 468 #define YY_RESTORE_YY_MORE_OFFSET
 469 char *yytext;
 470 #line 1 "scripts/genksyms/lex.l"
 471 #define INITIAL 0
 472 /* Lexical analysis for genksyms.
 473    Copyright 1996, 1997 Linux International.
 474
 475    New implementation contributed by Richard Henderson <rth@tamu.edu>
 476    Based on original work by Bjorn Ekwall <bj0rn@blox.se>
 477
 478    Taken from Linux modutils 2.4.22.
 479
 480    This program is free software; you can redistribute it and/or modify it
 481    under the terms of the GNU General Public License as published by the
 482    Free Software Foundation; either version 2 of the License, or (at your
 483    option) any later version.
 484
 485    This program is distributed in the hope that it will be useful, but
 486    WITHOUT ANY WARRANTY; without even the implied warranty of
 487    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 488    General Public License for more details.
 489
 490    You should have received a copy of the GNU General Public License
 491    along with this program; if not, write to the Free Software Foundation,
 492    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 493 #line 25 "scripts/genksyms/lex.l"
 494
 495 #include <limits.h>
 496 #include <stdlib.h>
 497 #include <string.h>
 498 #include <ctype.h>
 499
 500 #include "genksyms.h"
 501 #include "parse.h"
 502
 503 /* We've got a two-level lexer here.  We let flex do basic tokenization
 504    and then we categorize those basic tokens in the second stage.  */
 505 #define YY_DECL         static int yylex1(void)
 506
 507 /* Version 2 checksumming does proper tokenization; version 1 wasn't
 508    quite so pedantic.  */
 509 #define V2_TOKENS 1
 510
 511 /* We don't do multiple input files.  */
 512 #line 513 "scripts/genksyms/lex.c"
 513
 514 /* Macros after this point can all be overridden by user definitions in
 515  * section 1.
 516  */
 517
 518 #ifndef YY_SKIP_YYWRAP
 519 #ifdef __cplusplus
 520 extern "C" int yywrap YY_PROTO(( void ));
 521 #else
 522 extern int yywrap YY_PROTO(( void ));
 523 #endif
 524 #endif
 525
 526 #ifndef YY_NO_UNPUT
 527 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 528 #endif
 529
 530 #ifndef yytext_ptr
 531 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 532 #endif
 533
 534 #ifdef YY_NEED_STRLEN
 535 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 536 #endif
 537
 538 #ifndef YY_NO_INPUT
 539 #ifdef __cplusplus
 540 static int yyinput YY_PROTO(( void ));
 541 #else
 542 static int input YY_PROTO(( void ));
 543 #endif
 544 #endif
 545
 546 #if YY_STACK_USED
 547 static int yy_start_stack_ptr = 0;
 548 static int yy_start_stack_depth = 0;
 549 static int *yy_start_stack = 0;
 550 #ifndef YY_NO_PUSH_STATE
 551 static void yy_push_state YY_PROTO(( int new_state ));
 552 #endif
 553 #ifndef YY_NO_POP_STATE
 554 static void yy_pop_state YY_PROTO(( void ));
 555 #endif
 556 #ifndef YY_NO_TOP_STATE
 557 static int yy_top_state YY_PROTO(( void ));
 558 #endif
 559
 560 #else
 561 #define YY_NO_PUSH_STATE 1
 562 #define YY_NO_POP_STATE 1
 563 #define YY_NO_TOP_STATE 1
 564 #endif
 565
 566 #ifdef YY_MALLOC_DECL
 567 YY_MALLOC_DECL
 568 #else
 569 #if __STDC__
 570 #ifndef __cplusplus
 571 #include <stdlib.h>
 572 #endif
 573 #else
 574 /* Just try to get by without declaring the routines.  This will fail
 575  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 576  * or sizeof(void*) != sizeof(int).
 577  */
 578 #endif
 579 #endif
 580
 581 /* Amount of stuff to slurp up with each read. */
 582 #ifndef YY_READ_BUF_SIZE
 583 #define YY_READ_BUF_SIZE 8192
 584 #endif
 585
 586 /* Copy whatever the last rule matched to the standard output. */
 587
 588 #ifndef ECHO
 589 /* This used to be an fputs(), but since the string might contain NUL's,
 590  * we now use fwrite().
 591  */
 592 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 593 #endif
 594
 595 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 596  * is returned in "result".
 597  */
 598 #ifndef YY_INPUT
 599 #define YY_INPUT(buf,result,max_size) \
 600         if ( yy_current_buffer->yy_is_interactive ) \
 601                 { \
 602                 int c = '*', n; \
 603                 for ( n = 0; n < max_size && \
 604                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 605                         buf[n] = (char) c; \
 606                 if ( c == '\n' ) \
 607                         buf[n++] = (char) c; \
 608                 if ( c == EOF && ferror( yyin ) ) \
 609                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 610                 result = n; \
 611                 } \
 612         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 613                   && ferror( yyin ) ) \
 614                 YY_FATAL_ERROR( "input in flex scanner failed" );
 615 #endif
 616
 617 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 618  * we don't want an extra ';' after the "return" because that will cause
 619  * some compilers to complain about unreachable statements.
 620  */
 621 #ifndef yyterminate
 622 #define yyterminate() return YY_NULL
 623 #endif
 624
 625 /* Number of entries by which start-condition stack grows. */
 626 #ifndef YY_START_STACK_INCR
 627 #define YY_START_STACK_INCR 25
 628 #endif
 629
 630 /* Report a fatal error. */
 631 #ifndef YY_FATAL_ERROR
 632 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 633 #endif
 634
 635 /* Default declaration of generated scanner - a define so the user can
 636  * easily add parameters.
 637  */
 638 #ifndef YY_DECL
 639 #define YY_DECL int yylex YY_PROTO(( void ))
 640 #endif
 641
 642 /* Code executed at the beginning of each rule, after yytext and yyleng
 643  * have been set up.
 644  */
 645 #ifndef YY_USER_ACTION
 646 #define YY_USER_ACTION
 647 #endif
 648
 649 /* Code executed at the end of each rule. */
 650 #ifndef YY_BREAK
 651 #define YY_BREAK break;
 652 #endif
 653
 654 #define YY_RULE_SETUP \
 655         if ( yyleng > 0 ) \
 656                 yy_current_buffer->yy_at_bol = \
 657                                 (yytext[yyleng - 1] == '\n'); \
 658         YY_USER_ACTION
 659
 660 YY_DECL
 661         {
 662         register yy_state_type yy_current_state;
 663         register char *yy_cp = NULL, *yy_bp = NULL;
 664         register int yy_act;
 665
 666 #line 65 "scripts/genksyms/lex.l"
 667
 668
 669
 670  /* Keep track of our location in the original source files.  */
 671 #line 672 "scripts/genksyms/lex.c"
 672
 673         if ( yy_init )
 674                 {
 675                 yy_init = 0;
 676
 677 #ifdef YY_USER_INIT
 678                 YY_USER_INIT;
 679 #endif
 680
 681                 if ( ! yy_start )
 682                         yy_start = 1;   /* first start state */
 683
 684                 if ( ! yyin )
 685                         yyin = stdin;
 686
 687                 if ( ! yyout )
 688                         yyout = stdout;
 689
 690                 if ( ! yy_current_buffer )
 691                         yy_current_buffer =
 692                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 693
 694                 yy_load_buffer_state();
 695                 }
 696
 697         while ( 1 )             /* loops until end-of-file is reached */
 698                 {
 699                 yy_cp = yy_c_buf_p;
 700
 701                 /* Support of yytext. */
 702                 *yy_cp = yy_hold_char;
 703
 704                 /* yy_bp points to the position in yy_ch_buf of the start of
 705                  * the current run.
 706                  */
 707                 yy_bp = yy_cp;
 708
 709                 yy_current_state = yy_start;
 710                 yy_current_state += YY_AT_BOL();
 711 yy_match:
 712                 do
 713                         {
 714                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 715                         if ( yy_accept[yy_current_state] )
 716                                 {
 717                                 yy_last_accepting_state = yy_current_state;
 718                                 yy_last_accepting_cpos = yy_cp;
 719                                 }
 720                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 721                                 {
 722                                 yy_current_state = (int) yy_def[yy_current_state];
 723                                 if ( yy_current_state >= 76 )
 724                                         yy_c = yy_meta[(unsigned int) yy_c];
 725                                 }
 726                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 727                         ++yy_cp;
 728                         }
 729                 while ( yy_base[yy_current_state] != 284 );
 730
 731 yy_find_action:
 732                 yy_act = yy_accept[yy_current_state];
 733                 if ( yy_act == 0 )
 734                         { /* have to back up */
 735                         yy_cp = yy_last_accepting_cpos;
 736                         yy_current_state = yy_last_accepting_state;
 737                         yy_act = yy_accept[yy_current_state];
 738                         }
 739
 740                 YY_DO_BEFORE_ACTION;
 741
 742
 743 do_action:      /* This label is used only to access EOF actions. */
 744
 745                 if ( yy_flex_debug )
 746                         {
 747                         if ( yy_act == 0 )
 748                                 fprintf( stderr, "--scanner backing up\n" );
 749                         else if ( yy_act < 13 )
 750                                 fprintf( stderr, "--accepting rule at line %d (\"%s\")\n",
 751                                          yy_rule_linenum[yy_act], yytext );
 752                         else if ( yy_act == 13 )
 753                                 fprintf( stderr, "--accepting default rule (\"%s\")\n",
 754                                          yytext );
 755                         else if ( yy_act == 14 )
 756                                 fprintf( stderr, "--(end of buffer or a NUL)\n" );
 757                         else
 758                                 fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
 759                         }
 760
 761                 switch ( yy_act )
 762         { /* beginning of action switch */
 763                         case 0: /* must back up */
 764                         /* undo the effects of YY_DO_BEFORE_ACTION */
 765                         *yy_cp = yy_hold_char;
 766                         yy_cp = yy_last_accepting_cpos;
 767                         yy_current_state = yy_last_accepting_state;
 768                         goto yy_find_action;
 769
 770 case 1:
 771 YY_RULE_SETUP
 772 #line 69 "scripts/genksyms/lex.l"
 773 return FILENAME;
 774         YY_BREAK
 775 case 2:
 776 YY_RULE_SETUP
 777 #line 70 "scripts/genksyms/lex.l"
 778 cur_line++;
 779         YY_BREAK
 780 case 3:
 781 YY_RULE_SETUP
 782 #line 71 "scripts/genksyms/lex.l"
 783 cur_line++;
 784         YY_BREAK
 785 /* Ignore all other whitespace.  */
 786 case 4:
 787 YY_RULE_SETUP
 788 #line 74 "scripts/genksyms/lex.l"
 789 ;
 790         YY_BREAK
 791 case 5:
 792 YY_RULE_SETUP
 793 #line 77 "scripts/genksyms/lex.l"
 794 return STRING;
 795         YY_BREAK
 796 case 6:
 797 YY_RULE_SETUP
 798 #line 78 "scripts/genksyms/lex.l"
 799 return CHAR;
 800         YY_BREAK
 801 case 7:
 802 YY_RULE_SETUP
 803 #line 79 "scripts/genksyms/lex.l"
 804 return IDENT;
 805         YY_BREAK
 806 /* The Pedant requires that the other C multi-character tokens be
 807     recognized as tokens.  We don't actually use them since we don't
 808     parse expressions, but we do want whitespace to be arranged
 809     around them properly.  */
 810 case 8:
 811 YY_RULE_SETUP
 812 #line 85 "scripts/genksyms/lex.l"
 813 return OTHER;
 814         YY_BREAK
 815 case 9:
 816 YY_RULE_SETUP
 817 #line 86 "scripts/genksyms/lex.l"
 818 return INT;
 819         YY_BREAK
 820 case 10:
 821 YY_RULE_SETUP
 822 #line 87 "scripts/genksyms/lex.l"
 823 return REAL;
 824         YY_BREAK
 825 case 11:
 826 YY_RULE_SETUP
 827 #line 89 "scripts/genksyms/lex.l"
 828 return DOTS;
 829         YY_BREAK
 830 /* All other tokens are single characters.  */
 831 case 12:
 832 YY_RULE_SETUP
 833 #line 92 "scripts/genksyms/lex.l"
 834 return yytext[0];
 835         YY_BREAK
 836 case 13:
 837 YY_RULE_SETUP
 838 #line 95 "scripts/genksyms/lex.l"
 839 ECHO;
 840         YY_BREAK
 841 #line 842 "scripts/genksyms/lex.c"
 842 case YY_STATE_EOF(INITIAL):
 843 case YY_STATE_EOF(V2_TOKENS):
 844         yyterminate();
 845
 846         case YY_END_OF_BUFFER:
 847                 {
 848                 /* Amount of text matched not including the EOB char. */
 849                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
 850
 851                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 852                 *yy_cp = yy_hold_char;
 853                 YY_RESTORE_YY_MORE_OFFSET
 854
 855                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
 856                         {
 857                         /* We're scanning a new file or input source.  It's
 858                          * possible that this happened because the user
 859                          * just pointed yyin at a new source and called
 860                          * yylex().  If so, then we have to assure
 861                          * consistency between yy_current_buffer and our
 862                          * globals.  Here is the right place to do so, because
 863                          * this is the first action (other than possibly a
 864                          * back-up) that will match for the new input source.
 865                          */
 866                         yy_n_chars = yy_current_buffer->yy_n_chars;
 867                         yy_current_buffer->yy_input_file = yyin;
 868                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
 869                         }
 870
 871                 /* Note that here we test for yy_c_buf_p "<=" to the position
 872                  * of the first EOB in the buffer, since yy_c_buf_p will
 873                  * already have been incremented past the NUL character
 874                  * (since all states make transitions on EOB to the
 875                  * end-of-buffer state).  Contrast this with the test
 876                  * in input().
 877                  */
 878                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 879                         { /* This was really a NUL. */
 880                         yy_state_type yy_next_state;
 881
 882                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 883
 884                         yy_current_state = yy_get_previous_state();
 885
 886                         /* Okay, we're now positioned to make the NUL
 887                          * transition.  We couldn't have
 888                          * yy_get_previous_state() go ahead and do it
 889                          * for us because it doesn't know how to deal
 890                          * with the possibility of jamming (and we don't
 891                          * want to build jamming into it because then it
 892                          * will run more slowly).
 893                          */
 894
 895                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 896
 897                         yy_bp = yytext_ptr + YY_MORE_ADJ;
 898
 899                         if ( yy_next_state )
 900                                 {
 901                                 /* Consume the NUL. */
 902                                 yy_cp = ++yy_c_buf_p;
 903                                 yy_current_state = yy_next_state;
 904                                 goto yy_match;
 905                                 }
 906
 907                         else
 908                                 {
 909                                 yy_cp = yy_c_buf_p;
 910                                 goto yy_find_action;
 911                                 }
 912                         }
 913
 914                 else switch ( yy_get_next_buffer() )
 915                         {
 916                         case EOB_ACT_END_OF_FILE:
 917                                 {
 918                                 yy_did_buffer_switch_on_eof = 0;
 919
 920                                 if ( yywrap() )
 921                                         {
 922                                         /* Note: because we've taken care in
 923                                          * yy_get_next_buffer() to have set up
 924                                          * yytext, we can now set up
 925                                          * yy_c_buf_p so that if some total
 926                                          * hoser (like flex itself) wants to
 927                                          * call the scanner after we return the
 928                                          * YY_NULL, it'll still work - another
 929                                          * YY_NULL will get returned.
 930                                          */
 931                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
 932
 933                                         yy_act = YY_STATE_EOF(YY_START);
 934                                         goto do_action;
 935                                         }
 936
 937                                 else
 938                                         {
 939                                         if ( ! yy_did_buffer_switch_on_eof )
 940                                                 YY_NEW_FILE;
 941                                         }
 942                                 break;
 943                                 }
 944
 945                         case EOB_ACT_CONTINUE_SCAN:
 946                                 yy_c_buf_p =
 947                                         yytext_ptr + yy_amount_of_matched_text;
 948
 949                                 yy_current_state = yy_get_previous_state();
 950
 951                                 yy_cp = yy_c_buf_p;
 952                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 953                                 goto yy_match;
 954
 955                         case EOB_ACT_LAST_MATCH:
 956                                 yy_c_buf_p =
 957                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
 958
 959                                 yy_current_state = yy_get_previous_state();
 960
 961                                 yy_cp = yy_c_buf_p;
 962                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 963                                 goto yy_find_action;
 964                         }
 965                 break;
 966                 }
 967
 968         default:
 969                 YY_FATAL_ERROR(
 970                         "fatal flex scanner internal error--no action found" );
 971         } /* end of action switch */
 972                 } /* end of scanning one token */
 973         } /* end of yylex */
 974
 975
 976 /* yy_get_next_buffer - try to read in a new buffer
 977  *
 978  * Returns a code representing an action:
 979  *      EOB_ACT_LAST_MATCH -
 980  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 981  *      EOB_ACT_END_OF_FILE - end of file
 982  */
 983
 984 static int yy_get_next_buffer()
 985         {
 986         register char *dest = yy_current_buffer->yy_ch_buf;
 987         register char *source = yytext_ptr;
 988         register int number_to_move, i;
 989         int ret_val;
 990
 991         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
 992                 YY_FATAL_ERROR(
 993                 "fatal flex scanner internal error--end of buffer missed" );
 994
 995         if ( yy_current_buffer->yy_fill_buffer == 0 )
 996                 { /* Don't try to fill the buffer, so this is an EOF. */
 997                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
 998                         {
 999                         /* We matched a single character, the EOB, so
1000                          * treat this as a final EOF.
1001                          */
1002                         return EOB_ACT_END_OF_FILE;
1003                         }
1004
1005                 else
1006                         {
1007                         /* We matched some text prior to the EOB, first
1008                          * process it.
1009                          */
1010                         return EOB_ACT_LAST_MATCH;
1011                         }
1012                 }
1013
1014         /* Try to read more data. */
1015
1016         /* First move last chars to start of buffer. */
1017         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1018
1019         for ( i = 0; i < number_to_move; ++i )
1020                 *(dest++) = *(source++);
1021
1022         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1023                 /* don't do the read, it's not guaranteed to return an EOF,
1024                  * just force an EOF
1025                  */
1026                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1027
1028         else
1029                 {
1030                 int num_to_read =
1031                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1032
1033                 while ( num_to_read <= 0 )
1034                         { /* Not enough room in the buffer - grow it. */
1035 #ifdef YY_USES_REJECT
1036                         YY_FATAL_ERROR(
1037 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1038 #else
1039
1040                         /* just a shorter name for the current buffer */
1041                         YY_BUFFER_STATE b = yy_current_buffer;
1042
1043                         int yy_c_buf_p_offset =
1044                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1045
1046                         if ( b->yy_is_our_buffer )
1047                                 {
1048                                 int new_size = b->yy_buf_size * 2;
1049
1050                                 if ( new_size <= 0 )
1051                                         b->yy_buf_size += b->yy_buf_size / 8;
1052                                 else
1053                                         b->yy_buf_size *= 2;
1054
1055                                 b->yy_ch_buf = (char *)
1056                                         /* Include room in for 2 EOB chars. */
1057                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1058                                                          b->yy_buf_size + 2 );
1059                                 }
1060                         else
1061                                 /* Can't grow it, we don't own it. */
1062                                 b->yy_ch_buf = 0;
1063
1064                         if ( ! b->yy_ch_buf )
1065                                 YY_FATAL_ERROR(
1066                                 "fatal error - scanner input buffer overflow" );
1067
1068                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1069
1070                         num_to_read = yy_current_buffer->yy_buf_size -
1071                                                 number_to_move - 1;
1072 #endif
1073                         }
1074
1075                 if ( num_to_read > YY_READ_BUF_SIZE )
1076                         num_to_read = YY_READ_BUF_SIZE;
1077
1078                 /* Read in more data. */
1079                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1080                         yy_n_chars, num_to_read );
1081
1082                 yy_current_buffer->yy_n_chars = yy_n_chars;
1083                 }
1084
1085         if ( yy_n_chars == 0 )
1086                 {
1087                 if ( number_to_move == YY_MORE_ADJ )
1088                         {
1089                         ret_val = EOB_ACT_END_OF_FILE;
1090                         yyrestart( yyin );
1091                         }
1092
1093                 else
1094                         {
1095                         ret_val = EOB_ACT_LAST_MATCH;
1096                         yy_current_buffer->yy_buffer_status =
1097                                 YY_BUFFER_EOF_PENDING;
1098                         }
1099                 }
1100
1101         else
1102                 ret_val = EOB_ACT_CONTINUE_SCAN;
1103
1104         yy_n_chars += number_to_move;
1105         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1106         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1107
1108         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1109
1110         return ret_val;
1111         }
1112
1113
1114 /* yy_get_previous_state - get the state just before the EOB char was reached */
1115
1116 static yy_state_type yy_get_previous_state()
1117         {
1118         register yy_state_type yy_current_state;
1119         register char *yy_cp;
1120
1121         yy_current_state = yy_start;
1122         yy_current_state += YY_AT_BOL();
1123
1124         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1125                 {
1126                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1127                 if ( yy_accept[yy_current_state] )
1128                         {
1129                         yy_last_accepting_state = yy_current_state;
1130                         yy_last_accepting_cpos = yy_cp;
1131                         }
1132                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1133                         {
1134                         yy_current_state = (int) yy_def[yy_current_state];
1135                         if ( yy_current_state >= 76 )
1136                                 yy_c = yy_meta[(unsigned int) yy_c];
1137                         }
1138                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1139                 }
1140
1141         return yy_current_state;
1142         }
1143
1144
1145 /* yy_try_NUL_trans - try to make a transition on the NUL character
1146  *
1147  * synopsis
1148  *      next_state = yy_try_NUL_trans( current_state );
1149  */
1150
1151 #ifdef YY_USE_PROTOS
1152 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1153 #else
1154 static yy_state_type yy_try_NUL_trans( yy_current_state )
1155 yy_state_type yy_current_state;
1156 #endif
1157         {
1158         register int yy_is_jam;
1159         register char *yy_cp = yy_c_buf_p;
1160
1161         register YY_CHAR yy_c = 1;
1162         if ( yy_accept[yy_current_state] )
1163                 {
1164                 yy_last_accepting_state = yy_current_state;
1165                 yy_last_accepting_cpos = yy_cp;
1166                 }
1167         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1168                 {
1169                 yy_current_state = (int) yy_def[yy_current_state];
1170                 if ( yy_current_state >= 76 )
1171                         yy_c = yy_meta[(unsigned int) yy_c];
1172                 }
1173         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1174         yy_is_jam = (yy_current_state == 75);
1175
1176         return yy_is_jam ? 0 : yy_current_state;
1177         }
1178
1179
1180 #ifndef YY_NO_UNPUT
1181 #ifdef YY_USE_PROTOS
1182 static void yyunput( int c, register char *yy_bp )
1183 #else
1184 static void yyunput( c, yy_bp )
1185 int c;
1186 register char *yy_bp;
1187 #endif
1188         {
1189         register char *yy_cp = yy_c_buf_p;
1190
1191         /* undo effects of setting up yytext */
1192         *yy_cp = yy_hold_char;
1193
1194         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1195                 { /* need to shift things up to make room */
1196                 /* +2 for EOB chars. */
1197                 register int number_to_move = yy_n_chars + 2;
1198                 register char *dest = &yy_current_buffer->yy_ch_buf[
1199                                         yy_current_buffer->yy_buf_size + 2];
1200                 register char *source =
1201                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1202
1203                 while ( source > yy_current_buffer->yy_ch_buf )
1204                         *--dest = *--source;
1205
1206                 yy_cp += (int) (dest - source);
1207                 yy_bp += (int) (dest - source);
1208                 yy_current_buffer->yy_n_chars =
1209                         yy_n_chars = yy_current_buffer->yy_buf_size;
1210
1211                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1212                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1213                 }
1214
1215         *--yy_cp = (char) c;
1216
1217
1218         yytext_ptr = yy_bp;
1219         yy_hold_char = *yy_cp;
1220         yy_c_buf_p = yy_cp;
1221         }
1222 #endif  /* ifndef YY_NO_UNPUT */
1223
1224
1225 #ifdef __cplusplus
1226 static int yyinput()
1227 #else
1228 static int input()
1229 #endif
1230         {
1231         int c;
1232
1233         *yy_c_buf_p = yy_hold_char;
1234
1235         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1236                 {
1237                 /* yy_c_buf_p now points to the character we want to return.
1238                  * If this occurs *before* the EOB characters, then it's a
1239                  * valid NUL; if not, then we've hit the end of the buffer.
1240                  */
1241                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1242                         /* This was really a NUL. */
1243                         *yy_c_buf_p = '\0';
1244
1245                 else
1246                         { /* need more input */
1247                         int offset = yy_c_buf_p - yytext_ptr;
1248                         ++yy_c_buf_p;
1249
1250                         switch ( yy_get_next_buffer() )
1251                                 {
1252                                 case EOB_ACT_LAST_MATCH:
1253                                         /* This happens because yy_g_n_b()
1254                                          * sees that we've accumulated a
1255                                          * token and flags that we need to
1256                                          * try matching the token before
1257                                          * proceeding.  But for input(),
1258                                          * there's no matching to consider.
1259                                          * So convert the EOB_ACT_LAST_MATCH
1260                                          * to EOB_ACT_END_OF_FILE.
1261                                          */
1262
1263                                         /* Reset buffer status. */
1264                                         yyrestart( yyin );
1265
1266                                         /* fall through */
1267
1268                                 case EOB_ACT_END_OF_FILE:
1269                                         {
1270                                         if ( yywrap() )
1271                                                 return EOF;
1272
1273                                         if ( ! yy_did_buffer_switch_on_eof )
1274                                                 YY_NEW_FILE;
1275 #ifdef __cplusplus
1276                                         return yyinput();
1277 #else
1278                                         return input();
1279 #endif
1280                                         }
1281
1282                                 case EOB_ACT_CONTINUE_SCAN:
1283                                         yy_c_buf_p = yytext_ptr + offset;
1284                                         break;
1285                                 }
1286                         }
1287                 }
1288
1289         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1290         *yy_c_buf_p = '\0';     /* preserve yytext */
1291         yy_hold_char = *++yy_c_buf_p;
1292
1293         yy_current_buffer->yy_at_bol = (c == '\n');
1294
1295         return c;
1296         }
1297
1298
1299 #ifdef YY_USE_PROTOS
1300 void yyrestart( FILE *input_file )
1301 #else
1302 void yyrestart( input_file )
1303 FILE *input_file;
1304 #endif
1305         {
1306         if ( ! yy_current_buffer )
1307                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1308
1309         yy_init_buffer( yy_current_buffer, input_file );
1310         yy_load_buffer_state();
1311         }
1312
1313
1314 #ifdef YY_USE_PROTOS
1315 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1316 #else
1317 void yy_switch_to_buffer( new_buffer )
1318 YY_BUFFER_STATE new_buffer;
1319 #endif
1320         {
1321         if ( yy_current_buffer == new_buffer )
1322                 return;
1323
1324         if ( yy_current_buffer )
1325                 {
1326                 /* Flush out information for old buffer. */
1327                 *yy_c_buf_p = yy_hold_char;
1328                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1329                 yy_current_buffer->yy_n_chars = yy_n_chars;
1330                 }
1331
1332         yy_current_buffer = new_buffer;
1333         yy_load_buffer_state();
1334
1335         /* We don't actually know whether we did this switch during
1336          * EOF (yywrap()) processing, but the only time this flag
1337          * is looked at is after yywrap() is called, so it's safe
1338          * to go ahead and always set it.
1339          */
1340         yy_did_buffer_switch_on_eof = 1;
1341         }
1342
1343
1344 #ifdef YY_USE_PROTOS
1345 void yy_load_buffer_state( void )
1346 #else
1347 void yy_load_buffer_state()
1348 #endif
1349         {
1350         yy_n_chars = yy_current_buffer->yy_n_chars;
1351         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1352         yyin = yy_current_buffer->yy_input_file;
1353         yy_hold_char = *yy_c_buf_p;
1354         }
1355
1356
1357 #ifdef YY_USE_PROTOS
1358 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1359 #else
1360 YY_BUFFER_STATE yy_create_buffer( file, size )
1361 FILE *file;
1362 int size;
1363 #endif
1364         {
1365         YY_BUFFER_STATE b;
1366
1367         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1368         if ( ! b )
1369                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1370
1371         b->yy_buf_size = size;
1372
1373         /* yy_ch_buf has to be 2 characters longer than the size given because
1374          * we need to put in 2 end-of-buffer characters.
1375          */
1376         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1377         if ( ! b->yy_ch_buf )
1378                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1379
1380         b->yy_is_our_buffer = 1;
1381
1382         yy_init_buffer( b, file );
1383
1384         return b;
1385         }
1386
1387
1388 #ifdef YY_USE_PROTOS
1389 void yy_delete_buffer( YY_BUFFER_STATE b )
1390 #else
1391 void yy_delete_buffer( b )
1392 YY_BUFFER_STATE b;
1393 #endif
1394         {
1395         if ( ! b )
1396                 return;
1397
1398         if ( b == yy_current_buffer )
1399                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1400
1401         if ( b->yy_is_our_buffer )
1402                 yy_flex_free( (void *) b->yy_ch_buf );
1403
1404         yy_flex_free( (void *) b );
1405         }
1406
1407
1408
1409 #ifdef YY_USE_PROTOS
1410 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1411 #else
1412 void yy_init_buffer( b, file )
1413 YY_BUFFER_STATE b;
1414 FILE *file;
1415 #endif
1416
1417
1418         {
1419         yy_flush_buffer( b );
1420
1421         b->yy_input_file = file;
1422         b->yy_fill_buffer = 1;
1423
1424 #if YY_ALWAYS_INTERACTIVE
1425         b->yy_is_interactive = 1;
1426 #else
1427 #if YY_NEVER_INTERACTIVE
1428         b->yy_is_interactive = 0;
1429 #else
1430         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1431 #endif
1432 #endif
1433         }
1434
1435
1436 #ifdef YY_USE_PROTOS
1437 void yy_flush_buffer( YY_BUFFER_STATE b )
1438 #else
1439 void yy_flush_buffer( b )
1440 YY_BUFFER_STATE b;
1441 #endif
1442
1443         {
1444         if ( ! b )
1445                 return;
1446
1447         b->yy_n_chars = 0;
1448
1449         /* We always need two end-of-buffer characters.  The first causes
1450          * a transition to the end-of-buffer state.  The second causes
1451          * a jam in that state.
1452          */
1453         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1454         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1455
1456         b->yy_buf_pos = &b->yy_ch_buf[0];
1457
1458         b->yy_at_bol = 1;
1459         b->yy_buffer_status = YY_BUFFER_NEW;
1460
1461         if ( b == yy_current_buffer )
1462                 yy_load_buffer_state();
1463         }
1464
1465
1466 #ifndef YY_NO_SCAN_BUFFER
1467 #ifdef YY_USE_PROTOS
1468 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1469 #else
1470 YY_BUFFER_STATE yy_scan_buffer( base, size )
1471 char *base;
1472 yy_size_t size;
1473 #endif
1474         {
1475         YY_BUFFER_STATE b;
1476
1477         if ( size < 2 ||
1478              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1479              base[size-1] != YY_END_OF_BUFFER_CHAR )
1480                 /* They forgot to leave room for the EOB's. */
1481                 return 0;
1482
1483         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1484         if ( ! b )
1485                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1486
1487         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1488         b->yy_buf_pos = b->yy_ch_buf = base;
1489         b->yy_is_our_buffer = 0;
1490         b->yy_input_file = 0;
1491         b->yy_n_chars = b->yy_buf_size;
1492         b->yy_is_interactive = 0;
1493         b->yy_at_bol = 1;
1494         b->yy_fill_buffer = 0;
1495         b->yy_buffer_status = YY_BUFFER_NEW;
1496
1497         yy_switch_to_buffer( b );
1498
1499         return b;
1500         }
1501 #endif
1502
1503
1504 #ifndef YY_NO_SCAN_STRING
1505 #ifdef YY_USE_PROTOS
1506 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1507 #else
1508 YY_BUFFER_STATE yy_scan_string( yy_str )
1509 yyconst char *yy_str;
1510 #endif
1511         {
1512         int len;
1513         for ( len = 0; yy_str[len]; ++len )
1514                 ;
1515
1516         return yy_scan_bytes( yy_str, len );
1517         }
1518 #endif
1519
1520
1521 #ifndef YY_NO_SCAN_BYTES
1522 #ifdef YY_USE_PROTOS
1523 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1524 #else
1525 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1526 yyconst char *bytes;
1527 int len;
1528 #endif
1529         {
1530         YY_BUFFER_STATE b;
1531         char *buf;
1532         yy_size_t n;
1533         int i;
1534
1535         /* Get memory for full buffer, including space for trailing EOB's. */
1536         n = len + 2;
1537         buf = (char *) yy_flex_alloc( n );
1538         if ( ! buf )
1539                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1540
1541         for ( i = 0; i < len; ++i )
1542                 buf[i] = bytes[i];
1543
1544         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1545
1546         b = yy_scan_buffer( buf, n );
1547         if ( ! b )
1548                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1549
1550         /* It's okay to grow etc. this buffer, and we should throw it
1551          * away when we're done.
1552          */
1553         b->yy_is_our_buffer = 1;
1554
1555         return b;
1556         }
1557 #endif
1558
1559
1560 #ifndef YY_NO_PUSH_STATE
1561 #ifdef YY_USE_PROTOS
1562 static void yy_push_state( int new_state )
1563 #else
1564 static void yy_push_state( new_state )
1565 int new_state;
1566 #endif
1567         {
1568         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1569                 {
1570                 yy_size_t new_size;
1571
1572                 yy_start_stack_depth += YY_START_STACK_INCR;
1573                 new_size = yy_start_stack_depth * sizeof( int );
1574
1575                 if ( ! yy_start_stack )
1576                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1577
1578                 else
1579                         yy_start_stack = (int *) yy_flex_realloc(
1580                                         (void *) yy_start_stack, new_size );
1581
1582                 if ( ! yy_start_stack )
1583                         YY_FATAL_ERROR(
1584                         "out of memory expanding start-condition stack" );
1585                 }
1586
1587         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1588
1589         BEGIN(new_state);
1590         }
1591 #endif
1592
1593
1594 #ifndef YY_NO_POP_STATE
1595 static void yy_pop_state()
1596         {
1597         if ( --yy_start_stack_ptr < 0 )
1598                 YY_FATAL_ERROR( "start-condition stack underflow" );
1599
1600         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1601         }
1602 #endif
1603
1604
1605 #ifndef YY_NO_TOP_STATE
1606 static int yy_top_state()
1607         {
1608         return yy_start_stack[yy_start_stack_ptr - 1];
1609         }
1610 #endif
1611
1612 #ifndef YY_EXIT_FAILURE
1613 #define YY_EXIT_FAILURE 2
1614 #endif
1615
1616 #ifdef YY_USE_PROTOS
1617 static void yy_fatal_error( yyconst char msg[] )
1618 #else
1619 static void yy_fatal_error( msg )
1620 char msg[];
1621 #endif
1622         {
1623         (void) fprintf( stderr, "%s\n", msg );
1624         exit( YY_EXIT_FAILURE );
1625         }
1626
1627
1628
1629 /* Redefine yyless() so it works in section 3 code. */
1630
1631 #undef yyless
1632 #define yyless(n) \
1633         do \
1634                 { \
1635                 /* Undo effects of setting up yytext. */ \
1636                 yytext[yyleng] = yy_hold_char; \
1637                 yy_c_buf_p = yytext + n; \
1638                 yy_hold_char = *yy_c_buf_p; \
1639                 *yy_c_buf_p = '\0'; \
1640                 yyleng = n; \
1641                 } \
1642         while ( 0 )
1643
1644
1645 /* Internal utility routines. */
1646
1647 #ifndef yytext_ptr
1648 #ifdef YY_USE_PROTOS
1649 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1650 #else
1651 static void yy_flex_strncpy( s1, s2, n )
1652 char *s1;
1653 yyconst char *s2;
1654 int n;
1655 #endif
1656         {
1657         register int i;
1658         for ( i = 0; i < n; ++i )
1659                 s1[i] = s2[i];
1660         }
1661 #endif
1662
1663 #ifdef YY_NEED_STRLEN
1664 #ifdef YY_USE_PROTOS
1665 static int yy_flex_strlen( yyconst char *s )
1666 #else
1667 static int yy_flex_strlen( s )
1668 yyconst char *s;
1669 #endif
1670         {
1671         register int n;
1672         for ( n = 0; s[n]; ++n )
1673                 ;
1674
1675         return n;
1676         }
1677 #endif
1678
1679
1680 #ifdef YY_USE_PROTOS
1681 static void *yy_flex_alloc( yy_size_t size )
1682 #else
1683 static void *yy_flex_alloc( size )
1684 yy_size_t size;
1685 #endif
1686         {
1687         return (void *) malloc( size );
1688         }
1689
1690 #ifdef YY_USE_PROTOS
1691 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1692 #else
1693 static void *yy_flex_realloc( ptr, size )
1694 void *ptr;
1695 yy_size_t size;
1696 #endif
1697         {
1698         /* The cast to (char *) in the following accommodates both
1699          * implementations that use char* generic pointers, and those
1700          * that use void* generic pointers.  It works with the latter
1701          * because both ANSI C and C++ allow castless assignment from
1702          * any pointer type to void*, and deal with argument conversions
1703          * as though doing an assignment.
1704          */
1705         return (void *) realloc( (char *) ptr, size );
1706         }
1707
1708 #ifdef YY_USE_PROTOS
1709 static void yy_flex_free( void *ptr )
1710 #else
1711 static void yy_flex_free( ptr )
1712 void *ptr;
1713 #endif
1714         {
1715         free( ptr );
1716         }
1717
1718 #if YY_MAIN
1719 int main()
1720         {
1721         yylex();
1722         return 0;
1723         }
1724 #endif
1725 #line 95 "scripts/genksyms/lex.l"
1726
1727
1728 /* Bring in the keyword recognizer.  */
1729
1730 #include "keywords.c"
1731
1732
1733 /* Macros to append to our phrase collection list.  */
1734
1735 #define _APP(T,L)       do {                                               \
1736                           cur_node = next_node;                            \
1737                           next_node = xmalloc(sizeof(*next_node));         \
1738                           next_node->next = cur_node;                      \
1739                           cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
1740                           cur_node->tag = SYM_NORMAL;                      \
1741                         } while (0)
1742
1743 #define APP             _APP(yytext, yyleng)
1744
1745
1746 /* The second stage lexer.  Here we incorporate knowledge of the state
1747    of the parser to tailor the tokens that are returned.  */
1748
1749 int
1750 yylex(void)
1751 {
1752   static enum {
1753     ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_BRACKET, ST_BRACE,
1754     ST_EXPRESSION, ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
1755     ST_TABLE_5, ST_TABLE_6
1756   } lexstate = ST_NOTSTARTED;
1757
1758   static int suppress_type_lookup, dont_want_brace_phrase;
1759   static struct string_list *next_node;
1760
1761   int token, count = 0;
1762   struct string_list *cur_node;
1763
1764   if (lexstate == ST_NOTSTARTED)
1765     {
1766       BEGIN(V2_TOKENS);
1767       next_node = xmalloc(sizeof(*next_node));
1768       next_node->next = NULL;
1769       lexstate = ST_NORMAL;
1770     }
1771
1772 repeat:
1773   token = yylex1();
1774
1775   if (token == 0)
1776     return 0;
1777   else if (token == FILENAME)
1778     {
1779       char *file, *e;
1780
1781       /* Save the filename and line number for later error messages.  */
1782
1783       if (cur_filename)
1784         free(cur_filename);
1785
1786       file = strchr(yytext, '\"')+1;
1787       e = strchr(file, '\"');
1788       *e = '\0';
1789       cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
1790       cur_line = atoi(yytext+2);
1791
1792       goto repeat;
1793     }
1794
1795   switch (lexstate)
1796     {
1797     case ST_NORMAL:
1798       switch (token)
1799         {
1800         case IDENT:
1801           APP;
1802           {
1803             const struct resword *r = is_reserved_word(yytext, yyleng);
1804             if (r)
1805               {
1806                 switch (token = r->token)
1807                   {
1808                   case ATTRIBUTE_KEYW:
1809                     lexstate = ST_ATTRIBUTE;
1810                     count = 0;
1811                     goto repeat;
1812                   case ASM_KEYW:
1813                     lexstate = ST_ASM;
1814                     count = 0;
1815                     goto repeat;
1816
1817                   case STRUCT_KEYW:
1818                   case UNION_KEYW:
1819                     dont_want_brace_phrase = 3;
1820                   case ENUM_KEYW:
1821                     suppress_type_lookup = 2;
1822                     goto fini;
1823
1824                   case EXPORT_SYMBOL_KEYW:
1825                       goto fini;
1826                   }
1827               }
1828             if (!suppress_type_lookup)
1829               {
1830                 struct symbol *sym = find_symbol(yytext, SYM_TYPEDEF);
1831                 if (sym && sym->type == SYM_TYPEDEF)
1832                   token = TYPE;
1833               }
1834           }
1835           break;
1836
1837         case '[':
1838           APP;
1839           lexstate = ST_BRACKET;
1840           count = 1;
1841           goto repeat;
1842
1843         case '{':
1844           APP;
1845           if (dont_want_brace_phrase)
1846             break;
1847           lexstate = ST_BRACE;
1848           count = 1;
1849           goto repeat;
1850
1851         case '=': case ':':
1852           APP;
1853           lexstate = ST_EXPRESSION;
1854           break;
1855
1856         case DOTS:
1857         default:
1858           APP;
1859           break;
1860         }
1861       break;
1862
1863     case ST_ATTRIBUTE:
1864       APP;
1865       switch (token)
1866         {
1867         case '(':
1868           ++count;
1869           goto repeat;
1870         case ')':
1871           if (--count == 0)
1872             {
1873               lexstate = ST_NORMAL;
1874               token = ATTRIBUTE_PHRASE;
1875               break;
1876             }
1877           goto repeat;
1878         default:
1879           goto repeat;
1880         }
1881       break;
1882
1883     case ST_ASM:
1884       APP;
1885       switch (token)
1886         {
1887         case '(':
1888           ++count;
1889           goto repeat;
1890         case ')':
1891           if (--count == 0)
1892             {
1893               lexstate = ST_NORMAL;
1894               token = ASM_PHRASE;
1895               break;
1896             }
1897           goto repeat;
1898         default:
1899           goto repeat;
1900         }
1901       break;
1902
1903     case ST_BRACKET:
1904       APP;
1905       switch (token)
1906         {
1907         case '[':
1908           ++count;
1909           goto repeat;
1910         case ']':
1911           if (--count == 0)
1912             {
1913               lexstate = ST_NORMAL;
1914               token = BRACKET_PHRASE;
1915               break;
1916             }
1917           goto repeat;
1918         default:
1919           goto repeat;
1920         }
1921       break;
1922
1923     case ST_BRACE:
1924       APP;
1925       switch (token)
1926         {
1927         case '{':
1928           ++count;
1929           goto repeat;
1930         case '}':
1931           if (--count == 0)
1932             {
1933               lexstate = ST_NORMAL;
1934               token = BRACE_PHRASE;
1935               break;
1936             }
1937           goto repeat;
1938         default:
1939           goto repeat;
1940         }
1941       break;
1942
1943     case ST_EXPRESSION:
1944       switch (token)
1945         {
1946         case '(': case '[': case '{':
1947           ++count;
1948           APP;
1949           goto repeat;
1950         case ')': case ']': case '}':
1951           --count;
1952           APP;
1953           goto repeat;
1954         case ',': case ';':
1955           if (count == 0)
1956             {
1957               /* Put back the token we just read so's we can find it again
1958                  after registering the expression.  */
1959               unput(token);
1960
1961               lexstate = ST_NORMAL;
1962               token = EXPRESSION_PHRASE;
1963               break;
1964             }
1965           APP;
1966           goto repeat;
1967         default:
1968           APP;
1969           goto repeat;
1970         }
1971       break;
1972
1973     case ST_TABLE_1:
1974       goto repeat;
1975
1976     case ST_TABLE_2:
1977       if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
1978         {
1979           token = EXPORT_SYMBOL_KEYW;
1980           lexstate = ST_TABLE_5;
1981           APP;
1982           break;
1983         }
1984       lexstate = ST_TABLE_6;
1985       /* FALLTHRU */
1986
1987     case ST_TABLE_6:
1988       switch (token)
1989         {
1990         case '{': case '[': case '(':
1991           ++count;
1992           break;
1993         case '}': case ']': case ')':
1994           --count;
1995           break;
1996         case ',':
1997           if (count == 0)
1998             lexstate = ST_TABLE_2;
1999           break;
2000         };
2001       goto repeat;
2002
2003     case ST_TABLE_3:
2004       goto repeat;
2005
2006     case ST_TABLE_4:
2007       if (token == ';')
2008         lexstate = ST_NORMAL;
2009       goto repeat;
2010
2011     case ST_TABLE_5:
2012       switch (token)
2013         {
2014         case ',':
2015           token = ';';
2016           lexstate = ST_TABLE_2;
2017           APP;
2018           break;
2019         default:
2020           APP;
2021           break;
2022         }
2023       break;
2024
2025     default:
2026       abort();
2027     }
2028 fini:
2029
2030   if (suppress_type_lookup > 0)
2031     --suppress_type_lookup;
2032   if (dont_want_brace_phrase > 0)
2033     --dont_want_brace_phrase;
2034
2035   yylval = &next_node->next;
2036
2037   return token;
2038 }
2039 /* A Bison parser, made by GNU Bison 2.0.  */
2040
2041 /* Skeleton parser for Yacc-like parsing with Bison,
2042    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
2043
2044    This program is free software; you can redistribute it and/or modify
2045    it under the terms of the GNU General Public License as published by
2046    the Free Software Foundation; either version 2, or (at your option)
2047    any later version.
2048
2049    This program is distributed in the hope that it will be useful,
2050    but WITHOUT ANY WARRANTY; without even the implied warranty of
2051    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2052    GNU General Public License for more details.
2053
2054    You should have received a copy of the GNU General Public License
2055    along with this program; if not, write to the Free Software
2056    Foundation, Inc., 59 Temple Place - Suite 330,
2057    Boston, MA 02111-1307, USA.  */
2058
2059 /* As a special exception, when this file is copied by Bison into a
2060    Bison output file, you may use that output file without restriction.
2061    This special exception was added by the Free Software Foundation
2062    in version 1.24 of Bison.  */
2063
2064 /* Tokens.  */
2065 #ifndef YYTOKENTYPE
2066 # define YYTOKENTYPE
2067    /* Put the tokens into the symbol table, so that GDB and other debuggers
2068       know about them.  */
2069    enum yytokentype {
2070      ASM_KEYW = 258,
2071      ATTRIBUTE_KEYW = 259,
2072      AUTO_KEYW = 260,
2073      BOOL_KEYW = 261,
2074      CHAR_KEYW = 262,
2075      CONST_KEYW = 263,
2076      DOUBLE_KEYW = 264,
2077      ENUM_KEYW = 265,
2078      EXTERN_KEYW = 266,
2079      FLOAT_KEYW = 267,
2080      INLINE_KEYW = 268,
2081      INT_KEYW = 269,
2082      LONG_KEYW = 270,
2083      REGISTER_KEYW = 271,
2084      RESTRICT_KEYW = 272,
2085      SHORT_KEYW = 273,
2086      SIGNED_KEYW = 274,
2087      STATIC_KEYW = 275,
2088      STRUCT_KEYW = 276,
2089      TYPEDEF_KEYW = 277,
2090      UNION_KEYW = 278,
2091      UNSIGNED_KEYW = 279,
2092      VOID_KEYW = 280,
2093      VOLATILE_KEYW = 281,
2094      TYPEOF_KEYW = 282,
2095      EXPORT_SYMBOL_KEYW = 283,
2096      ASM_PHRASE = 284,
2097      ATTRIBUTE_PHRASE = 285,
2098      BRACE_PHRASE = 286,
2099      BRACKET_PHRASE = 287,
2100      EXPRESSION_PHRASE = 288,
2101      CHAR = 289,
2102      DOTS = 290,
2103      IDENT = 291,
2104      INT = 292,
2105      REAL = 293,
2106      STRING = 294,
2107      TYPE = 295,
2108      OTHER = 296,
2109      FILENAME = 297
2110    };
2111 #endif
2112 #define ASM_KEYW 258
2113 #define ATTRIBUTE_KEYW 259
2114 #define AUTO_KEYW 260
2115 #define BOOL_KEYW 261
2116 #define CHAR_KEYW 262
2117 #define CONST_KEYW 263
2118 #define DOUBLE_KEYW 264
2119 #define ENUM_KEYW 265
2120 #define EXTERN_KEYW 266
2121 #define FLOAT_KEYW 267
2122 #define INLINE_KEYW 268
2123 #define INT_KEYW 269
2124 #define LONG_KEYW 270
2125 #define REGISTER_KEYW 271
2126 #define RESTRICT_KEYW 272
2127 #define SHORT_KEYW 273
2128 #define SIGNED_KEYW 274
2129 #define STATIC_KEYW 275
2130 #define STRUCT_KEYW 276
2131 #define TYPEDEF_KEYW 277
2132 #define UNION_KEYW 278
2133 #define UNSIGNED_KEYW 279
2134 #define VOID_KEYW 280
2135 #define VOLATILE_KEYW 281
2136 #define TYPEOF_KEYW 282
2137 #define EXPORT_SYMBOL_KEYW 283
2138 #define ASM_PHRASE 284
2139 #define ATTRIBUTE_PHRASE 285
2140 #define BRACE_PHRASE 286
2141 #define BRACKET_PHRASE 287
2142 #define EXPRESSION_PHRASE 288
2143 #define CHAR 289
2144 #define DOTS 290
2145 #define IDENT 291
2146 #define INT 292
2147 #define REAL 293
2148 #define STRING 294
2149 #define TYPE 295
2150 #define OTHER 296
2151 #define FILENAME 297
2152
2153
2154
2155
2156 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
2157 typedef int YYSTYPE;
2158 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2159 # define YYSTYPE_IS_DECLARED 1
2160 # define YYSTYPE_IS_TRIVIAL 1
2161 #endif
2162
2163 extern YYSTYPE yylval;
2164
2165
2166