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