2 #line 3 "/home/patrick/Source/coreboot/util/kconfig/zconf.lex.c"
4 #define YY_INT_ALIGNED short int
6 /* A lexical scanner generated by flex */
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
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
28 #define YY_FLEX_MAJOR_VERSION 2
29 #define YY_FLEX_MINOR_VERSION 5
30 #define YY_FLEX_SUBMINOR_VERSION 39
31 #if YY_FLEX_SUBMINOR_VERSION > 0
35 /* First, we deal with platform-specific or compiler-specific issues. */
37 /* begin standard C headers. */
43 /* end standard C headers. */
45 /* flex integer type definitions */
50 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
55 * if you want the limit (max/min) macros for int types.
57 #ifndef __STDC_LIMIT_MACROS
58 #define __STDC_LIMIT_MACROS 1
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;
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;
76 /* Limits of integral types. */
78 #define INT8_MIN (-128)
81 #define INT16_MIN (-32767-1)
84 #define INT32_MIN (-2147483647-1)
87 #define INT8_MAX (127)
90 #define INT16_MAX (32767)
93 #define INT32_MAX (2147483647)
96 #define UINT8_MAX (255U)
99 #define UINT16_MAX (65535U)
102 #define UINT32_MAX (4294967295U)
107 #endif /* ! FLEXINT_H */
111 /* The "const" storage-class-modifier is valid. */
114 #else /* ! __cplusplus */
116 /* C99 requires __STDC__ to be defined as 1. */
117 #if defined (__STDC__)
121 #endif /* defined (__STDC__) */
122 #endif /* ! __cplusplus */
125 #define yyconst const
130 /* Returned upon end-of-file. */
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
138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
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.
144 #define BEGIN (yy_start) = 1 + 2 *
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
150 #define YY_START (((yy_start) - 1) / 2)
151 #define YYSTATE YY_START
153 /* Action number for EOF rule of a given start state. */
154 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
156 /* Special action meaning "start processing a new file". */
157 #define YY_NEW_FILE zconfrestart(zconfin )
159 #define YY_END_OF_BUFFER_CHAR 0
161 /* Size of default input buffer. */
164 /* On IA-64, the buffer size is 16k, not 8k.
165 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
166 * Ditto for the __ia64__ case accordingly.
168 #define YY_BUF_SIZE 32768
170 #define YY_BUF_SIZE 16384
171 #endif /* __ia64__ */
174 /* The state buf must be large enough to hold one state per character in the main buffer.
176 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
178 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
179 #define YY_TYPEDEF_YY_BUFFER_STATE
180 typedef struct yy_buffer_state *YY_BUFFER_STATE;
183 #ifndef YY_TYPEDEF_YY_SIZE_T
184 #define YY_TYPEDEF_YY_SIZE_T
185 typedef size_t yy_size_t;
188 extern yy_size_t zconfleng;
190 extern FILE *zconfin, *zconfout;
192 #define EOB_ACT_CONTINUE_SCAN 0
193 #define EOB_ACT_END_OF_FILE 1
194 #define EOB_ACT_LAST_MATCH 2
196 #define YY_LESS_LINENO(n)
197 #define YY_LINENO_REWIND_TO(ptr)
199 /* Return all but the first "n" matched characters back to the input stream. */
203 /* Undo effects of setting up zconftext. */ \
204 int yyless_macro_arg = (n); \
205 YY_LESS_LINENO(yyless_macro_arg);\
206 *yy_cp = (yy_hold_char); \
207 YY_RESTORE_YY_MORE_OFFSET \
208 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
209 YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
213 #define unput(c) yyunput( c, (yytext_ptr) )
215 #ifndef YY_STRUCT_YY_BUFFER_STATE
216 #define YY_STRUCT_YY_BUFFER_STATE
217 struct yy_buffer_state
221 char *yy_ch_buf; /* input buffer */
222 char *yy_buf_pos; /* current position in input buffer */
224 /* Size of input buffer in bytes, not including room for EOB
227 yy_size_t yy_buf_size;
229 /* Number of characters read into yy_ch_buf, not including EOB
232 yy_size_t yy_n_chars;
234 /* Whether we "own" the buffer - i.e., we know we created it,
235 * and can realloc() it to grow it, and should free() it to
238 int yy_is_our_buffer;
240 /* Whether this is an "interactive" input source; if so, and
241 * if we're using stdio for input, then we want to use getc()
242 * instead of fread(), to make sure we stop fetching input after
245 int yy_is_interactive;
247 /* Whether we're considered to be at the beginning of a line.
248 * If so, '^' rules will be active on the next match, otherwise
253 int yy_bs_lineno; /**< The line count. */
254 int yy_bs_column; /**< The column count. */
256 /* Whether to try to fill the input buffer when we reach the
261 int yy_buffer_status;
263 #define YY_BUFFER_NEW 0
264 #define YY_BUFFER_NORMAL 1
265 /* When an EOF's been seen but there's still some text to process
266 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
267 * shouldn't try reading from the input source any more. We might
268 * still have a bunch of tokens to match, though, because of
269 * possible backing-up.
271 * When we actually see the EOF, we change the status to "new"
272 * (via zconfrestart()), so that the user can continue scanning by
273 * just pointing zconfin at a new input file.
275 #define YY_BUFFER_EOF_PENDING 2
278 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
280 /* Stack of input buffers. */
281 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
282 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
283 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
285 /* We provide macros for accessing buffer states in case in the
286 * future we want to put the buffer states in a more general
289 * Returns the top of the stack, or NULL.
291 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
292 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
295 /* Same as previous macro, but useful when we know that the buffer stack is not
296 * NULL or when we need an lvalue. For internal use only.
298 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
300 /* yy_hold_char holds the character lost when zconftext is formed. */
301 static char yy_hold_char;
302 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
305 /* Points to current character in buffer. */
306 static char *yy_c_buf_p = (char *) 0;
307 static int yy_init = 0; /* whether we need to initialize */
308 static int yy_start = 0; /* start state number */
310 /* Flag which is used to allow zconfwrap()'s to do buffer switches
311 * instead of setting up a fresh zconfin. A bit of a hack ...
313 static int yy_did_buffer_switch_on_eof;
315 void zconfrestart (FILE *input_file );
316 void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer );
317 YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size );
318 void zconf_delete_buffer (YY_BUFFER_STATE b );
319 void zconf_flush_buffer (YY_BUFFER_STATE b );
320 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer );
321 void zconfpop_buffer_state (void );
323 static void zconfensure_buffer_stack (void );
324 static void zconf_load_buffer_state (void );
325 static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file );
327 #define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
329 YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size );
330 YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str );
331 YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,yy_size_t len );
333 void *zconfalloc (yy_size_t );
334 void *zconfrealloc (void *,yy_size_t );
335 void zconffree (void * );
337 #define yy_new_buffer zconf_create_buffer
339 #define yy_set_interactive(is_interactive) \
341 if ( ! YY_CURRENT_BUFFER ){ \
342 zconfensure_buffer_stack (); \
343 YY_CURRENT_BUFFER_LVALUE = \
344 zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
346 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
349 #define yy_set_bol(at_bol) \
351 if ( ! YY_CURRENT_BUFFER ){\
352 zconfensure_buffer_stack (); \
353 YY_CURRENT_BUFFER_LVALUE = \
354 zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
356 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
359 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
361 /* Begin user sect3 */
363 #define zconfwrap() 1
364 #define YY_SKIP_YYWRAP
366 typedef unsigned char YY_CHAR;
368 FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
370 typedef int yy_state_type;
372 extern int zconflineno;
376 extern char *zconftext;
377 #define yytext_ptr zconftext
379 static yyconst flex_int16_t yy_nxt[][17] =
382 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
387 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
388 12, 12, 12, 12, 12, 12, 12
392 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
393 12, 12, 12, 12, 12, 12, 12
397 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
398 16, 16, 16, 18, 16, 16, 16
402 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
403 16, 16, 16, 18, 16, 16, 16
408 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
409 19, 19, 19, 19, 19, 19, 19
413 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
414 19, 19, 19, 19, 19, 19, 19
418 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
419 22, 22, 22, 22, 22, 25, 22
423 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
424 22, 22, 22, 22, 22, 25, 22
428 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
429 33, 34, 35, 35, 36, 37, 38
434 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
435 33, 34, 35, 35, 36, 37, 38
439 -11, -11, -11, -11, -11, -11, -11, -11, -11, -11,
440 -11, -11, -11, -11, -11, -11, -11
444 11, -12, -12, -12, -12, -12, -12, -12, -12, -12,
445 -12, -12, -12, -12, -12, -12, -12
449 11, -13, 39, 40, -13, -13, 41, -13, -13, -13,
450 -13, -13, -13, -13, -13, -13, -13
454 11, -14, -14, -14, -14, -14, -14, -14, -14, -14,
455 -14, -14, -14, -14, -14, -14, -14
460 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
461 42, 42, 42, 42, 42, 42, 42
465 11, -16, -16, -16, -16, -16, -16, -16, -16, -16,
466 -16, -16, -16, -16, -16, -16, -16
470 11, -17, -17, -17, -17, -17, -17, -17, -17, -17,
471 -17, -17, -17, -17, -17, -17, -17
475 11, -18, -18, -18, -18, -18, -18, -18, -18, -18,
476 -18, -18, -18, 44, -18, -18, -18
480 11, 45, 45, -19, 45, 45, 45, 45, 45, 45,
481 45, 45, 45, 45, 45, 45, 45
486 11, -20, 46, 47, -20, -20, -20, -20, -20, -20,
487 -20, -20, -20, -20, -20, -20, -20
491 11, 48, -21, -21, 48, 48, 48, 48, 48, 48,
492 48, 48, 48, 48, 48, 48, 48
496 11, 49, 49, 50, 49, -22, 49, 49, -22, 49,
497 49, 49, 49, 49, 49, -22, 49
501 11, -23, -23, -23, -23, -23, -23, -23, -23, -23,
502 -23, -23, -23, -23, -23, -23, -23
506 11, -24, -24, -24, -24, -24, -24, -24, -24, -24,
507 -24, -24, -24, -24, -24, -24, -24
512 11, 51, 51, 52, 51, 51, 51, 51, 51, 51,
513 51, 51, 51, 51, 51, 51, 51
517 11, -26, -26, -26, -26, -26, -26, -26, -26, -26,
518 -26, -26, -26, -26, -26, -26, -26
522 11, -27, -27, -27, -27, -27, -27, -27, -27, -27,
523 -27, -27, -27, -27, -27, -27, -27
527 11, -28, -28, -28, -28, -28, -28, -28, -28, -28,
528 -28, -28, -28, -28, 53, -28, -28
532 11, -29, -29, -29, -29, -29, -29, -29, -29, -29,
533 -29, -29, -29, -29, -29, -29, -29
538 11, 54, 54, -30, 54, 54, 54, 54, 54, 54,
539 54, 54, 54, 54, 54, 54, 54
543 11, -31, -31, -31, -31, -31, -31, 55, -31, -31,
544 -31, -31, -31, -31, -31, -31, -31
548 11, -32, -32, -32, -32, -32, -32, -32, -32, -32,
549 -32, -32, -32, -32, -32, -32, -32
553 11, -33, -33, -33, -33, -33, -33, -33, -33, -33,
554 -33, -33, -33, -33, -33, -33, -33
558 11, -34, -34, -34, -34, -34, -34, -34, -34, -34,
559 -34, 56, 57, 57, -34, -34, -34
564 11, -35, -35, -35, -35, -35, -35, -35, -35, -35,
565 -35, 57, 57, 57, -35, -35, -35
569 11, -36, -36, -36, -36, -36, -36, -36, -36, -36,
570 -36, -36, -36, -36, -36, -36, -36
574 11, -37, -37, 58, -37, -37, -37, -37, -37, -37,
575 -37, -37, -37, -37, -37, -37, -37
579 11, -38, -38, -38, -38, -38, -38, -38, -38, -38,
580 -38, -38, -38, -38, -38, -38, 59
584 11, -39, 39, 40, -39, -39, 41, -39, -39, -39,
585 -39, -39, -39, -39, -39, -39, -39
590 11, -40, -40, -40, -40, -40, -40, -40, -40, -40,
591 -40, -40, -40, -40, -40, -40, -40
595 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
596 42, 42, 42, 42, 42, 42, 42
600 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
601 42, 42, 42, 42, 42, 42, 42
605 11, -43, -43, -43, -43, -43, -43, -43, -43, -43,
606 -43, -43, -43, -43, -43, -43, -43
610 11, -44, -44, -44, -44, -44, -44, -44, -44, -44,
611 -44, -44, -44, 44, -44, -44, -44
616 11, 45, 45, -45, 45, 45, 45, 45, 45, 45,
617 45, 45, 45, 45, 45, 45, 45
621 11, -46, 46, 47, -46, -46, -46, -46, -46, -46,
622 -46, -46, -46, -46, -46, -46, -46
626 11, 48, -47, -47, 48, 48, 48, 48, 48, 48,
627 48, 48, 48, 48, 48, 48, 48
631 11, -48, -48, -48, -48, -48, -48, -48, -48, -48,
632 -48, -48, -48, -48, -48, -48, -48
636 11, 49, 49, 50, 49, -49, 49, 49, -49, 49,
637 49, 49, 49, 49, 49, -49, 49
642 11, -50, -50, -50, -50, -50, -50, -50, -50, -50,
643 -50, -50, -50, -50, -50, -50, -50
647 11, -51, -51, 52, -51, -51, -51, -51, -51, -51,
648 -51, -51, -51, -51, -51, -51, -51
652 11, -52, -52, -52, -52, -52, -52, -52, -52, -52,
653 -52, -52, -52, -52, -52, -52, -52
657 11, -53, -53, -53, -53, -53, -53, -53, -53, -53,
658 -53, -53, -53, -53, -53, -53, -53
662 11, 54, 54, -54, 54, 54, 54, 54, 54, 54,
663 54, 54, 54, 54, 54, 54, 54
668 11, -55, -55, -55, -55, -55, -55, -55, -55, -55,
669 -55, -55, -55, -55, -55, -55, -55
673 11, -56, -56, -56, -56, -56, -56, -56, -56, -56,
674 -56, 60, 57, 57, -56, -56, -56
678 11, -57, -57, -57, -57, -57, -57, -57, -57, -57,
679 -57, 57, 57, 57, -57, -57, -57
683 11, -58, -58, -58, -58, -58, -58, -58, -58, -58,
684 -58, -58, -58, -58, -58, -58, -58
688 11, -59, -59, -59, -59, -59, -59, -59, -59, -59,
689 -59, -59, -59, -59, -59, -59, -59
694 11, -60, -60, -60, -60, -60, -60, -60, -60, -60,
695 -60, 57, 57, 57, -60, -60, -60
700 static yy_state_type yy_get_previous_state (void );
701 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
702 static int yy_get_next_buffer (void );
703 static void yy_fatal_error (yyconst char msg[] );
705 /* Done after the current pattern has been matched and before the
706 * corresponding action - sets up zconftext.
708 #define YY_DO_BEFORE_ACTION \
709 (yytext_ptr) = yy_bp; \
710 zconfleng = (size_t) (yy_cp - yy_bp); \
711 (yy_hold_char) = *yy_cp; \
713 (yy_c_buf_p) = yy_cp;
715 #define YY_NUM_RULES 33
716 #define YY_END_OF_BUFFER 34
717 /* This struct is not used in this scanner,
718 but its presence is necessary. */
721 flex_int32_t yy_verify;
724 static yyconst flex_int16_t yy_accept[61] =
726 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
727 34, 5, 4, 2, 3, 7, 8, 6, 32, 29,
728 31, 24, 28, 27, 26, 22, 17, 13, 16, 20,
729 22, 11, 12, 19, 19, 14, 22, 22, 4, 2,
730 3, 3, 1, 6, 32, 29, 31, 30, 24, 23,
731 26, 25, 15, 20, 9, 19, 19, 21, 10, 18
734 static yyconst flex_int32_t yy_ec[256] =
736 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
737 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
738 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
739 1, 2, 4, 5, 6, 1, 1, 7, 8, 9,
740 10, 1, 1, 1, 11, 12, 12, 13, 13, 13,
741 13, 13, 13, 13, 13, 13, 13, 1, 1, 1,
742 14, 1, 1, 1, 13, 13, 13, 13, 13, 13,
743 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
744 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
745 1, 15, 1, 1, 13, 1, 13, 13, 13, 13,
747 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
748 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
749 13, 13, 1, 16, 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, 1, 1, 1, 1, 1,
754 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
755 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
756 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
758 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
759 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
760 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
761 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
762 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
766 extern int zconf_flex_debug;
767 int zconf_flex_debug = 0;
769 /* The intent behind this definition is that it'll catch
770 * any uses of REJECT which flex missed.
772 #define REJECT reject_used_but_not_detected
773 #define yymore() yymore_used_but_not_detected
774 #define YY_MORE_ADJ 0
775 #define YY_RESTORE_YY_MORE_OFFSET
777 #define YY_NO_INPUT 1
780 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
781 * Released under the terms of the GNU GPL v2.0.
793 #define START_STRSIZE 16
801 static int text_size, text_asize;
804 struct buffer *parent;
805 YY_BUFFER_STATE state;
808 struct buffer *current_buf;
810 static int last_ts, first_ts;
812 static void zconf_endhelp(void);
813 static void zconf_endfile(void);
815 static void new_string(void)
817 text = xmalloc(START_STRSIZE);
818 text_asize = START_STRSIZE;
823 static void append_string(const char *str, int size)
825 int new_size = text_size + size + 1;
826 if (new_size > text_asize) {
827 new_size += START_STRSIZE - 1;
828 new_size &= -START_STRSIZE;
829 text = realloc(text, new_size);
830 text_asize = new_size;
832 memcpy(text + text_size, str, size);
837 static void alloc_string(const char *str, int size)
839 text = xmalloc(size + 1);
840 memcpy(text, str, size);
850 #ifndef YY_NO_UNISTD_H
851 /* Special case for "unistd.h", since it is non-ANSI. We include it way
852 * down here because we want the user's section 1 to have been scanned first.
853 * The user has a chance to override it with an option.
858 #ifndef YY_EXTRA_TYPE
859 #define YY_EXTRA_TYPE void *
862 static int yy_init_globals (void );
864 /* Accessor methods to globals.
865 These are made visible to non-reentrant scanners for convenience. */
867 int zconflex_destroy (void );
869 int zconfget_debug (void );
871 void zconfset_debug (int debug_flag );
873 YY_EXTRA_TYPE zconfget_extra (void );
875 void zconfset_extra (YY_EXTRA_TYPE user_defined );
877 FILE *zconfget_in (void );
879 void zconfset_in (FILE * in_str );
881 FILE *zconfget_out (void );
883 void zconfset_out (FILE * out_str );
885 yy_size_t zconfget_leng (void );
887 char *zconfget_text (void );
889 int zconfget_lineno (void );
891 void zconfset_lineno (int line_number );
893 /* Macros after this point can all be overridden by user definitions in
897 #ifndef YY_SKIP_YYWRAP
899 extern "C" int zconfwrap (void );
901 extern int zconfwrap (void );
905 static void yyunput (int c,char *buf_ptr );
908 static void yy_flex_strncpy (char *,yyconst char *,int );
911 #ifdef YY_NEED_STRLEN
912 static int yy_flex_strlen (yyconst char * );
918 static int yyinput (void );
920 static int input (void );
925 /* Amount of stuff to slurp up with each read. */
926 #ifndef YY_READ_BUF_SIZE
928 /* On IA-64, the buffer size is 16k, not 8k */
929 #define YY_READ_BUF_SIZE 16384
931 #define YY_READ_BUF_SIZE 8192
932 #endif /* __ia64__ */
935 /* Copy whatever the last rule matched to the standard output. */
937 /* This used to be an fputs(), but since the string might contain NUL's,
938 * we now use fwrite().
940 #define ECHO do { if (fwrite( zconftext, zconfleng, 1, zconfout )) {} } while (0)
943 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
944 * is returned in "result".
947 #define YY_INPUT(buf,result,max_size) \
949 while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
951 if( errno != EINTR) \
953 YY_FATAL_ERROR( "input in flex scanner failed" ); \
963 /* No semi-colon after return; correct usage is to write "yyterminate();" -
964 * we don't want an extra ';' after the "return" because that will cause
965 * some compilers to complain about unreachable statements.
968 #define yyterminate() return YY_NULL
971 /* Number of entries by which start-condition stack grows. */
972 #ifndef YY_START_STACK_INCR
973 #define YY_START_STACK_INCR 25
976 /* Report a fatal error. */
977 #ifndef YY_FATAL_ERROR
978 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
981 /* end tables serialization structures and prototypes */
983 /* Default declaration of generated scanner - a define so the user can
984 * easily add parameters.
987 #define YY_DECL_IS_OURS 1
989 extern int zconflex (void);
991 #define YY_DECL int zconflex (void)
992 #endif /* !YY_DECL */
994 /* Code executed at the beginning of each rule, after zconftext and zconfleng
997 #ifndef YY_USER_ACTION
998 #define YY_USER_ACTION
1001 /* Code executed at the end of each rule. */
1003 #define YY_BREAK break;
1006 #define YY_RULE_SETUP \
1009 /** The main scanner function which does all the work.
1013 register yy_state_type yy_current_state;
1014 register char *yy_cp, *yy_bp;
1015 register int yy_act;
1026 (yy_start) = 1; /* first start state */
1034 if ( ! YY_CURRENT_BUFFER ) {
1035 zconfensure_buffer_stack ();
1036 YY_CURRENT_BUFFER_LVALUE =
1037 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1040 zconf_load_buffer_state( );
1048 while ( 1 ) /* loops until end-of-file is reached */
1050 yy_cp = (yy_c_buf_p);
1052 /* Support of zconftext. */
1053 *yy_cp = (yy_hold_char);
1055 /* yy_bp points to the position in yy_ch_buf of the start of
1060 yy_current_state = (yy_start);
1062 while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)] ]) > 0 )
1065 yy_current_state = -yy_current_state;
1068 yy_act = yy_accept[yy_current_state];
1070 YY_DO_BEFORE_ACTION;
1072 do_action: /* This label is used only to access EOF actions. */
1075 { /* beginning of action switch */
1077 /* rule 1 can match eol */
1079 /* rule 2 can match eol */
1082 current_file->lineno++;
1099 unput(zconftext[0]);
1107 const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1109 current_pos.file = current_file;
1110 current_pos.lineno = current_file->lineno;
1111 if (id && id->flags & TF_COMMAND) {
1115 alloc_string(zconftext, zconfleng);
1116 zconflval.string = text;
1125 /* rule 8 can match eol */
1129 current_file->lineno++;
1144 return T_OPEN_PAREN;
1148 return T_CLOSE_PAREN;
1171 /* rule 17 can match eol */
1173 BEGIN(INITIAL); current_file->lineno++; return T_EOL;
1182 const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1183 if (id && id->flags & TF_PARAM) {
1187 alloc_string(zconftext, zconfleng);
1188 zconflval.string = text;
1197 /* rule 21 can match eol */
1199 current_file->lineno++;
1205 case YY_STATE_EOF(PARAM):
1212 /* rule 23 can match eol */
1213 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1214 YY_LINENO_REWIND_TO(yy_cp - 1);
1215 (yy_c_buf_p) = yy_cp -= 1;
1216 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1219 append_string(zconftext, zconfleng);
1220 zconflval.string = text;
1221 return T_WORD_QUOTE;
1227 append_string(zconftext, zconfleng);
1231 /* rule 25 can match eol */
1232 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1233 YY_LINENO_REWIND_TO(yy_cp - 1);
1234 (yy_c_buf_p) = yy_cp -= 1;
1235 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1238 append_string(zconftext + 1, zconfleng - 1);
1239 zconflval.string = text;
1240 return T_WORD_QUOTE;
1246 append_string(zconftext + 1, zconfleng - 1);
1252 if (str == zconftext[0]) {
1254 zconflval.string = text;
1255 return T_WORD_QUOTE;
1257 append_string(zconftext, 1);
1261 /* rule 28 can match eol */
1264 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
1265 current_file->lineno++;
1270 case YY_STATE_EOF(STRING):
1280 for (i = 0; i < zconfleng; i++) {
1281 if (zconftext[i] == '\t')
1288 if (ts < first_ts) {
1294 append_string(" ", 8);
1297 append_string(" ", ts);
1302 /* rule 30 can match eol */
1303 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1304 YY_LINENO_REWIND_TO(yy_cp - 1);
1305 (yy_c_buf_p) = yy_cp -= 1;
1306 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1309 current_file->lineno++;
1315 /* rule 31 can match eol */
1318 current_file->lineno++;
1319 append_string("\n", 1);
1326 if ((zconftext[zconfleng-1] != ' ') && (zconftext[zconfleng-1] != '\t'))
1330 append_string(zconftext, zconfleng);
1335 case YY_STATE_EOF(HELP):
1342 case YY_STATE_EOF(INITIAL):
1343 case YY_STATE_EOF(COMMAND):
1355 YY_FATAL_ERROR( "flex scanner jammed" );
1358 case YY_END_OF_BUFFER:
1360 /* Amount of text matched not including the EOB char. */
1361 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1363 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1364 *yy_cp = (yy_hold_char);
1365 YY_RESTORE_YY_MORE_OFFSET
1367 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1369 /* We're scanning a new file or input source. It's
1370 * possible that this happened because the user
1371 * just pointed zconfin at a new source and called
1372 * zconflex(). If so, then we have to assure
1373 * consistency between YY_CURRENT_BUFFER and our
1374 * globals. Here is the right place to do so, because
1375 * this is the first action (other than possibly a
1376 * back-up) that will match for the new input source.
1378 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1379 YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
1380 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1383 /* Note that here we test for yy_c_buf_p "<=" to the position
1384 * of the first EOB in the buffer, since yy_c_buf_p will
1385 * already have been incremented past the NUL character
1386 * (since all states make transitions on EOB to the
1387 * end-of-buffer state). Contrast this with the test
1390 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1391 { /* This was really a NUL. */
1392 yy_state_type yy_next_state;
1394 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1396 yy_current_state = yy_get_previous_state( );
1398 /* Okay, we're now positioned to make the NUL
1399 * transition. We couldn't have
1400 * yy_get_previous_state() go ahead and do it
1401 * for us because it doesn't know how to deal
1402 * with the possibility of jamming (and we don't
1403 * want to build jamming into it because then it
1404 * will run more slowly).
1407 yy_next_state = yy_try_NUL_trans( yy_current_state );
1409 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1411 if ( yy_next_state )
1413 /* Consume the NUL. */
1414 yy_cp = ++(yy_c_buf_p);
1415 yy_current_state = yy_next_state;
1421 yy_cp = (yy_c_buf_p);
1422 goto yy_find_action;
1426 else switch ( yy_get_next_buffer( ) )
1428 case EOB_ACT_END_OF_FILE:
1430 (yy_did_buffer_switch_on_eof) = 0;
1434 /* Note: because we've taken care in
1435 * yy_get_next_buffer() to have set up
1436 * zconftext, we can now set up
1437 * yy_c_buf_p so that if some total
1438 * hoser (like flex itself) wants to
1439 * call the scanner after we return the
1440 * YY_NULL, it'll still work - another
1441 * YY_NULL will get returned.
1443 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1445 yy_act = YY_STATE_EOF(YY_START);
1451 if ( ! (yy_did_buffer_switch_on_eof) )
1457 case EOB_ACT_CONTINUE_SCAN:
1459 (yytext_ptr) + yy_amount_of_matched_text;
1461 yy_current_state = yy_get_previous_state( );
1463 yy_cp = (yy_c_buf_p);
1464 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1467 case EOB_ACT_LAST_MATCH:
1469 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1471 yy_current_state = yy_get_previous_state( );
1473 yy_cp = (yy_c_buf_p);
1474 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1475 goto yy_find_action;
1482 "fatal flex scanner internal error--no action found" );
1483 } /* end of action switch */
1484 } /* end of scanning one token */
1485 } /* end of user's declarations */
1486 } /* end of zconflex */
1488 /* yy_get_next_buffer - try to read in a new buffer
1490 * Returns a code representing an action:
1491 * EOB_ACT_LAST_MATCH -
1492 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1493 * EOB_ACT_END_OF_FILE - end of file
1495 static int yy_get_next_buffer (void)
1497 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1498 register char *source = (yytext_ptr);
1499 register int number_to_move, i;
1502 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1504 "fatal flex scanner internal error--end of buffer missed" );
1506 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1507 { /* Don't try to fill the buffer, so this is an EOF. */
1508 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1510 /* We matched a single character, the EOB, so
1511 * treat this as a final EOF.
1513 return EOB_ACT_END_OF_FILE;
1518 /* We matched some text prior to the EOB, first
1521 return EOB_ACT_LAST_MATCH;
1525 /* Try to read more data. */
1527 /* First move last chars to start of buffer. */
1528 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1530 for ( i = 0; i < number_to_move; ++i )
1531 *(dest++) = *(source++);
1533 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1534 /* don't do the read, it's not guaranteed to return an EOF,
1537 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1541 yy_size_t num_to_read =
1542 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1544 while ( num_to_read <= 0 )
1545 { /* Not enough room in the buffer - grow it. */
1547 /* just a shorter name for the current buffer */
1548 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1550 int yy_c_buf_p_offset =
1551 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1553 if ( b->yy_is_our_buffer )
1555 yy_size_t new_size = b->yy_buf_size * 2;
1557 if ( new_size <= 0 )
1558 b->yy_buf_size += b->yy_buf_size / 8;
1560 b->yy_buf_size *= 2;
1562 b->yy_ch_buf = (char *)
1563 /* Include room in for 2 EOB chars. */
1564 zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1567 /* Can't grow it, we don't own it. */
1570 if ( ! b->yy_ch_buf )
1572 "fatal error - scanner input buffer overflow" );
1574 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1576 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1581 if ( num_to_read > YY_READ_BUF_SIZE )
1582 num_to_read = YY_READ_BUF_SIZE;
1584 /* Read in more data. */
1585 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1586 (yy_n_chars), num_to_read );
1588 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1591 if ( (yy_n_chars) == 0 )
1593 if ( number_to_move == YY_MORE_ADJ )
1595 ret_val = EOB_ACT_END_OF_FILE;
1596 zconfrestart(zconfin );
1601 ret_val = EOB_ACT_LAST_MATCH;
1602 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1603 YY_BUFFER_EOF_PENDING;
1608 ret_val = EOB_ACT_CONTINUE_SCAN;
1610 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1611 /* Extend the array by 50%, plus the number we really need. */
1612 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1613 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) zconfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1614 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1615 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1618 (yy_n_chars) += number_to_move;
1619 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1620 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1622 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1627 /* yy_get_previous_state - get the state just before the EOB char was reached */
1629 static yy_state_type yy_get_previous_state (void)
1631 register yy_state_type yy_current_state;
1632 register char *yy_cp;
1634 yy_current_state = (yy_start);
1636 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1638 yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
1641 return yy_current_state;
1644 /* yy_try_NUL_trans - try to make a transition on the NUL character
1647 * next_state = yy_try_NUL_trans( current_state );
1649 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1651 register int yy_is_jam;
1653 yy_current_state = yy_nxt[yy_current_state][1];
1654 yy_is_jam = (yy_current_state <= 0);
1656 return yy_is_jam ? 0 : yy_current_state;
1659 static void yyunput (int c, register char * yy_bp )
1661 register char *yy_cp;
1663 yy_cp = (yy_c_buf_p);
1665 /* undo effects of setting up zconftext */
1666 *yy_cp = (yy_hold_char);
1668 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1669 { /* need to shift things up to make room */
1670 /* +2 for EOB chars. */
1671 register yy_size_t number_to_move = (yy_n_chars) + 2;
1672 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1673 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1674 register char *source =
1675 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1677 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1678 *--dest = *--source;
1680 yy_cp += (int) (dest - source);
1681 yy_bp += (int) (dest - source);
1682 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1683 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1685 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1686 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1689 *--yy_cp = (char) c;
1691 (yytext_ptr) = yy_bp;
1692 (yy_hold_char) = *yy_cp;
1693 (yy_c_buf_p) = yy_cp;
1698 static int yyinput (void)
1700 static int input (void)
1706 *(yy_c_buf_p) = (yy_hold_char);
1708 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1710 /* yy_c_buf_p now points to the character we want to return.
1711 * If this occurs *before* the EOB characters, then it's a
1712 * valid NUL; if not, then we've hit the end of the buffer.
1714 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1715 /* This was really a NUL. */
1716 *(yy_c_buf_p) = '\0';
1719 { /* need more input */
1720 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1723 switch ( yy_get_next_buffer( ) )
1725 case EOB_ACT_LAST_MATCH:
1726 /* This happens because yy_g_n_b()
1727 * sees that we've accumulated a
1728 * token and flags that we need to
1729 * try matching the token before
1730 * proceeding. But for input(),
1731 * there's no matching to consider.
1732 * So convert the EOB_ACT_LAST_MATCH
1733 * to EOB_ACT_END_OF_FILE.
1736 /* Reset buffer status. */
1737 zconfrestart(zconfin );
1741 case EOB_ACT_END_OF_FILE:
1746 if ( ! (yy_did_buffer_switch_on_eof) )
1755 case EOB_ACT_CONTINUE_SCAN:
1756 (yy_c_buf_p) = (yytext_ptr) + offset;
1762 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1763 *(yy_c_buf_p) = '\0'; /* preserve zconftext */
1764 (yy_hold_char) = *++(yy_c_buf_p);
1768 #endif /* ifndef YY_NO_INPUT */
1770 /** Immediately switch to a different input stream.
1771 * @param input_file A readable stream.
1773 * @note This function does not reset the start condition to @c INITIAL .
1775 void zconfrestart (FILE * input_file )
1778 if ( ! YY_CURRENT_BUFFER ){
1779 zconfensure_buffer_stack ();
1780 YY_CURRENT_BUFFER_LVALUE =
1781 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1784 zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
1785 zconf_load_buffer_state( );
1788 /** Switch to a different input buffer.
1789 * @param new_buffer The new input buffer.
1792 void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1795 /* TODO. We should be able to replace this entire function body
1797 * zconfpop_buffer_state();
1798 * zconfpush_buffer_state(new_buffer);
1800 zconfensure_buffer_stack ();
1801 if ( YY_CURRENT_BUFFER == new_buffer )
1804 if ( YY_CURRENT_BUFFER )
1806 /* Flush out information for old buffer. */
1807 *(yy_c_buf_p) = (yy_hold_char);
1808 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1809 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1812 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1813 zconf_load_buffer_state( );
1815 /* We don't actually know whether we did this switch during
1816 * EOF (zconfwrap()) processing, but the only time this flag
1817 * is looked at is after zconfwrap() is called, so it's safe
1818 * to go ahead and always set it.
1820 (yy_did_buffer_switch_on_eof) = 1;
1823 static void zconf_load_buffer_state (void)
1825 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1826 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1827 zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1828 (yy_hold_char) = *(yy_c_buf_p);
1831 /** Allocate and initialize an input buffer state.
1832 * @param file A readable stream.
1833 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1835 * @return the allocated buffer state.
1837 YY_BUFFER_STATE zconf_create_buffer (FILE * file, int size )
1841 b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
1843 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1845 b->yy_buf_size = size;
1847 /* yy_ch_buf has to be 2 characters longer than the size given because
1848 * we need to put in 2 end-of-buffer characters.
1850 b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2 );
1851 if ( ! b->yy_ch_buf )
1852 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1854 b->yy_is_our_buffer = 1;
1856 zconf_init_buffer(b,file );
1861 /** Destroy the buffer.
1862 * @param b a buffer created with zconf_create_buffer()
1865 void zconf_delete_buffer (YY_BUFFER_STATE b )
1871 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1872 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1874 if ( b->yy_is_our_buffer )
1875 zconffree((void *) b->yy_ch_buf );
1877 zconffree((void *) b );
1880 /* Initializes or reinitializes a buffer.
1881 * This function is sometimes called more than once on the same buffer,
1882 * such as during a zconfrestart() or at EOF.
1884 static void zconf_init_buffer (YY_BUFFER_STATE b, FILE * file )
1889 zconf_flush_buffer(b );
1891 b->yy_input_file = file;
1892 b->yy_fill_buffer = 1;
1894 /* If b is the current buffer, then zconf_init_buffer was _probably_
1895 * called from zconfrestart() or through yy_get_next_buffer.
1896 * In that case, we don't want to reset the lineno or column.
1898 if (b != YY_CURRENT_BUFFER){
1899 b->yy_bs_lineno = 1;
1900 b->yy_bs_column = 0;
1903 b->yy_is_interactive = 0;
1908 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1909 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1912 void zconf_flush_buffer (YY_BUFFER_STATE b )
1919 /* We always need two end-of-buffer characters. The first causes
1920 * a transition to the end-of-buffer state. The second causes
1921 * a jam in that state.
1923 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1924 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1926 b->yy_buf_pos = &b->yy_ch_buf[0];
1929 b->yy_buffer_status = YY_BUFFER_NEW;
1931 if ( b == YY_CURRENT_BUFFER )
1932 zconf_load_buffer_state( );
1935 /** Pushes the new state onto the stack. The new state becomes
1936 * the current state. This function will allocate the stack
1938 * @param new_buffer The new state.
1941 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
1943 if (new_buffer == NULL)
1946 zconfensure_buffer_stack();
1948 /* This block is copied from zconf_switch_to_buffer. */
1949 if ( YY_CURRENT_BUFFER )
1951 /* Flush out information for old buffer. */
1952 *(yy_c_buf_p) = (yy_hold_char);
1953 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1954 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1957 /* Only push if top exists. Otherwise, replace top. */
1958 if (YY_CURRENT_BUFFER)
1959 (yy_buffer_stack_top)++;
1960 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1962 /* copied from zconf_switch_to_buffer. */
1963 zconf_load_buffer_state( );
1964 (yy_did_buffer_switch_on_eof) = 1;
1967 /** Removes and deletes the top of the stack, if present.
1968 * The next element becomes the new top.
1971 void zconfpop_buffer_state (void)
1973 if (!YY_CURRENT_BUFFER)
1976 zconf_delete_buffer(YY_CURRENT_BUFFER );
1977 YY_CURRENT_BUFFER_LVALUE = NULL;
1978 if ((yy_buffer_stack_top) > 0)
1979 --(yy_buffer_stack_top);
1981 if (YY_CURRENT_BUFFER) {
1982 zconf_load_buffer_state( );
1983 (yy_did_buffer_switch_on_eof) = 1;
1987 /* Allocates the stack if it does not exist.
1988 * Guarantees space for at least one push.
1990 static void zconfensure_buffer_stack (void)
1992 yy_size_t num_to_alloc;
1994 if (!(yy_buffer_stack)) {
1996 /* First allocation is just for 2 elements, since we don't know if this
1997 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1998 * immediate realloc on the next call.
2001 (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
2002 (num_to_alloc * sizeof(struct yy_buffer_state*)
2004 if ( ! (yy_buffer_stack) )
2005 YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
2007 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2009 (yy_buffer_stack_max) = num_to_alloc;
2010 (yy_buffer_stack_top) = 0;
2014 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2016 /* Increase the buffer to prepare for a possible push. */
2017 int grow_size = 8 /* arbitrary grow size */;
2019 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2020 (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
2022 num_to_alloc * sizeof(struct yy_buffer_state*)
2024 if ( ! (yy_buffer_stack) )
2025 YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
2027 /* zero only the new slots.*/
2028 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2029 (yy_buffer_stack_max) = num_to_alloc;
2033 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2034 * @param base the character buffer
2035 * @param size the size in bytes of the character buffer
2037 * @return the newly allocated buffer state object.
2039 YY_BUFFER_STATE zconf_scan_buffer (char * base, yy_size_t size )
2044 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2045 base[size-1] != YY_END_OF_BUFFER_CHAR )
2046 /* They forgot to leave room for the EOB's. */
2049 b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
2051 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
2053 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2054 b->yy_buf_pos = b->yy_ch_buf = base;
2055 b->yy_is_our_buffer = 0;
2056 b->yy_input_file = 0;
2057 b->yy_n_chars = b->yy_buf_size;
2058 b->yy_is_interactive = 0;
2060 b->yy_fill_buffer = 0;
2061 b->yy_buffer_status = YY_BUFFER_NEW;
2063 zconf_switch_to_buffer(b );
2068 /** Setup the input buffer state to scan a string. The next call to zconflex() will
2069 * scan from a @e copy of @a str.
2070 * @param yystr a NUL-terminated string to scan
2072 * @return the newly allocated buffer state object.
2073 * @note If you want to scan bytes that may contain NUL values, then use
2074 * zconf_scan_bytes() instead.
2076 YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
2079 return zconf_scan_bytes(yystr,strlen(yystr) );
2082 /** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
2083 * scan from a @e copy of @a bytes.
2084 * @param yybytes the byte buffer to scan
2085 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2087 * @return the newly allocated buffer state object.
2089 YY_BUFFER_STATE zconf_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
2096 /* Get memory for full buffer, including space for trailing EOB's. */
2097 n = _yybytes_len + 2;
2098 buf = (char *) zconfalloc(n );
2100 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
2102 for ( i = 0; i < _yybytes_len; ++i )
2103 buf[i] = yybytes[i];
2105 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2107 b = zconf_scan_buffer(buf,n );
2109 YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
2111 /* It's okay to grow etc. this buffer, and we should throw it
2112 * away when we're done.
2114 b->yy_is_our_buffer = 1;
2119 #ifndef YY_EXIT_FAILURE
2120 #define YY_EXIT_FAILURE 2
2123 static void yy_fatal_error (yyconst char* msg )
2125 (void) fprintf( stderr, "%s\n", msg );
2126 exit( YY_EXIT_FAILURE );
2129 /* Redefine yyless() so it works in section 3 code. */
2135 /* Undo effects of setting up zconftext. */ \
2136 int yyless_macro_arg = (n); \
2137 YY_LESS_LINENO(yyless_macro_arg);\
2138 zconftext[zconfleng] = (yy_hold_char); \
2139 (yy_c_buf_p) = zconftext + yyless_macro_arg; \
2140 (yy_hold_char) = *(yy_c_buf_p); \
2141 *(yy_c_buf_p) = '\0'; \
2142 zconfleng = yyless_macro_arg; \
2146 /* Accessor methods (get/set functions) to struct members. */
2148 /** Get the current line number.
2151 int zconfget_lineno (void)
2157 /** Get the input stream.
2160 FILE *zconfget_in (void)
2165 /** Get the output stream.
2168 FILE *zconfget_out (void)
2173 /** Get the length of the current token.
2176 yy_size_t zconfget_leng (void)
2181 /** Get the current token.
2185 char *zconfget_text (void)
2190 /** Set the current line number.
2191 * @param line_number
2194 void zconfset_lineno (int line_number )
2197 zconflineno = line_number;
2200 /** Set the input stream. This does not discard the current
2202 * @param in_str A readable stream.
2204 * @see zconf_switch_to_buffer
2206 void zconfset_in (FILE * in_str )
2211 void zconfset_out (FILE * out_str )
2213 zconfout = out_str ;
2216 int zconfget_debug (void)
2218 return zconf_flex_debug;
2221 void zconfset_debug (int bdebug )
2223 zconf_flex_debug = bdebug ;
2226 static int yy_init_globals (void)
2228 /* Initialization is the same as for the non-reentrant scanner.
2229 * This function is called from zconflex_destroy(), so don't allocate here.
2232 (yy_buffer_stack) = 0;
2233 (yy_buffer_stack_top) = 0;
2234 (yy_buffer_stack_max) = 0;
2235 (yy_c_buf_p) = (char *) 0;
2239 /* Defined in main.c */
2244 zconfin = (FILE *) 0;
2245 zconfout = (FILE *) 0;
2248 /* For future reference: Set errno on error, since we are called by
2254 /* zconflex_destroy is for both reentrant and non-reentrant scanners. */
2255 int zconflex_destroy (void)
2258 /* Pop the buffer stack, destroying each element. */
2259 while(YY_CURRENT_BUFFER){
2260 zconf_delete_buffer(YY_CURRENT_BUFFER );
2261 YY_CURRENT_BUFFER_LVALUE = NULL;
2262 zconfpop_buffer_state();
2265 /* Destroy the stack itself. */
2266 zconffree((yy_buffer_stack) );
2267 (yy_buffer_stack) = NULL;
2269 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2270 * zconflex() is called, initialization will occur. */
2277 * Internal utility routines.
2281 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2284 for ( i = 0; i < n; ++i )
2289 #ifdef YY_NEED_STRLEN
2290 static int yy_flex_strlen (yyconst char * s )
2293 for ( n = 0; s[n]; ++n )
2300 void *zconfalloc (yy_size_t size )
2302 return (void *) malloc( size );
2305 void *zconfrealloc (void * ptr, yy_size_t size )
2307 /* The cast to (char *) in the following accommodates both
2308 * implementations that use char* generic pointers, and those
2309 * that use void* generic pointers. It works with the latter
2310 * because both ANSI C and C++ allow castless assignment from
2311 * any pointer type to void*, and deal with argument conversions
2312 * as though doing an assignment.
2314 return (void *) realloc( (char *) ptr, size );
2317 void zconffree (void * ptr )
2319 free( (char *) ptr ); /* see zconfrealloc() for (char *) cast */
2322 #define YYTABLES_NAME "yytables"
2324 void zconf_starthelp(void)
2327 last_ts = first_ts = 0;
2331 static void zconf_endhelp(void)
2333 zconflval.string = text;
2338 * Try to open specified file with following names:
2341 * The latter is used when srctree is separate from objtree
2342 * when compiling the kernel.
2343 * Return NULL if file is not found.
2345 FILE *zconf_fopen(const char *name)
2347 char *env, fullname[PATH_MAX+1];
2350 f = fopen(name, "r");
2351 if (!f && name != NULL && name[0] != '/') {
2352 env = getenv(SRCTREE);
2354 sprintf(fullname, "%s/%s", env, name);
2355 f = fopen(fullname, "r");
2361 void zconf_initscan(const char *name)
2363 zconfin = zconf_fopen(name);
2365 printf("can't find file %s\n", name);
2369 current_buf = xmalloc(sizeof(*current_buf));
2370 memset(current_buf, 0, sizeof(*current_buf));
2372 current_file = file_lookup(name);
2373 current_file->lineno = 1;
2376 void zconf_nextfile(const char *name)
2379 struct file *file = file_lookup(name);
2380 struct buffer *buf = xmalloc(sizeof(*buf));
2381 memset(buf, 0, sizeof(*buf));
2383 current_buf->state = YY_CURRENT_BUFFER;
2384 zconfin = zconf_fopen(file->name);
2386 printf("%s:%d: can't open file \"%s\"\n",
2387 zconf_curname(), zconf_lineno(), file->name);
2390 zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
2391 buf->parent = current_buf;
2394 for (iter = current_file->parent; iter; iter = iter->parent ) {
2395 if (!strcmp(current_file->name,iter->name) ) {
2396 printf("%s:%d: recursive inclusion detected. "
2397 "Inclusion path:\n current file : '%s'\n",
2398 zconf_curname(), zconf_lineno(),
2400 iter = current_file->parent;
2402 strcmp(iter->name,current_file->name)) {
2403 printf(" included from: '%s:%d'\n",
2404 iter->name, iter->lineno-1);
2405 iter = iter->parent;
2408 printf(" included from: '%s:%d'\n",
2409 iter->name, iter->lineno+1);
2414 file->parent = current_file;
2415 current_file = file;
2418 void zconf_nextfiles(const char *wildcard)
2424 if (glob(wildcard, 0, NULL, &g) != 0) {
2427 if (g.gl_pathv == NULL) {
2432 /* working through files backwards, since
2433 * we're first pushing them on a stack
2434 * before actually handling them.
2436 for (i = g.gl_pathc; i > 0; i--) {
2437 w = &g.gl_pathv[i - 1];
2444 static void zconf_endfile(void)
2446 struct buffer *parent;
2448 current_file = current_file->parent;
2450 parent = current_buf->parent;
2453 zconf_delete_buffer(YY_CURRENT_BUFFER);
2454 zconf_switch_to_buffer(parent->state);
2457 current_buf = parent;
2460 int zconf_lineno(void)
2462 return current_pos.lineno;
2465 const char *zconf_curname(void)
2467 return current_pos.file ? current_pos.file->name : "<none>";