home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6-686 / scripts / genksyms / lex.c < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  52.4 KB  |  2,167 lines
  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.  
  2167.