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 37
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. */
163 #define YY_BUF_SIZE 16384
166 /* The state buf must be large enough to hold one state per character in the main buffer.
168 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
170 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
171 #define YY_TYPEDEF_YY_BUFFER_STATE
172 typedef struct yy_buffer_state *YY_BUFFER_STATE;
175 #ifndef YY_TYPEDEF_YY_SIZE_T
176 #define YY_TYPEDEF_YY_SIZE_T
177 typedef size_t yy_size_t;
180 extern yy_size_t zconfleng;
182 extern FILE *zconfin, *zconfout;
184 #define EOB_ACT_CONTINUE_SCAN 0
185 #define EOB_ACT_END_OF_FILE 1
186 #define EOB_ACT_LAST_MATCH 2
188 #define YY_LESS_LINENO(n)
190 /* Return all but the first "n" matched characters back to the input stream. */
194 /* Undo effects of setting up zconftext. */ \
195 int yyless_macro_arg = (n); \
196 YY_LESS_LINENO(yyless_macro_arg);\
197 *yy_cp = (yy_hold_char); \
198 YY_RESTORE_YY_MORE_OFFSET \
199 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
200 YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
204 #define unput(c) yyunput( c, (yytext_ptr) )
206 #ifndef YY_STRUCT_YY_BUFFER_STATE
207 #define YY_STRUCT_YY_BUFFER_STATE
208 struct yy_buffer_state
212 char *yy_ch_buf; /* input buffer */
213 char *yy_buf_pos; /* current position in input buffer */
215 /* Size of input buffer in bytes, not including room for EOB
218 yy_size_t yy_buf_size;
220 /* Number of characters read into yy_ch_buf, not including EOB
223 yy_size_t yy_n_chars;
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
229 int yy_is_our_buffer;
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
236 int yy_is_interactive;
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
244 int yy_bs_lineno; /**< The line count. */
245 int yy_bs_column; /**< The column count. */
247 /* Whether to try to fill the input buffer when we reach the
252 int yy_buffer_status;
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.
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.
266 #define YY_BUFFER_EOF_PENDING 2
269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
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. */
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
280 * Returns the top of the stack, or NULL.
282 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
283 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
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.
289 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
291 /* yy_hold_char holds the character lost when zconftext is formed. */
292 static char yy_hold_char;
293 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
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 */
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 ...
304 static int yy_did_buffer_switch_on_eof;
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 );
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 );
318 #define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
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,yy_size_t len );
324 void *zconfalloc (yy_size_t );
325 void *zconfrealloc (void *,yy_size_t );
326 void zconffree (void * );
328 #define yy_new_buffer zconf_create_buffer
330 #define yy_set_interactive(is_interactive) \
332 if ( ! YY_CURRENT_BUFFER ){ \
333 zconfensure_buffer_stack (); \
334 YY_CURRENT_BUFFER_LVALUE = \
335 zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
337 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
340 #define yy_set_bol(at_bol) \
342 if ( ! YY_CURRENT_BUFFER ){\
343 zconfensure_buffer_stack (); \
344 YY_CURRENT_BUFFER_LVALUE = \
345 zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
347 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
350 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
352 /* Begin user sect3 */
354 #define zconfwrap() 1
355 #define YY_SKIP_YYWRAP
357 typedef unsigned char YY_CHAR;
359 FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
361 typedef int yy_state_type;
363 extern int zconflineno;
367 extern char *zconftext;
368 #define yytext_ptr zconftext
369 static yyconst flex_int16_t yy_nxt[][17] =
372 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
377 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
378 12, 12, 12, 12, 12, 12, 12
382 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
383 12, 12, 12, 12, 12, 12, 12
387 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
388 16, 16, 16, 18, 16, 16, 16
392 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
393 16, 16, 16, 18, 16, 16, 16
398 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
399 19, 19, 19, 19, 19, 19, 19
403 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
404 19, 19, 19, 19, 19, 19, 19
408 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
409 22, 22, 22, 22, 22, 25, 22
413 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
414 22, 22, 22, 22, 22, 25, 22
418 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
419 33, 34, 35, 35, 36, 37, 38
424 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
425 33, 34, 35, 35, 36, 37, 38
429 -11, -11, -11, -11, -11, -11, -11, -11, -11, -11,
430 -11, -11, -11, -11, -11, -11, -11
434 11, -12, -12, -12, -12, -12, -12, -12, -12, -12,
435 -12, -12, -12, -12, -12, -12, -12
439 11, -13, 39, 40, -13, -13, 41, -13, -13, -13,
440 -13, -13, -13, -13, -13, -13, -13
444 11, -14, -14, -14, -14, -14, -14, -14, -14, -14,
445 -14, -14, -14, -14, -14, -14, -14
450 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
451 42, 42, 42, 42, 42, 42, 42
455 11, -16, -16, -16, -16, -16, -16, -16, -16, -16,
456 -16, -16, -16, -16, -16, -16, -16
460 11, -17, -17, -17, -17, -17, -17, -17, -17, -17,
461 -17, -17, -17, -17, -17, -17, -17
465 11, -18, -18, -18, -18, -18, -18, -18, -18, -18,
466 -18, -18, -18, 44, -18, -18, -18
470 11, 45, 45, -19, 45, 45, 45, 45, 45, 45,
471 45, 45, 45, 45, 45, 45, 45
476 11, -20, 46, 47, -20, -20, -20, -20, -20, -20,
477 -20, -20, -20, -20, -20, -20, -20
481 11, 48, -21, -21, 48, 48, 48, 48, 48, 48,
482 48, 48, 48, 48, 48, 48, 48
486 11, 49, 49, 50, 49, -22, 49, 49, -22, 49,
487 49, 49, 49, 49, 49, -22, 49
491 11, -23, -23, -23, -23, -23, -23, -23, -23, -23,
492 -23, -23, -23, -23, -23, -23, -23
496 11, -24, -24, -24, -24, -24, -24, -24, -24, -24,
497 -24, -24, -24, -24, -24, -24, -24
502 11, 51, 51, 52, 51, 51, 51, 51, 51, 51,
503 51, 51, 51, 51, 51, 51, 51
507 11, -26, -26, -26, -26, -26, -26, -26, -26, -26,
508 -26, -26, -26, -26, -26, -26, -26
512 11, -27, -27, -27, -27, -27, -27, -27, -27, -27,
513 -27, -27, -27, -27, -27, -27, -27
517 11, -28, -28, -28, -28, -28, -28, -28, -28, -28,
518 -28, -28, -28, -28, 53, -28, -28
522 11, -29, -29, -29, -29, -29, -29, -29, -29, -29,
523 -29, -29, -29, -29, -29, -29, -29
528 11, 54, 54, -30, 54, 54, 54, 54, 54, 54,
529 54, 54, 54, 54, 54, 54, 54
533 11, -31, -31, -31, -31, -31, -31, 55, -31, -31,
534 -31, -31, -31, -31, -31, -31, -31
538 11, -32, -32, -32, -32, -32, -32, -32, -32, -32,
539 -32, -32, -32, -32, -32, -32, -32
543 11, -33, -33, -33, -33, -33, -33, -33, -33, -33,
544 -33, -33, -33, -33, -33, -33, -33
548 11, -34, -34, -34, -34, -34, -34, -34, -34, -34,
549 -34, 56, 57, 57, -34, -34, -34
554 11, -35, -35, -35, -35, -35, -35, -35, -35, -35,
555 -35, 57, 57, 57, -35, -35, -35
559 11, -36, -36, -36, -36, -36, -36, -36, -36, -36,
560 -36, -36, -36, -36, -36, -36, -36
564 11, -37, -37, 58, -37, -37, -37, -37, -37, -37,
565 -37, -37, -37, -37, -37, -37, -37
569 11, -38, -38, -38, -38, -38, -38, -38, -38, -38,
570 -38, -38, -38, -38, -38, -38, 59
574 11, -39, 39, 40, -39, -39, 41, -39, -39, -39,
575 -39, -39, -39, -39, -39, -39, -39
580 11, -40, -40, -40, -40, -40, -40, -40, -40, -40,
581 -40, -40, -40, -40, -40, -40, -40
585 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
586 42, 42, 42, 42, 42, 42, 42
590 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
591 42, 42, 42, 42, 42, 42, 42
595 11, -43, -43, -43, -43, -43, -43, -43, -43, -43,
596 -43, -43, -43, -43, -43, -43, -43
600 11, -44, -44, -44, -44, -44, -44, -44, -44, -44,
601 -44, -44, -44, 44, -44, -44, -44
606 11, 45, 45, -45, 45, 45, 45, 45, 45, 45,
607 45, 45, 45, 45, 45, 45, 45
611 11, -46, 46, 47, -46, -46, -46, -46, -46, -46,
612 -46, -46, -46, -46, -46, -46, -46
616 11, 48, -47, -47, 48, 48, 48, 48, 48, 48,
617 48, 48, 48, 48, 48, 48, 48
621 11, -48, -48, -48, -48, -48, -48, -48, -48, -48,
622 -48, -48, -48, -48, -48, -48, -48
626 11, 49, 49, 50, 49, -49, 49, 49, -49, 49,
627 49, 49, 49, 49, 49, -49, 49
632 11, -50, -50, -50, -50, -50, -50, -50, -50, -50,
633 -50, -50, -50, -50, -50, -50, -50
637 11, -51, -51, 52, -51, -51, -51, -51, -51, -51,
638 -51, -51, -51, -51, -51, -51, -51
642 11, -52, -52, -52, -52, -52, -52, -52, -52, -52,
643 -52, -52, -52, -52, -52, -52, -52
647 11, -53, -53, -53, -53, -53, -53, -53, -53, -53,
648 -53, -53, -53, -53, -53, -53, -53
652 11, 54, 54, -54, 54, 54, 54, 54, 54, 54,
653 54, 54, 54, 54, 54, 54, 54
658 11, -55, -55, -55, -55, -55, -55, -55, -55, -55,
659 -55, -55, -55, -55, -55, -55, -55
663 11, -56, -56, -56, -56, -56, -56, -56, -56, -56,
664 -56, 60, 57, 57, -56, -56, -56
668 11, -57, -57, -57, -57, -57, -57, -57, -57, -57,
669 -57, 57, 57, 57, -57, -57, -57
673 11, -58, -58, -58, -58, -58, -58, -58, -58, -58,
674 -58, -58, -58, -58, -58, -58, -58
678 11, -59, -59, -59, -59, -59, -59, -59, -59, -59,
679 -59, -59, -59, -59, -59, -59, -59
684 11, -60, -60, -60, -60, -60, -60, -60, -60, -60,
685 -60, 57, 57, 57, -60, -60, -60
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[] );
695 /* Done after the current pattern has been matched and before the
696 * corresponding action - sets up zconftext.
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; \
703 (yy_c_buf_p) = yy_cp;
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. */
711 flex_int32_t yy_verify;
714 static yyconst flex_int16_t yy_accept[61] =
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
724 static yyconst flex_int32_t yy_ec[256] =
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,
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,
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,
756 extern int zconf_flex_debug;
757 int zconf_flex_debug = 0;
759 /* The intent behind this definition is that it'll catch
760 * any uses of REJECT which flex missed.
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
767 #define YY_NO_INPUT 1
770 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
771 * Released under the terms of the GNU GPL v2.0.
784 #define START_STRSIZE 16
792 static int text_size, text_asize;
795 struct buffer *parent;
796 YY_BUFFER_STATE state;
799 struct buffer *current_buf;
801 static int last_ts, first_ts;
803 static void zconf_endhelp(void);
804 static void zconf_endfile(void);
806 static void new_string(void)
808 text = xmalloc(START_STRSIZE);
809 text_asize = START_STRSIZE;
814 static void append_string(const char *str, int size)
816 int new_size = text_size + size + 1;
817 if (new_size > text_asize) {
818 new_size += START_STRSIZE - 1;
819 new_size &= -START_STRSIZE;
820 text = realloc(text, new_size);
821 text_asize = new_size;
823 memcpy(text + text_size, str, size);
828 static void alloc_string(const char *str, int size)
830 text = xmalloc(size + 1);
831 memcpy(text, str, size);
841 #ifndef YY_NO_UNISTD_H
842 /* Special case for "unistd.h", since it is non-ANSI. We include it way
843 * down here because we want the user's section 1 to have been scanned first.
844 * The user has a chance to override it with an option.
849 #ifndef YY_EXTRA_TYPE
850 #define YY_EXTRA_TYPE void *
853 static int yy_init_globals (void );
855 /* Accessor methods to globals.
856 These are made visible to non-reentrant scanners for convenience. */
858 int zconflex_destroy (void );
860 int zconfget_debug (void );
862 void zconfset_debug (int debug_flag );
864 YY_EXTRA_TYPE zconfget_extra (void );
866 void zconfset_extra (YY_EXTRA_TYPE user_defined );
868 FILE *zconfget_in (void );
870 void zconfset_in (FILE * in_str );
872 FILE *zconfget_out (void );
874 void zconfset_out (FILE * out_str );
876 yy_size_t zconfget_leng (void );
878 char *zconfget_text (void );
880 int zconfget_lineno (void );
882 void zconfset_lineno (int line_number );
884 /* Macros after this point can all be overridden by user definitions in
888 #ifndef YY_SKIP_YYWRAP
890 extern "C" int zconfwrap (void );
892 extern int zconfwrap (void );
896 static void yyunput (int c,char *buf_ptr );
899 static void yy_flex_strncpy (char *,yyconst char *,int );
902 #ifdef YY_NEED_STRLEN
903 static int yy_flex_strlen (yyconst char * );
909 static int yyinput (void );
911 static int input (void );
916 /* Amount of stuff to slurp up with each read. */
917 #ifndef YY_READ_BUF_SIZE
918 #define YY_READ_BUF_SIZE 8192
921 /* Copy whatever the last rule matched to the standard output. */
923 /* This used to be an fputs(), but since the string might contain NUL's,
924 * we now use fwrite().
926 #define ECHO do { if (fwrite( zconftext, zconfleng, 1, zconfout )) {} } while (0)
929 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
930 * is returned in "result".
933 #define YY_INPUT(buf,result,max_size) \
935 while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
937 if( errno != EINTR) \
939 YY_FATAL_ERROR( "input in flex scanner failed" ); \
949 /* No semi-colon after return; correct usage is to write "yyterminate();" -
950 * we don't want an extra ';' after the "return" because that will cause
951 * some compilers to complain about unreachable statements.
954 #define yyterminate() return YY_NULL
957 /* Number of entries by which start-condition stack grows. */
958 #ifndef YY_START_STACK_INCR
959 #define YY_START_STACK_INCR 25
962 /* Report a fatal error. */
963 #ifndef YY_FATAL_ERROR
964 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
967 /* end tables serialization structures and prototypes */
969 /* Default declaration of generated scanner - a define so the user can
970 * easily add parameters.
973 #define YY_DECL_IS_OURS 1
975 extern int zconflex (void);
977 #define YY_DECL int zconflex (void)
978 #endif /* !YY_DECL */
980 /* Code executed at the beginning of each rule, after zconftext and zconfleng
983 #ifndef YY_USER_ACTION
984 #define YY_USER_ACTION
987 /* Code executed at the end of each rule. */
989 #define YY_BREAK break;
992 #define YY_RULE_SETUP \
995 /** The main scanner function which does all the work.
999 register yy_state_type yy_current_state;
1000 register char *yy_cp, *yy_bp;
1001 register int yy_act;
1015 (yy_start) = 1; /* first start state */
1023 if ( ! YY_CURRENT_BUFFER ) {
1024 zconfensure_buffer_stack ();
1025 YY_CURRENT_BUFFER_LVALUE =
1026 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1029 zconf_load_buffer_state( );
1032 while ( 1 ) /* loops until end-of-file is reached */
1034 yy_cp = (yy_c_buf_p);
1036 /* Support of zconftext. */
1037 *yy_cp = (yy_hold_char);
1039 /* yy_bp points to the position in yy_ch_buf of the start of
1044 yy_current_state = (yy_start);
1046 while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)] ]) > 0 )
1049 yy_current_state = -yy_current_state;
1052 yy_act = yy_accept[yy_current_state];
1054 YY_DO_BEFORE_ACTION;
1056 do_action: /* This label is used only to access EOF actions. */
1059 { /* beginning of action switch */
1061 /* rule 1 can match eol */
1063 /* rule 2 can match eol */
1066 current_file->lineno++;
1083 unput(zconftext[0]);
1091 const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1093 current_pos.file = current_file;
1094 current_pos.lineno = current_file->lineno;
1095 if (id && id->flags & TF_COMMAND) {
1099 alloc_string(zconftext, zconfleng);
1100 zconflval.string = text;
1109 /* rule 8 can match eol */
1113 current_file->lineno++;
1128 return T_OPEN_PAREN;
1132 return T_CLOSE_PAREN;
1155 /* rule 17 can match eol */
1157 BEGIN(INITIAL); current_file->lineno++; return T_EOL;
1166 const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1167 if (id && id->flags & TF_PARAM) {
1171 alloc_string(zconftext, zconfleng);
1172 zconflval.string = text;
1181 /* rule 21 can match eol */
1183 current_file->lineno++;
1189 case YY_STATE_EOF(PARAM):
1196 /* rule 23 can match eol */
1197 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1198 (yy_c_buf_p) = yy_cp -= 1;
1199 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1202 append_string(zconftext, zconfleng);
1203 zconflval.string = text;
1204 return T_WORD_QUOTE;
1210 append_string(zconftext, zconfleng);
1214 /* rule 25 can match eol */
1215 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1216 (yy_c_buf_p) = yy_cp -= 1;
1217 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1220 append_string(zconftext + 1, zconfleng - 1);
1221 zconflval.string = text;
1222 return T_WORD_QUOTE;
1228 append_string(zconftext + 1, zconfleng - 1);
1234 if (str == zconftext[0]) {
1236 zconflval.string = text;
1237 return T_WORD_QUOTE;
1239 append_string(zconftext, 1);
1243 /* rule 28 can match eol */
1246 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
1247 current_file->lineno++;
1252 case YY_STATE_EOF(STRING):
1262 for (i = 0; i < zconfleng; i++) {
1263 if (zconftext[i] == '\t')
1270 if (ts < first_ts) {
1276 append_string(" ", 8);
1279 append_string(" ", ts);
1284 /* rule 30 can match eol */
1285 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1286 (yy_c_buf_p) = yy_cp -= 1;
1287 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1290 current_file->lineno++;
1296 /* rule 31 can match eol */
1299 current_file->lineno++;
1300 append_string("\n", 1);
1307 if ((zconftext[zconfleng-1] != ' ') && (zconftext[zconfleng-1] != '\t'))
1311 append_string(zconftext, zconfleng);
1316 case YY_STATE_EOF(HELP):
1323 case YY_STATE_EOF(INITIAL):
1324 case YY_STATE_EOF(COMMAND):
1336 YY_FATAL_ERROR( "flex scanner jammed" );
1339 case YY_END_OF_BUFFER:
1341 /* Amount of text matched not including the EOB char. */
1342 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1344 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1345 *yy_cp = (yy_hold_char);
1346 YY_RESTORE_YY_MORE_OFFSET
1348 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1350 /* We're scanning a new file or input source. It's
1351 * possible that this happened because the user
1352 * just pointed zconfin at a new source and called
1353 * zconflex(). If so, then we have to assure
1354 * consistency between YY_CURRENT_BUFFER and our
1355 * globals. Here is the right place to do so, because
1356 * this is the first action (other than possibly a
1357 * back-up) that will match for the new input source.
1359 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1360 YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
1361 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1364 /* Note that here we test for yy_c_buf_p "<=" to the position
1365 * of the first EOB in the buffer, since yy_c_buf_p will
1366 * already have been incremented past the NUL character
1367 * (since all states make transitions on EOB to the
1368 * end-of-buffer state). Contrast this with the test
1371 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1372 { /* This was really a NUL. */
1373 yy_state_type yy_next_state;
1375 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1377 yy_current_state = yy_get_previous_state( );
1379 /* Okay, we're now positioned to make the NUL
1380 * transition. We couldn't have
1381 * yy_get_previous_state() go ahead and do it
1382 * for us because it doesn't know how to deal
1383 * with the possibility of jamming (and we don't
1384 * want to build jamming into it because then it
1385 * will run more slowly).
1388 yy_next_state = yy_try_NUL_trans( yy_current_state );
1390 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1392 if ( yy_next_state )
1394 /* Consume the NUL. */
1395 yy_cp = ++(yy_c_buf_p);
1396 yy_current_state = yy_next_state;
1402 yy_cp = (yy_c_buf_p);
1403 goto yy_find_action;
1407 else switch ( yy_get_next_buffer( ) )
1409 case EOB_ACT_END_OF_FILE:
1411 (yy_did_buffer_switch_on_eof) = 0;
1415 /* Note: because we've taken care in
1416 * yy_get_next_buffer() to have set up
1417 * zconftext, we can now set up
1418 * yy_c_buf_p so that if some total
1419 * hoser (like flex itself) wants to
1420 * call the scanner after we return the
1421 * YY_NULL, it'll still work - another
1422 * YY_NULL will get returned.
1424 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1426 yy_act = YY_STATE_EOF(YY_START);
1432 if ( ! (yy_did_buffer_switch_on_eof) )
1438 case EOB_ACT_CONTINUE_SCAN:
1440 (yytext_ptr) + yy_amount_of_matched_text;
1442 yy_current_state = yy_get_previous_state( );
1444 yy_cp = (yy_c_buf_p);
1445 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1448 case EOB_ACT_LAST_MATCH:
1450 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1452 yy_current_state = yy_get_previous_state( );
1454 yy_cp = (yy_c_buf_p);
1455 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1456 goto yy_find_action;
1463 "fatal flex scanner internal error--no action found" );
1464 } /* end of action switch */
1465 } /* end of scanning one token */
1466 } /* end of zconflex */
1468 /* yy_get_next_buffer - try to read in a new buffer
1470 * Returns a code representing an action:
1471 * EOB_ACT_LAST_MATCH -
1472 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1473 * EOB_ACT_END_OF_FILE - end of file
1475 static int yy_get_next_buffer (void)
1477 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1478 register char *source = (yytext_ptr);
1479 register int number_to_move, i;
1482 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1484 "fatal flex scanner internal error--end of buffer missed" );
1486 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1487 { /* Don't try to fill the buffer, so this is an EOF. */
1488 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1490 /* We matched a single character, the EOB, so
1491 * treat this as a final EOF.
1493 return EOB_ACT_END_OF_FILE;
1498 /* We matched some text prior to the EOB, first
1501 return EOB_ACT_LAST_MATCH;
1505 /* Try to read more data. */
1507 /* First move last chars to start of buffer. */
1508 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1510 for ( i = 0; i < number_to_move; ++i )
1511 *(dest++) = *(source++);
1513 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1514 /* don't do the read, it's not guaranteed to return an EOF,
1517 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1521 yy_size_t num_to_read =
1522 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1524 while ( num_to_read <= 0 )
1525 { /* Not enough room in the buffer - grow it. */
1527 /* just a shorter name for the current buffer */
1528 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1530 int yy_c_buf_p_offset =
1531 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1533 if ( b->yy_is_our_buffer )
1535 yy_size_t new_size = b->yy_buf_size * 2;
1537 if ( new_size <= 0 )
1538 b->yy_buf_size += b->yy_buf_size / 8;
1540 b->yy_buf_size *= 2;
1542 b->yy_ch_buf = (char *)
1543 /* Include room in for 2 EOB chars. */
1544 zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1547 /* Can't grow it, we don't own it. */
1550 if ( ! b->yy_ch_buf )
1552 "fatal error - scanner input buffer overflow" );
1554 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1556 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1561 if ( num_to_read > YY_READ_BUF_SIZE )
1562 num_to_read = YY_READ_BUF_SIZE;
1564 /* Read in more data. */
1565 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1566 (yy_n_chars), num_to_read );
1568 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1571 if ( (yy_n_chars) == 0 )
1573 if ( number_to_move == YY_MORE_ADJ )
1575 ret_val = EOB_ACT_END_OF_FILE;
1576 zconfrestart(zconfin );
1581 ret_val = EOB_ACT_LAST_MATCH;
1582 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1583 YY_BUFFER_EOF_PENDING;
1588 ret_val = EOB_ACT_CONTINUE_SCAN;
1590 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1591 /* Extend the array by 50%, plus the number we really need. */
1592 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1593 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) zconfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1594 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1595 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1598 (yy_n_chars) += number_to_move;
1599 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1600 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1602 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1607 /* yy_get_previous_state - get the state just before the EOB char was reached */
1609 static yy_state_type yy_get_previous_state (void)
1611 register yy_state_type yy_current_state;
1612 register char *yy_cp;
1614 yy_current_state = (yy_start);
1616 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1618 yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
1621 return yy_current_state;
1624 /* yy_try_NUL_trans - try to make a transition on the NUL character
1627 * next_state = yy_try_NUL_trans( current_state );
1629 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1631 register int yy_is_jam;
1633 yy_current_state = yy_nxt[yy_current_state][1];
1634 yy_is_jam = (yy_current_state <= 0);
1636 return yy_is_jam ? 0 : yy_current_state;
1639 static void yyunput (int c, register char * yy_bp )
1641 register char *yy_cp;
1643 yy_cp = (yy_c_buf_p);
1645 /* undo effects of setting up zconftext */
1646 *yy_cp = (yy_hold_char);
1648 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1649 { /* need to shift things up to make room */
1650 /* +2 for EOB chars. */
1651 register yy_size_t number_to_move = (yy_n_chars) + 2;
1652 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1653 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1654 register char *source =
1655 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1657 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1658 *--dest = *--source;
1660 yy_cp += (int) (dest - source);
1661 yy_bp += (int) (dest - source);
1662 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1663 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1665 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1666 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1669 *--yy_cp = (char) c;
1671 (yytext_ptr) = yy_bp;
1672 (yy_hold_char) = *yy_cp;
1673 (yy_c_buf_p) = yy_cp;
1678 static int yyinput (void)
1680 static int input (void)
1686 *(yy_c_buf_p) = (yy_hold_char);
1688 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1690 /* yy_c_buf_p now points to the character we want to return.
1691 * If this occurs *before* the EOB characters, then it's a
1692 * valid NUL; if not, then we've hit the end of the buffer.
1694 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1695 /* This was really a NUL. */
1696 *(yy_c_buf_p) = '\0';
1699 { /* need more input */
1700 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1703 switch ( yy_get_next_buffer( ) )
1705 case EOB_ACT_LAST_MATCH:
1706 /* This happens because yy_g_n_b()
1707 * sees that we've accumulated a
1708 * token and flags that we need to
1709 * try matching the token before
1710 * proceeding. But for input(),
1711 * there's no matching to consider.
1712 * So convert the EOB_ACT_LAST_MATCH
1713 * to EOB_ACT_END_OF_FILE.
1716 /* Reset buffer status. */
1717 zconfrestart(zconfin );
1721 case EOB_ACT_END_OF_FILE:
1726 if ( ! (yy_did_buffer_switch_on_eof) )
1735 case EOB_ACT_CONTINUE_SCAN:
1736 (yy_c_buf_p) = (yytext_ptr) + offset;
1742 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1743 *(yy_c_buf_p) = '\0'; /* preserve zconftext */
1744 (yy_hold_char) = *++(yy_c_buf_p);
1748 #endif /* ifndef YY_NO_INPUT */
1750 /** Immediately switch to a different input stream.
1751 * @param input_file A readable stream.
1753 * @note This function does not reset the start condition to @c INITIAL .
1755 void zconfrestart (FILE * input_file )
1758 if ( ! YY_CURRENT_BUFFER ){
1759 zconfensure_buffer_stack ();
1760 YY_CURRENT_BUFFER_LVALUE =
1761 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1764 zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
1765 zconf_load_buffer_state( );
1768 /** Switch to a different input buffer.
1769 * @param new_buffer The new input buffer.
1772 void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1775 /* TODO. We should be able to replace this entire function body
1777 * zconfpop_buffer_state();
1778 * zconfpush_buffer_state(new_buffer);
1780 zconfensure_buffer_stack ();
1781 if ( YY_CURRENT_BUFFER == new_buffer )
1784 if ( YY_CURRENT_BUFFER )
1786 /* Flush out information for old buffer. */
1787 *(yy_c_buf_p) = (yy_hold_char);
1788 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1789 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1792 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1793 zconf_load_buffer_state( );
1795 /* We don't actually know whether we did this switch during
1796 * EOF (zconfwrap()) processing, but the only time this flag
1797 * is looked at is after zconfwrap() is called, so it's safe
1798 * to go ahead and always set it.
1800 (yy_did_buffer_switch_on_eof) = 1;
1803 static void zconf_load_buffer_state (void)
1805 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1806 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1807 zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1808 (yy_hold_char) = *(yy_c_buf_p);
1811 /** Allocate and initialize an input buffer state.
1812 * @param file A readable stream.
1813 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1815 * @return the allocated buffer state.
1817 YY_BUFFER_STATE zconf_create_buffer (FILE * file, int size )
1821 b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
1823 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1825 b->yy_buf_size = size;
1827 /* yy_ch_buf has to be 2 characters longer than the size given because
1828 * we need to put in 2 end-of-buffer characters.
1830 b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2 );
1831 if ( ! b->yy_ch_buf )
1832 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1834 b->yy_is_our_buffer = 1;
1836 zconf_init_buffer(b,file );
1841 /** Destroy the buffer.
1842 * @param b a buffer created with zconf_create_buffer()
1845 void zconf_delete_buffer (YY_BUFFER_STATE b )
1851 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1852 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1854 if ( b->yy_is_our_buffer )
1855 zconffree((void *) b->yy_ch_buf );
1857 zconffree((void *) b );
1860 /* Initializes or reinitializes a buffer.
1861 * This function is sometimes called more than once on the same buffer,
1862 * such as during a zconfrestart() or at EOF.
1864 static void zconf_init_buffer (YY_BUFFER_STATE b, FILE * file )
1869 zconf_flush_buffer(b );
1871 b->yy_input_file = file;
1872 b->yy_fill_buffer = 1;
1874 /* If b is the current buffer, then zconf_init_buffer was _probably_
1875 * called from zconfrestart() or through yy_get_next_buffer.
1876 * In that case, we don't want to reset the lineno or column.
1878 if (b != YY_CURRENT_BUFFER){
1879 b->yy_bs_lineno = 1;
1880 b->yy_bs_column = 0;
1883 b->yy_is_interactive = 0;
1888 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1889 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1892 void zconf_flush_buffer (YY_BUFFER_STATE b )
1899 /* We always need two end-of-buffer characters. The first causes
1900 * a transition to the end-of-buffer state. The second causes
1901 * a jam in that state.
1903 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1904 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1906 b->yy_buf_pos = &b->yy_ch_buf[0];
1909 b->yy_buffer_status = YY_BUFFER_NEW;
1911 if ( b == YY_CURRENT_BUFFER )
1912 zconf_load_buffer_state( );
1915 /** Pushes the new state onto the stack. The new state becomes
1916 * the current state. This function will allocate the stack
1918 * @param new_buffer The new state.
1921 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
1923 if (new_buffer == NULL)
1926 zconfensure_buffer_stack();
1928 /* This block is copied from zconf_switch_to_buffer. */
1929 if ( YY_CURRENT_BUFFER )
1931 /* Flush out information for old buffer. */
1932 *(yy_c_buf_p) = (yy_hold_char);
1933 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1934 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1937 /* Only push if top exists. Otherwise, replace top. */
1938 if (YY_CURRENT_BUFFER)
1939 (yy_buffer_stack_top)++;
1940 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1942 /* copied from zconf_switch_to_buffer. */
1943 zconf_load_buffer_state( );
1944 (yy_did_buffer_switch_on_eof) = 1;
1947 /** Removes and deletes the top of the stack, if present.
1948 * The next element becomes the new top.
1951 void zconfpop_buffer_state (void)
1953 if (!YY_CURRENT_BUFFER)
1956 zconf_delete_buffer(YY_CURRENT_BUFFER );
1957 YY_CURRENT_BUFFER_LVALUE = NULL;
1958 if ((yy_buffer_stack_top) > 0)
1959 --(yy_buffer_stack_top);
1961 if (YY_CURRENT_BUFFER) {
1962 zconf_load_buffer_state( );
1963 (yy_did_buffer_switch_on_eof) = 1;
1967 /* Allocates the stack if it does not exist.
1968 * Guarantees space for at least one push.
1970 static void zconfensure_buffer_stack (void)
1972 yy_size_t num_to_alloc;
1974 if (!(yy_buffer_stack)) {
1976 /* First allocation is just for 2 elements, since we don't know if this
1977 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1978 * immediate realloc on the next call.
1981 (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
1982 (num_to_alloc * sizeof(struct yy_buffer_state*)
1984 if ( ! (yy_buffer_stack) )
1985 YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
1987 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1989 (yy_buffer_stack_max) = num_to_alloc;
1990 (yy_buffer_stack_top) = 0;
1994 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1996 /* Increase the buffer to prepare for a possible push. */
1997 int grow_size = 8 /* arbitrary grow size */;
1999 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2000 (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
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 /* zero only the new slots.*/
2008 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2009 (yy_buffer_stack_max) = num_to_alloc;
2013 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2014 * @param base the character buffer
2015 * @param size the size in bytes of the character buffer
2017 * @return the newly allocated buffer state object.
2019 YY_BUFFER_STATE zconf_scan_buffer (char * base, yy_size_t size )
2024 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2025 base[size-1] != YY_END_OF_BUFFER_CHAR )
2026 /* They forgot to leave room for the EOB's. */
2029 b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
2031 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
2033 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2034 b->yy_buf_pos = b->yy_ch_buf = base;
2035 b->yy_is_our_buffer = 0;
2036 b->yy_input_file = 0;
2037 b->yy_n_chars = b->yy_buf_size;
2038 b->yy_is_interactive = 0;
2040 b->yy_fill_buffer = 0;
2041 b->yy_buffer_status = YY_BUFFER_NEW;
2043 zconf_switch_to_buffer(b );
2048 /** Setup the input buffer state to scan a string. The next call to zconflex() will
2049 * scan from a @e copy of @a str.
2050 * @param yystr a NUL-terminated string to scan
2052 * @return the newly allocated buffer state object.
2053 * @note If you want to scan bytes that may contain NUL values, then use
2054 * zconf_scan_bytes() instead.
2056 YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
2059 return zconf_scan_bytes(yystr,strlen(yystr) );
2062 /** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
2063 * scan from a @e copy of @a bytes.
2064 * @param yybytes the byte buffer to scan
2065 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2067 * @return the newly allocated buffer state object.
2069 YY_BUFFER_STATE zconf_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
2076 /* Get memory for full buffer, including space for trailing EOB's. */
2077 n = _yybytes_len + 2;
2078 buf = (char *) zconfalloc(n );
2080 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
2082 for ( i = 0; i < _yybytes_len; ++i )
2083 buf[i] = yybytes[i];
2085 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2087 b = zconf_scan_buffer(buf,n );
2089 YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
2091 /* It's okay to grow etc. this buffer, and we should throw it
2092 * away when we're done.
2094 b->yy_is_our_buffer = 1;
2099 #ifndef YY_EXIT_FAILURE
2100 #define YY_EXIT_FAILURE 2
2103 static void yy_fatal_error (yyconst char* msg )
2105 (void) fprintf( stderr, "%s\n", msg );
2106 exit( YY_EXIT_FAILURE );
2109 /* Redefine yyless() so it works in section 3 code. */
2115 /* Undo effects of setting up zconftext. */ \
2116 int yyless_macro_arg = (n); \
2117 YY_LESS_LINENO(yyless_macro_arg);\
2118 zconftext[zconfleng] = (yy_hold_char); \
2119 (yy_c_buf_p) = zconftext + yyless_macro_arg; \
2120 (yy_hold_char) = *(yy_c_buf_p); \
2121 *(yy_c_buf_p) = '\0'; \
2122 zconfleng = yyless_macro_arg; \
2126 /* Accessor methods (get/set functions) to struct members. */
2128 /** Get the current line number.
2131 int zconfget_lineno (void)
2137 /** Get the input stream.
2140 FILE *zconfget_in (void)
2145 /** Get the output stream.
2148 FILE *zconfget_out (void)
2153 /** Get the length of the current token.
2156 yy_size_t zconfget_leng (void)
2161 /** Get the current token.
2165 char *zconfget_text (void)
2170 /** Set the current line number.
2171 * @param line_number
2174 void zconfset_lineno (int line_number )
2177 zconflineno = line_number;
2180 /** Set the input stream. This does not discard the current
2182 * @param in_str A readable stream.
2184 * @see zconf_switch_to_buffer
2186 void zconfset_in (FILE * in_str )
2191 void zconfset_out (FILE * out_str )
2193 zconfout = out_str ;
2196 int zconfget_debug (void)
2198 return zconf_flex_debug;
2201 void zconfset_debug (int bdebug )
2203 zconf_flex_debug = bdebug ;
2206 static int yy_init_globals (void)
2208 /* Initialization is the same as for the non-reentrant scanner.
2209 * This function is called from zconflex_destroy(), so don't allocate here.
2212 (yy_buffer_stack) = 0;
2213 (yy_buffer_stack_top) = 0;
2214 (yy_buffer_stack_max) = 0;
2215 (yy_c_buf_p) = (char *) 0;
2219 /* Defined in main.c */
2224 zconfin = (FILE *) 0;
2225 zconfout = (FILE *) 0;
2228 /* For future reference: Set errno on error, since we are called by
2234 /* zconflex_destroy is for both reentrant and non-reentrant scanners. */
2235 int zconflex_destroy (void)
2238 /* Pop the buffer stack, destroying each element. */
2239 while(YY_CURRENT_BUFFER){
2240 zconf_delete_buffer(YY_CURRENT_BUFFER );
2241 YY_CURRENT_BUFFER_LVALUE = NULL;
2242 zconfpop_buffer_state();
2245 /* Destroy the stack itself. */
2246 zconffree((yy_buffer_stack) );
2247 (yy_buffer_stack) = NULL;
2249 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2250 * zconflex() is called, initialization will occur. */
2257 * Internal utility routines.
2261 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2264 for ( i = 0; i < n; ++i )
2269 #ifdef YY_NEED_STRLEN
2270 static int yy_flex_strlen (yyconst char * s )
2273 for ( n = 0; s[n]; ++n )
2280 void *zconfalloc (yy_size_t size )
2282 return (void *) malloc( size );
2285 void *zconfrealloc (void * ptr, yy_size_t size )
2287 /* The cast to (char *) in the following accommodates both
2288 * implementations that use char* generic pointers, and those
2289 * that use void* generic pointers. It works with the latter
2290 * because both ANSI C and C++ allow castless assignment from
2291 * any pointer type to void*, and deal with argument conversions
2292 * as though doing an assignment.
2294 return (void *) realloc( (char *) ptr, size );
2297 void zconffree (void * ptr )
2299 free( (char *) ptr ); /* see zconfrealloc() for (char *) cast */
2302 #define YYTABLES_NAME "yytables"
2304 void zconf_starthelp(void)
2307 last_ts = first_ts = 0;
2311 static void zconf_endhelp(void)
2313 zconflval.string = text;
2318 * Try to open specified file with following names:
2321 * The latter is used when srctree is separate from objtree
2322 * when compiling the kernel.
2323 * Return NULL if file is not found.
2325 FILE *zconf_fopen(const char *name)
2327 char *env, fullname[PATH_MAX+1];
2330 f = fopen(name, "r");
2331 if (!f && name != NULL && name[0] != '/') {
2332 env = getenv(SRCTREE);
2334 sprintf(fullname, "%s/%s", env, name);
2335 f = fopen(fullname, "r");
2341 void zconf_initscan(const char *name)
2343 zconfin = zconf_fopen(name);
2345 printf("can't find file %s\n", name);
2349 current_buf = xmalloc(sizeof(*current_buf));
2350 memset(current_buf, 0, sizeof(*current_buf));
2352 current_file = file_lookup(name);
2353 current_file->lineno = 1;
2356 static void __zconf_nextfile(const char *name)
2359 struct file *file = file_lookup(name);
2360 struct buffer *buf = xmalloc(sizeof(*buf));
2361 memset(buf, 0, sizeof(*buf));
2363 current_buf->state = YY_CURRENT_BUFFER;
2364 zconfin = zconf_fopen(file->name);
2366 printf("%s:%d: can't open file \"%s\"\n",
2367 zconf_curname(), zconf_lineno(), file->name);
2370 zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
2371 buf->parent = current_buf;
2374 for (iter = current_file->parent; iter; iter = iter->parent ) {
2375 if (!strcmp(current_file->name,iter->name) ) {
2376 printf("%s:%d: recursive inclusion detected. "
2377 "Inclusion path:\n current file : '%s'\n",
2378 zconf_curname(), zconf_lineno(),
2380 iter = current_file->parent;
2382 strcmp(iter->name,current_file->name)) {
2383 printf(" included from: '%s:%d'\n",
2384 iter->name, iter->lineno-1);
2385 iter = iter->parent;
2388 printf(" included from: '%s:%d'\n",
2389 iter->name, iter->lineno+1);
2394 file->parent = current_file;
2395 current_file = file;
2398 void zconf_nextfile(const char *name)
2403 char path[PATH_MAX], *p;
2405 err = glob(name, GLOB_ERR | GLOB_MARK, NULL, &gl);
2407 /* ignore wildcard patterns that return no result */
2408 if (err == GLOB_NOMATCH && strchr(name, '*')) {
2413 if (err == GLOB_NOMATCH) {
2414 p = strdup(current_file->name);
2416 snprintf(path, sizeof(path), "%s/%s", dirname(p), name);
2417 err = glob(path, GLOB_ERR | GLOB_MARK, NULL, &gl);
2423 const char *reason = "unknown error";
2427 reason = "out of memory";
2430 reason = "read error";
2433 reason = "No files found";
2439 printf("%s:%d: glob failed: %s \"%s\"\n", zconf_curname(), zconf_lineno(),
2445 for (i = 0; i < gl.gl_pathc; i++)
2446 __zconf_nextfile(gl.gl_pathv[i]);
2449 static void zconf_endfile(void)
2451 struct buffer *parent;
2453 current_file = current_file->parent;
2455 parent = current_buf->parent;
2458 zconf_delete_buffer(YY_CURRENT_BUFFER);
2459 zconf_switch_to_buffer(parent->state);
2462 current_buf = parent;
2465 int zconf_lineno(void)
2467 return current_pos.lineno;
2470 const char *zconf_curname(void)
2472 return current_pos.file ? current_pos.file->name : "<none>";