kconfig/lex.zconf.c
author "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
Tue Jan 12 19:24:03 2010 +0100 (2010-01-12)
changeset 1761 88020b2c3246
parent 943 1cca90ce0481
child 2448 a103abae1560
permissions -rw-r--r--
scripts/functions: change handling of nochdir

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