USB: ldusb should signal an error in poll if the device is disconnected
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / scripts / kconfig / lex.zconf.c_shipped
blobdc3e81807d13a41c18df6d20ce8c466e566e9853
2 #line 3 "scripts/kconfig/lex.zconf.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
15 #define yyin zconfin
16 #define yyleng zconfleng
17 #define yylex zconflex
18 #define yylineno zconflineno
19 #define yyout zconfout
20 #define yyrestart zconfrestart
21 #define yytext zconftext
22 #define yywrap zconfwrap
23 #define yyalloc zconfalloc
24 #define yyrealloc zconfrealloc
25 #define yyfree zconffree
27 #define FLEX_SCANNER
28 #define YY_FLEX_MAJOR_VERSION 2
29 #define YY_FLEX_MINOR_VERSION 5
30 #define YY_FLEX_SUBMINOR_VERSION 35
31 #if YY_FLEX_SUBMINOR_VERSION > 0
32 #define FLEX_BETA
33 #endif
35 /* First, we deal with  platform-specific or compiler-specific issues. */
37 /* begin standard C headers. */
38 #include <stdio.h>
39 #include <string.h>
40 #include <errno.h>
41 #include <stdlib.h>
43 /* end standard C headers. */
45 /* flex integer type definitions */
47 #ifndef FLEXINT_H
48 #define FLEXINT_H
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. 
56  */
57 #ifndef __STDC_LIMIT_MACROS
58 #define __STDC_LIMIT_MACROS 1
59 #endif
61 #include <inttypes.h>
62 typedef int8_t flex_int8_t;
63 typedef uint8_t flex_uint8_t;
64 typedef int16_t flex_int16_t;
65 typedef uint16_t flex_uint16_t;
66 typedef int32_t flex_int32_t;
67 typedef uint32_t flex_uint32_t;
68 #else
69 typedef signed char flex_int8_t;
70 typedef short int flex_int16_t;
71 typedef int flex_int32_t;
72 typedef unsigned char flex_uint8_t; 
73 typedef unsigned short int flex_uint16_t;
74 typedef unsigned int flex_uint32_t;
76 /* Limits of integral types. */
77 #ifndef INT8_MIN
78 #define INT8_MIN               (-128)
79 #endif
80 #ifndef INT16_MIN
81 #define INT16_MIN              (-32767-1)
82 #endif
83 #ifndef INT32_MIN
84 #define INT32_MIN              (-2147483647-1)
85 #endif
86 #ifndef INT8_MAX
87 #define INT8_MAX               (127)
88 #endif
89 #ifndef INT16_MAX
90 #define INT16_MAX              (32767)
91 #endif
92 #ifndef INT32_MAX
93 #define INT32_MAX              (2147483647)
94 #endif
95 #ifndef UINT8_MAX
96 #define UINT8_MAX              (255U)
97 #endif
98 #ifndef UINT16_MAX
99 #define UINT16_MAX             (65535U)
100 #endif
101 #ifndef UINT32_MAX
102 #define UINT32_MAX             (4294967295U)
103 #endif
105 #endif /* ! C99 */
107 #endif /* ! FLEXINT_H */
109 #ifdef __cplusplus
111 /* The "const" storage-class-modifier is valid. */
112 #define YY_USE_CONST
114 #else   /* ! __cplusplus */
116 /* C99 requires __STDC__ to be defined as 1. */
117 #if defined (__STDC__)
119 #define YY_USE_CONST
121 #endif  /* defined (__STDC__) */
122 #endif  /* ! __cplusplus */
124 #ifdef YY_USE_CONST
125 #define yyconst const
126 #else
127 #define yyconst
128 #endif
130 /* Returned upon end-of-file. */
131 #define YY_NULL 0
133 /* Promotes a possibly negative, possibly signed char to an unsigned
134  * integer for use as an array index.  If the signed char is negative,
135  * we want to instead treat it as an 8-bit unsigned char, hence the
136  * double cast.
137  */
138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
140 /* Enter a start condition.  This macro really ought to take a parameter,
141  * but we do it the disgusting crufty way forced on us by the ()-less
142  * definition of BEGIN.
143  */
144 #define BEGIN (yy_start) = 1 + 2 *
146 /* Translate the current start state into a value that can be later handed
147  * to BEGIN to return to the state.  The YYSTATE alias is for lex
148  * compatibility.
149  */
150 #define YY_START (((yy_start) - 1) / 2)
151 #define YYSTATE YY_START
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. */
162 #ifndef YY_BUF_SIZE
163 #define YY_BUF_SIZE 16384
164 #endif
166 /* The state buf must be large enough to hold one state per character in the main buffer.
167  */
168 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
170 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
171 #define YY_TYPEDEF_YY_BUFFER_STATE
172 typedef struct yy_buffer_state *YY_BUFFER_STATE;
173 #endif
175 extern int zconfleng;
177 extern FILE *zconfin, *zconfout;
179 #define EOB_ACT_CONTINUE_SCAN 0
180 #define EOB_ACT_END_OF_FILE 1
181 #define EOB_ACT_LAST_MATCH 2
183     #define YY_LESS_LINENO(n)
184     
185 /* Return all but the first "n" matched characters back to the input stream. */
186 #define yyless(n) \
187         do \
188                 { \
189                 /* Undo effects of setting up zconftext. */ \
190         int yyless_macro_arg = (n); \
191         YY_LESS_LINENO(yyless_macro_arg);\
192                 *yy_cp = (yy_hold_char); \
193                 YY_RESTORE_YY_MORE_OFFSET \
194                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195                 YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
196                 } \
197         while ( 0 )
199 #define unput(c) yyunput( c, (yytext_ptr)  )
201 #ifndef YY_TYPEDEF_YY_SIZE_T
202 #define YY_TYPEDEF_YY_SIZE_T
203 typedef size_t yy_size_t;
204 #endif
206 #ifndef YY_STRUCT_YY_BUFFER_STATE
207 #define YY_STRUCT_YY_BUFFER_STATE
208 struct yy_buffer_state
209         {
210         FILE *yy_input_file;
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
216          * characters.
217          */
218         yy_size_t yy_buf_size;
220         /* Number of characters read into yy_ch_buf, not including EOB
221          * characters.
222          */
223         int 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
227          * delete it.
228          */
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
234          * each newline.
235          */
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
240          * not.
241          */
242         int yy_at_bol;
244     int yy_bs_lineno; /**< The line count. */
245     int yy_bs_column; /**< The column count. */
246     
247         /* Whether to try to fill the input buffer when we reach the
248          * end of it.
249          */
250         int yy_fill_buffer;
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.
261          *
262          * When we actually see the EOF, we change the status to "new"
263          * (via zconfrestart()), so that the user can continue scanning by
264          * just pointing zconfin at a new input file.
265          */
266 #define YY_BUFFER_EOF_PENDING 2
268         };
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
278  * "scanner state".
280  * Returns the top of the stack, or NULL.
281  */
282 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
283                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
284                           : NULL)
286 /* Same as previous macro, but useful when we know that the buffer stack is not
287  * NULL or when we need an lvalue. For internal use only.
288  */
289 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
291 /* yy_hold_char holds the character lost when zconftext is formed. */
292 static char yy_hold_char;
293 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
294 int zconfleng;
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 ...
303  */
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,int 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) \
331         { \
332         if ( ! YY_CURRENT_BUFFER ){ \
333         zconfensure_buffer_stack (); \
334                 YY_CURRENT_BUFFER_LVALUE =    \
335             zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
336         } \
337         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
338         }
340 #define yy_set_bol(at_bol) \
341         { \
342         if ( ! YY_CURRENT_BUFFER ){\
343         zconfensure_buffer_stack (); \
344                 YY_CURRENT_BUFFER_LVALUE =    \
345             zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
346         } \
347         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
348         }
350 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
352 /* Begin user sect3 */
354 #define zconfwrap(n) 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;
365 int zconflineno = 1;
367 extern char *zconftext;
368 #define yytext_ptr zconftext
369 static yyconst flex_int16_t yy_nxt[][17] =
370     {
371     {
372         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
373         0,    0,    0,    0,    0,    0,    0
374     },
376     {
377        11,   12,   13,   14,   12,   12,   15,   12,   12,   12,
378        12,   12,   12,   12,   12,   12,   12
379     },
381     {
382        11,   12,   13,   14,   12,   12,   15,   12,   12,   12,
383        12,   12,   12,   12,   12,   12,   12
384     },
386     {
387        11,   16,   16,   17,   16,   16,   16,   16,   16,   16,
388        16,   16,   16,   18,   16,   16,   16
389     },
391     {
392        11,   16,   16,   17,   16,   16,   16,   16,   16,   16,
393        16,   16,   16,   18,   16,   16,   16
395     },
397     {
398        11,   19,   20,   21,   19,   19,   19,   19,   19,   19,
399        19,   19,   19,   19,   19,   19,   19
400     },
402     {
403        11,   19,   20,   21,   19,   19,   19,   19,   19,   19,
404        19,   19,   19,   19,   19,   19,   19
405     },
407     {
408        11,   22,   22,   23,   22,   24,   22,   22,   24,   22,
409        22,   22,   22,   22,   22,   25,   22
410     },
412     {
413        11,   22,   22,   23,   22,   24,   22,   22,   24,   22,
414        22,   22,   22,   22,   22,   25,   22
415     },
417     {
418        11,   26,   26,   27,   28,   29,   30,   31,   29,   32,
419        33,   34,   35,   35,   36,   37,   38
421     },
423     {
424        11,   26,   26,   27,   28,   29,   30,   31,   29,   32,
425        33,   34,   35,   35,   36,   37,   38
426     },
428     {
429       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
430       -11,  -11,  -11,  -11,  -11,  -11,  -11
431     },
433     {
434        11,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
435       -12,  -12,  -12,  -12,  -12,  -12,  -12
436     },
438     {
439        11,  -13,   39,   40,  -13,  -13,   41,  -13,  -13,  -13,
440       -13,  -13,  -13,  -13,  -13,  -13,  -13
441     },
443     {
444        11,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
445       -14,  -14,  -14,  -14,  -14,  -14,  -14
447     },
449     {
450        11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
451        42,   42,   42,   42,   42,   42,   42
452     },
454     {
455        11,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
456       -16,  -16,  -16,  -16,  -16,  -16,  -16
457     },
459     {
460        11,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
461       -17,  -17,  -17,  -17,  -17,  -17,  -17
462     },
464     {
465        11,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
466       -18,  -18,  -18,   44,  -18,  -18,  -18
467     },
469     {
470        11,   45,   45,  -19,   45,   45,   45,   45,   45,   45,
471        45,   45,   45,   45,   45,   45,   45
473     },
475     {
476        11,  -20,   46,   47,  -20,  -20,  -20,  -20,  -20,  -20,
477       -20,  -20,  -20,  -20,  -20,  -20,  -20
478     },
480     {
481        11,   48,  -21,  -21,   48,   48,   48,   48,   48,   48,
482        48,   48,   48,   48,   48,   48,   48
483     },
485     {
486        11,   49,   49,   50,   49,  -22,   49,   49,  -22,   49,
487        49,   49,   49,   49,   49,  -22,   49
488     },
490     {
491        11,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
492       -23,  -23,  -23,  -23,  -23,  -23,  -23
493     },
495     {
496        11,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
497       -24,  -24,  -24,  -24,  -24,  -24,  -24
499     },
501     {
502        11,   51,   51,   52,   51,   51,   51,   51,   51,   51,
503        51,   51,   51,   51,   51,   51,   51
504     },
506     {
507        11,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
508       -26,  -26,  -26,  -26,  -26,  -26,  -26
509     },
511     {
512        11,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
513       -27,  -27,  -27,  -27,  -27,  -27,  -27
514     },
516     {
517        11,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
518       -28,  -28,  -28,  -28,   53,  -28,  -28
519     },
521     {
522        11,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
523       -29,  -29,  -29,  -29,  -29,  -29,  -29
525     },
527     {
528        11,   54,   54,  -30,   54,   54,   54,   54,   54,   54,
529        54,   54,   54,   54,   54,   54,   54
530     },
532     {
533        11,  -31,  -31,  -31,  -31,  -31,  -31,   55,  -31,  -31,
534       -31,  -31,  -31,  -31,  -31,  -31,  -31
535     },
537     {
538        11,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
539       -32,  -32,  -32,  -32,  -32,  -32,  -32
540     },
542     {
543        11,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
544       -33,  -33,  -33,  -33,  -33,  -33,  -33
545     },
547     {
548        11,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
549       -34,   56,   57,   57,  -34,  -34,  -34
551     },
553     {
554        11,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
555       -35,   57,   57,   57,  -35,  -35,  -35
556     },
558     {
559        11,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
560       -36,  -36,  -36,  -36,  -36,  -36,  -36
561     },
563     {
564        11,  -37,  -37,   58,  -37,  -37,  -37,  -37,  -37,  -37,
565       -37,  -37,  -37,  -37,  -37,  -37,  -37
566     },
568     {
569        11,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
570       -38,  -38,  -38,  -38,  -38,  -38,   59
571     },
573     {
574        11,  -39,   39,   40,  -39,  -39,   41,  -39,  -39,  -39,
575       -39,  -39,  -39,  -39,  -39,  -39,  -39
577     },
579     {
580        11,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
581       -40,  -40,  -40,  -40,  -40,  -40,  -40
582     },
584     {
585        11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
586        42,   42,   42,   42,   42,   42,   42
587     },
589     {
590        11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
591        42,   42,   42,   42,   42,   42,   42
592     },
594     {
595        11,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
596       -43,  -43,  -43,  -43,  -43,  -43,  -43
597     },
599     {
600        11,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
601       -44,  -44,  -44,   44,  -44,  -44,  -44
603     },
605     {
606        11,   45,   45,  -45,   45,   45,   45,   45,   45,   45,
607        45,   45,   45,   45,   45,   45,   45
608     },
610     {
611        11,  -46,   46,   47,  -46,  -46,  -46,  -46,  -46,  -46,
612       -46,  -46,  -46,  -46,  -46,  -46,  -46
613     },
615     {
616        11,   48,  -47,  -47,   48,   48,   48,   48,   48,   48,
617        48,   48,   48,   48,   48,   48,   48
618     },
620     {
621        11,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
622       -48,  -48,  -48,  -48,  -48,  -48,  -48
623     },
625     {
626        11,   49,   49,   50,   49,  -49,   49,   49,  -49,   49,
627        49,   49,   49,   49,   49,  -49,   49
629     },
631     {
632        11,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
633       -50,  -50,  -50,  -50,  -50,  -50,  -50
634     },
636     {
637        11,  -51,  -51,   52,  -51,  -51,  -51,  -51,  -51,  -51,
638       -51,  -51,  -51,  -51,  -51,  -51,  -51
639     },
641     {
642        11,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
643       -52,  -52,  -52,  -52,  -52,  -52,  -52
644     },
646     {
647        11,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
648       -53,  -53,  -53,  -53,  -53,  -53,  -53
649     },
651     {
652        11,   54,   54,  -54,   54,   54,   54,   54,   54,   54,
653        54,   54,   54,   54,   54,   54,   54
655     },
657     {
658        11,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
659       -55,  -55,  -55,  -55,  -55,  -55,  -55
660     },
662     {
663        11,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
664       -56,   60,   57,   57,  -56,  -56,  -56
665     },
667     {
668        11,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
669       -57,   57,   57,   57,  -57,  -57,  -57
670     },
672     {
673        11,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
674       -58,  -58,  -58,  -58,  -58,  -58,  -58
675     },
677     {
678        11,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
679       -59,  -59,  -59,  -59,  -59,  -59,  -59
681     },
683     {
684        11,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
685       -60,   57,   57,   57,  -60,  -60,  -60
686     },
688     } ;
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.
697  */
698 #define YY_DO_BEFORE_ACTION \
699         (yytext_ptr) = yy_bp; \
700         zconfleng = (size_t) (yy_cp - yy_bp); \
701         (yy_hold_char) = *yy_cp; \
702         *yy_cp = '\0'; \
703         (yy_c_buf_p) = yy_cp;
705 #define YY_NUM_RULES 33
706 #define YY_END_OF_BUFFER 34
707 /* This struct is not used in this scanner,
708    but its presence is necessary. */
709 struct yy_trans_info
710         {
711         flex_int32_t yy_verify;
712         flex_int32_t yy_nxt;
713         };
714 static yyconst flex_int16_t yy_accept[61] =
715     {   0,
716         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
717        34,    5,    4,    2,    3,    7,    8,    6,   32,   29,
718        31,   24,   28,   27,   26,   22,   17,   13,   16,   20,
719        22,   11,   12,   19,   19,   14,   22,   22,    4,    2,
720         3,    3,    1,    6,   32,   29,   31,   30,   24,   23,
721        26,   25,   15,   20,    9,   19,   19,   21,   10,   18
722     } ;
724 static yyconst flex_int32_t yy_ec[256] =
725     {   0,
726         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
727         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
728         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
729         1,    2,    4,    5,    6,    1,    1,    7,    8,    9,
730        10,    1,    1,    1,   11,   12,   12,   13,   13,   13,
731        13,   13,   13,   13,   13,   13,   13,    1,    1,    1,
732        14,    1,    1,    1,   13,   13,   13,   13,   13,   13,
733        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
734        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
735         1,   15,    1,    1,   13,    1,   13,   13,   13,   13,
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,
753         1,    1,    1,    1,    1
754     } ;
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.
761  */
762 #define REJECT reject_used_but_not_detected
763 #define yymore() yymore_used_but_not_detected
764 #define YY_MORE_ADJ 0
765 #define YY_RESTORE_YY_MORE_OFFSET
766 char *zconftext;
767 #define YY_NO_INPUT 1
770  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
771  * Released under the terms of the GNU GPL v2.0.
772  */
774 #include <limits.h>
775 #include <stdio.h>
776 #include <stdlib.h>
777 #include <string.h>
778 #include <unistd.h>
780 #define LKC_DIRECT_LINK
781 #include "lkc.h"
783 #define START_STRSIZE   16
785 static struct {
786         struct file *file;
787         int lineno;
788 } current_pos;
790 static char *text;
791 static int text_size, text_asize;
793 struct buffer {
794         struct buffer *parent;
795         YY_BUFFER_STATE state;
798 struct buffer *current_buf;
800 static int last_ts, first_ts;
802 static void zconf_endhelp(void);
803 static void zconf_endfile(void);
805 void new_string(void)
807         text = malloc(START_STRSIZE);
808         text_asize = START_STRSIZE;
809         text_size = 0;
810         *text = 0;
813 void append_string(const char *str, int size)
815         int new_size = text_size + size + 1;
816         if (new_size > text_asize) {
817                 new_size += START_STRSIZE - 1;
818                 new_size &= -START_STRSIZE;
819                 text = realloc(text, new_size);
820                 text_asize = new_size;
821         }
822         memcpy(text + text_size, str, size);
823         text_size += size;
824         text[text_size] = 0;
827 void alloc_string(const char *str, int size)
829         text = malloc(size + 1);
830         memcpy(text, str, size);
831         text[size] = 0;
834 #define INITIAL 0
835 #define COMMAND 1
836 #define HELP 2
837 #define STRING 3
838 #define PARAM 4
840 #ifndef YY_NO_UNISTD_H
841 /* Special case for "unistd.h", since it is non-ANSI. We include it way
842  * down here because we want the user's section 1 to have been scanned first.
843  * The user has a chance to override it with an option.
844  */
845 #include <unistd.h>
846 #endif
848 #ifndef YY_EXTRA_TYPE
849 #define YY_EXTRA_TYPE void *
850 #endif
852 static int yy_init_globals (void );
854 /* Accessor methods to globals.
855    These are made visible to non-reentrant scanners for convenience. */
857 int zconflex_destroy (void );
859 int zconfget_debug (void );
861 void zconfset_debug (int debug_flag  );
863 YY_EXTRA_TYPE zconfget_extra (void );
865 void zconfset_extra (YY_EXTRA_TYPE user_defined  );
867 FILE *zconfget_in (void );
869 void zconfset_in  (FILE * in_str  );
871 FILE *zconfget_out (void );
873 void zconfset_out  (FILE * out_str  );
875 int zconfget_leng (void );
877 char *zconfget_text (void );
879 int zconfget_lineno (void );
881 void zconfset_lineno (int line_number  );
883 /* Macros after this point can all be overridden by user definitions in
884  * section 1.
885  */
887 #ifndef YY_SKIP_YYWRAP
888 #ifdef __cplusplus
889 extern "C" int zconfwrap (void );
890 #else
891 extern int zconfwrap (void );
892 #endif
893 #endif
895     static void yyunput (int c,char *buf_ptr  );
896     
897 #ifndef yytext_ptr
898 static void yy_flex_strncpy (char *,yyconst char *,int );
899 #endif
901 #ifdef YY_NEED_STRLEN
902 static int yy_flex_strlen (yyconst char * );
903 #endif
905 #ifndef YY_NO_INPUT
907 #ifdef __cplusplus
908 static int yyinput (void );
909 #else
910 static int input (void );
911 #endif
913 #endif
915 /* Amount of stuff to slurp up with each read. */
916 #ifndef YY_READ_BUF_SIZE
917 #define YY_READ_BUF_SIZE 8192
918 #endif
920 /* Copy whatever the last rule matched to the standard output. */
921 #ifndef ECHO
922 /* This used to be an fputs(), but since the string might contain NUL's,
923  * we now use fwrite().
924  */
925 #define ECHO fwrite( zconftext, zconfleng, 1, zconfout )
926 #endif
928 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
929  * is returned in "result".
930  */
931 #ifndef YY_INPUT
932 #define YY_INPUT(buf,result,max_size) \
933         errno=0; \
934         while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
935         { \
936                 if( errno != EINTR) \
937                 { \
938                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
939                         break; \
940                 } \
941                 errno=0; \
942                 clearerr(zconfin); \
943         }\
946 #endif
948 /* No semi-colon after return; correct usage is to write "yyterminate();" -
949  * we don't want an extra ';' after the "return" because that will cause
950  * some compilers to complain about unreachable statements.
951  */
952 #ifndef yyterminate
953 #define yyterminate() return YY_NULL
954 #endif
956 /* Number of entries by which start-condition stack grows. */
957 #ifndef YY_START_STACK_INCR
958 #define YY_START_STACK_INCR 25
959 #endif
961 /* Report a fatal error. */
962 #ifndef YY_FATAL_ERROR
963 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
964 #endif
966 /* end tables serialization structures and prototypes */
968 /* Default declaration of generated scanner - a define so the user can
969  * easily add parameters.
970  */
971 #ifndef YY_DECL
972 #define YY_DECL_IS_OURS 1
974 extern int zconflex (void);
976 #define YY_DECL int zconflex (void)
977 #endif /* !YY_DECL */
979 /* Code executed at the beginning of each rule, after zconftext and zconfleng
980  * have been set up.
981  */
982 #ifndef YY_USER_ACTION
983 #define YY_USER_ACTION
984 #endif
986 /* Code executed at the end of each rule. */
987 #ifndef YY_BREAK
988 #define YY_BREAK break;
989 #endif
991 #define YY_RULE_SETUP \
992         YY_USER_ACTION
994 /** The main scanner function which does all the work.
995  */
996 YY_DECL
998         register yy_state_type yy_current_state;
999         register char *yy_cp, *yy_bp;
1000         register int yy_act;
1001     
1002         int str = 0;
1003         int ts, i;
1005         if ( !(yy_init) )
1006                 {
1007                 (yy_init) = 1;
1009 #ifdef YY_USER_INIT
1010                 YY_USER_INIT;
1011 #endif
1013                 if ( ! (yy_start) )
1014                         (yy_start) = 1; /* first start state */
1016                 if ( ! zconfin )
1017                         zconfin = stdin;
1019                 if ( ! zconfout )
1020                         zconfout = stdout;
1022                 if ( ! YY_CURRENT_BUFFER ) {
1023                         zconfensure_buffer_stack ();
1024                         YY_CURRENT_BUFFER_LVALUE =
1025                                 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1026                 }
1028                 zconf_load_buffer_state( );
1029                 }
1031         while ( 1 )             /* loops until end-of-file is reached */
1032                 {
1033                 yy_cp = (yy_c_buf_p);
1035                 /* Support of zconftext. */
1036                 *yy_cp = (yy_hold_char);
1038                 /* yy_bp points to the position in yy_ch_buf of the start of
1039                  * the current run.
1040                  */
1041                 yy_bp = yy_cp;
1043                 yy_current_state = (yy_start);
1044 yy_match:
1045                 while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)]  ]) > 0 )
1046                         ++yy_cp;
1048                 yy_current_state = -yy_current_state;
1050 yy_find_action:
1051                 yy_act = yy_accept[yy_current_state];
1053                 YY_DO_BEFORE_ACTION;
1055 do_action:      /* This label is used only to access EOF actions. */
1057                 switch ( yy_act )
1058         { /* beginning of action switch */
1059 case 1:
1060 /* rule 1 can match eol */
1061 case 2:
1062 /* rule 2 can match eol */
1063 YY_RULE_SETUP
1065         current_file->lineno++;
1066         return T_EOL;
1068         YY_BREAK
1069 case 3:
1070 YY_RULE_SETUP
1072         YY_BREAK
1073 case 4:
1074 YY_RULE_SETUP
1076         BEGIN(COMMAND);
1078         YY_BREAK
1079 case 5:
1080 YY_RULE_SETUP
1082         unput(zconftext[0]);
1083         BEGIN(COMMAND);
1085         YY_BREAK
1087 case 6:
1088 YY_RULE_SETUP
1090                 struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1091                 BEGIN(PARAM);
1092                 current_pos.file = current_file;
1093                 current_pos.lineno = current_file->lineno;
1094                 if (id && id->flags & TF_COMMAND) {
1095                         zconflval.id = id;
1096                         return id->token;
1097                 }
1098                 alloc_string(zconftext, zconfleng);
1099                 zconflval.string = text;
1100                 return T_WORD;
1101         }
1102         YY_BREAK
1103 case 7:
1104 YY_RULE_SETUP
1106         YY_BREAK
1107 case 8:
1108 /* rule 8 can match eol */
1109 YY_RULE_SETUP
1111                 BEGIN(INITIAL);
1112                 current_file->lineno++;
1113                 return T_EOL;
1114         }
1115         YY_BREAK
1117 case 9:
1118 YY_RULE_SETUP
1119 return T_AND;
1120         YY_BREAK
1121 case 10:
1122 YY_RULE_SETUP
1123 return T_OR;
1124         YY_BREAK
1125 case 11:
1126 YY_RULE_SETUP
1127 return T_OPEN_PAREN;
1128         YY_BREAK
1129 case 12:
1130 YY_RULE_SETUP
1131 return T_CLOSE_PAREN;
1132         YY_BREAK
1133 case 13:
1134 YY_RULE_SETUP
1135 return T_NOT;
1136         YY_BREAK
1137 case 14:
1138 YY_RULE_SETUP
1139 return T_EQUAL;
1140         YY_BREAK
1141 case 15:
1142 YY_RULE_SETUP
1143 return T_UNEQUAL;
1144         YY_BREAK
1145 case 16:
1146 YY_RULE_SETUP
1148                 str = zconftext[0];
1149                 new_string();
1150                 BEGIN(STRING);
1151         }
1152         YY_BREAK
1153 case 17:
1154 /* rule 17 can match eol */
1155 YY_RULE_SETUP
1156 BEGIN(INITIAL); current_file->lineno++; return T_EOL;
1157         YY_BREAK
1158 case 18:
1159 YY_RULE_SETUP
1160 /* ignore */
1161         YY_BREAK
1162 case 19:
1163 YY_RULE_SETUP
1165                 struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1166                 if (id && id->flags & TF_PARAM) {
1167                         zconflval.id = id;
1168                         return id->token;
1169                 }
1170                 alloc_string(zconftext, zconfleng);
1171                 zconflval.string = text;
1172                 return T_WORD;
1173         }
1174         YY_BREAK
1175 case 20:
1176 YY_RULE_SETUP
1177 /* comment */
1178         YY_BREAK
1179 case 21:
1180 /* rule 21 can match eol */
1181 YY_RULE_SETUP
1182 current_file->lineno++;
1183         YY_BREAK
1184 case 22:
1185 YY_RULE_SETUP
1187         YY_BREAK
1188 case YY_STATE_EOF(PARAM):
1190                 BEGIN(INITIAL);
1191         }
1192         YY_BREAK
1194 case 23:
1195 /* rule 23 can match eol */
1196 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1197 (yy_c_buf_p) = yy_cp -= 1;
1198 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1199 YY_RULE_SETUP
1201                 append_string(zconftext, zconfleng);
1202                 zconflval.string = text;
1203                 return T_WORD_QUOTE;
1204         }
1205         YY_BREAK
1206 case 24:
1207 YY_RULE_SETUP
1209                 append_string(zconftext, zconfleng);
1210         }
1211         YY_BREAK
1212 case 25:
1213 /* rule 25 can match eol */
1214 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1215 (yy_c_buf_p) = yy_cp -= 1;
1216 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1217 YY_RULE_SETUP
1219                 append_string(zconftext + 1, zconfleng - 1);
1220                 zconflval.string = text;
1221                 return T_WORD_QUOTE;
1222         }
1223         YY_BREAK
1224 case 26:
1225 YY_RULE_SETUP
1227                 append_string(zconftext + 1, zconfleng - 1);
1228         }
1229         YY_BREAK
1230 case 27:
1231 YY_RULE_SETUP
1233                 if (str == zconftext[0]) {
1234                         BEGIN(PARAM);
1235                         zconflval.string = text;
1236                         return T_WORD_QUOTE;
1237                 } else
1238                         append_string(zconftext, 1);
1239         }
1240         YY_BREAK
1241 case 28:
1242 /* rule 28 can match eol */
1243 YY_RULE_SETUP
1245                 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
1246                 current_file->lineno++;
1247                 BEGIN(INITIAL);
1248                 return T_EOL;
1249         }
1250         YY_BREAK
1251 case YY_STATE_EOF(STRING):
1253                 BEGIN(INITIAL);
1254         }
1255         YY_BREAK
1257 case 29:
1258 YY_RULE_SETUP
1260                 ts = 0;
1261                 for (i = 0; i < zconfleng; i++) {
1262                         if (zconftext[i] == '\t')
1263                                 ts = (ts & ~7) + 8;
1264                         else
1265                                 ts++;
1266                 }
1267                 last_ts = ts;
1268                 if (first_ts) {
1269                         if (ts < first_ts) {
1270                                 zconf_endhelp();
1271                                 return T_HELPTEXT;
1272                         }
1273                         ts -= first_ts;
1274                         while (ts > 8) {
1275                                 append_string("        ", 8);
1276                                 ts -= 8;
1277                         }
1278                         append_string("        ", ts);
1279                 }
1280         }
1281         YY_BREAK
1282 case 30:
1283 /* rule 30 can match eol */
1284 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1285 (yy_c_buf_p) = yy_cp -= 1;
1286 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1287 YY_RULE_SETUP
1289                 current_file->lineno++;
1290                 zconf_endhelp();
1291                 return T_HELPTEXT;
1292         }
1293         YY_BREAK
1294 case 31:
1295 /* rule 31 can match eol */
1296 YY_RULE_SETUP
1298                 current_file->lineno++;
1299                 append_string("\n", 1);
1300         }
1301         YY_BREAK
1302 case 32:
1303 YY_RULE_SETUP
1305                 while (zconfleng) {
1306                         if ((zconftext[zconfleng-1] != ' ') && (zconftext[zconfleng-1] != '\t'))
1307                                 break;
1308                         zconfleng--;
1309                 }
1310                 append_string(zconftext, zconfleng);
1311                 if (!first_ts)
1312                         first_ts = last_ts;
1313         }
1314         YY_BREAK
1315 case YY_STATE_EOF(HELP):
1317                 zconf_endhelp();
1318                 return T_HELPTEXT;
1319         }
1320         YY_BREAK
1322 case YY_STATE_EOF(INITIAL):
1323 case YY_STATE_EOF(COMMAND):
1325         if (current_file) {
1326                 zconf_endfile();
1327                 return T_EOL;
1328         }
1329         fclose(zconfin);
1330         yyterminate();
1332         YY_BREAK
1333 case 33:
1334 YY_RULE_SETUP
1335 YY_FATAL_ERROR( "flex scanner jammed" );
1336         YY_BREAK
1338         case YY_END_OF_BUFFER:
1339                 {
1340                 /* Amount of text matched not including the EOB char. */
1341                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1343                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1344                 *yy_cp = (yy_hold_char);
1345                 YY_RESTORE_YY_MORE_OFFSET
1347                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1348                         {
1349                         /* We're scanning a new file or input source.  It's
1350                          * possible that this happened because the user
1351                          * just pointed zconfin at a new source and called
1352                          * zconflex().  If so, then we have to assure
1353                          * consistency between YY_CURRENT_BUFFER and our
1354                          * globals.  Here is the right place to do so, because
1355                          * this is the first action (other than possibly a
1356                          * back-up) that will match for the new input source.
1357                          */
1358                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1359                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
1360                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1361                         }
1363                 /* Note that here we test for yy_c_buf_p "<=" to the position
1364                  * of the first EOB in the buffer, since yy_c_buf_p will
1365                  * already have been incremented past the NUL character
1366                  * (since all states make transitions on EOB to the
1367                  * end-of-buffer state).  Contrast this with the test
1368                  * in input().
1369                  */
1370                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1371                         { /* This was really a NUL. */
1372                         yy_state_type yy_next_state;
1374                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1376                         yy_current_state = yy_get_previous_state(  );
1378                         /* Okay, we're now positioned to make the NUL
1379                          * transition.  We couldn't have
1380                          * yy_get_previous_state() go ahead and do it
1381                          * for us because it doesn't know how to deal
1382                          * with the possibility of jamming (and we don't
1383                          * want to build jamming into it because then it
1384                          * will run more slowly).
1385                          */
1387                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1389                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1391                         if ( yy_next_state )
1392                                 {
1393                                 /* Consume the NUL. */
1394                                 yy_cp = ++(yy_c_buf_p);
1395                                 yy_current_state = yy_next_state;
1396                                 goto yy_match;
1397                                 }
1399                         else
1400                                 {
1401                                 yy_cp = (yy_c_buf_p);
1402                                 goto yy_find_action;
1403                                 }
1404                         }
1406                 else switch ( yy_get_next_buffer(  ) )
1407                         {
1408                         case EOB_ACT_END_OF_FILE:
1409                                 {
1410                                 (yy_did_buffer_switch_on_eof) = 0;
1412                                 if ( zconfwrap( ) )
1413                                         {
1414                                         /* Note: because we've taken care in
1415                                          * yy_get_next_buffer() to have set up
1416                                          * zconftext, we can now set up
1417                                          * yy_c_buf_p so that if some total
1418                                          * hoser (like flex itself) wants to
1419                                          * call the scanner after we return the
1420                                          * YY_NULL, it'll still work - another
1421                                          * YY_NULL will get returned.
1422                                          */
1423                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1425                                         yy_act = YY_STATE_EOF(YY_START);
1426                                         goto do_action;
1427                                         }
1429                                 else
1430                                         {
1431                                         if ( ! (yy_did_buffer_switch_on_eof) )
1432                                                 YY_NEW_FILE;
1433                                         }
1434                                 break;
1435                                 }
1437                         case EOB_ACT_CONTINUE_SCAN:
1438                                 (yy_c_buf_p) =
1439                                         (yytext_ptr) + yy_amount_of_matched_text;
1441                                 yy_current_state = yy_get_previous_state(  );
1443                                 yy_cp = (yy_c_buf_p);
1444                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1445                                 goto yy_match;
1447                         case EOB_ACT_LAST_MATCH:
1448                                 (yy_c_buf_p) =
1449                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1451                                 yy_current_state = yy_get_previous_state(  );
1453                                 yy_cp = (yy_c_buf_p);
1454                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1455                                 goto yy_find_action;
1456                         }
1457                 break;
1458                 }
1460         default:
1461                 YY_FATAL_ERROR(
1462                         "fatal flex scanner internal error--no action found" );
1463         } /* end of action switch */
1464                 } /* end of scanning one token */
1465 } /* end of zconflex */
1467 /* yy_get_next_buffer - try to read in a new buffer
1469  * Returns a code representing an action:
1470  *      EOB_ACT_LAST_MATCH -
1471  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1472  *      EOB_ACT_END_OF_FILE - end of file
1473  */
1474 static int yy_get_next_buffer (void)
1476         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1477         register char *source = (yytext_ptr);
1478         register int number_to_move, i;
1479         int ret_val;
1481         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1482                 YY_FATAL_ERROR(
1483                 "fatal flex scanner internal error--end of buffer missed" );
1485         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1486                 { /* Don't try to fill the buffer, so this is an EOF. */
1487                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1488                         {
1489                         /* We matched a single character, the EOB, so
1490                          * treat this as a final EOF.
1491                          */
1492                         return EOB_ACT_END_OF_FILE;
1493                         }
1495                 else
1496                         {
1497                         /* We matched some text prior to the EOB, first
1498                          * process it.
1499                          */
1500                         return EOB_ACT_LAST_MATCH;
1501                         }
1502                 }
1504         /* Try to read more data. */
1506         /* First move last chars to start of buffer. */
1507         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1509         for ( i = 0; i < number_to_move; ++i )
1510                 *(dest++) = *(source++);
1512         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1513                 /* don't do the read, it's not guaranteed to return an EOF,
1514                  * just force an EOF
1515                  */
1516                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1518         else
1519                 {
1520                         int num_to_read =
1521                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1523                 while ( num_to_read <= 0 )
1524                         { /* Not enough room in the buffer - grow it. */
1526                         /* just a shorter name for the current buffer */
1527                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1529                         int yy_c_buf_p_offset =
1530                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1532                         if ( b->yy_is_our_buffer )
1533                                 {
1534                                 int new_size = b->yy_buf_size * 2;
1536                                 if ( new_size <= 0 )
1537                                         b->yy_buf_size += b->yy_buf_size / 8;
1538                                 else
1539                                         b->yy_buf_size *= 2;
1541                                 b->yy_ch_buf = (char *)
1542                                         /* Include room in for 2 EOB chars. */
1543                                         zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1544                                 }
1545                         else
1546                                 /* Can't grow it, we don't own it. */
1547                                 b->yy_ch_buf = 0;
1549                         if ( ! b->yy_ch_buf )
1550                                 YY_FATAL_ERROR(
1551                                 "fatal error - scanner input buffer overflow" );
1553                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1555                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1556                                                 number_to_move - 1;
1558                         }
1560                 if ( num_to_read > YY_READ_BUF_SIZE )
1561                         num_to_read = YY_READ_BUF_SIZE;
1563                 /* Read in more data. */
1564                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1565                         (yy_n_chars), (size_t) num_to_read );
1567                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1568                 }
1570         if ( (yy_n_chars) == 0 )
1571                 {
1572                 if ( number_to_move == YY_MORE_ADJ )
1573                         {
1574                         ret_val = EOB_ACT_END_OF_FILE;
1575                         zconfrestart(zconfin  );
1576                         }
1578                 else
1579                         {
1580                         ret_val = EOB_ACT_LAST_MATCH;
1581                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1582                                 YY_BUFFER_EOF_PENDING;
1583                         }
1584                 }
1586         else
1587                 ret_val = EOB_ACT_CONTINUE_SCAN;
1589         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1590                 /* Extend the array by 50%, plus the number we really need. */
1591                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1592                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) zconfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1593                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1594                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1595         }
1597         (yy_n_chars) += number_to_move;
1598         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1599         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1601         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1603         return ret_val;
1606 /* yy_get_previous_state - get the state just before the EOB char was reached */
1608     static yy_state_type yy_get_previous_state (void)
1610         register yy_state_type yy_current_state;
1611         register char *yy_cp;
1612     
1613         yy_current_state = (yy_start);
1615         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1616                 {
1617                 yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
1618                 }
1620         return yy_current_state;
1623 /* yy_try_NUL_trans - try to make a transition on the NUL character
1625  * synopsis
1626  *      next_state = yy_try_NUL_trans( current_state );
1627  */
1628     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1630         register int yy_is_jam;
1631     
1632         yy_current_state = yy_nxt[yy_current_state][1];
1633         yy_is_jam = (yy_current_state <= 0);
1635         return yy_is_jam ? 0 : yy_current_state;
1638     static void yyunput (int c, register char * yy_bp )
1640         register char *yy_cp;
1641     
1642     yy_cp = (yy_c_buf_p);
1644         /* undo effects of setting up zconftext */
1645         *yy_cp = (yy_hold_char);
1647         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1648                 { /* need to shift things up to make room */
1649                 /* +2 for EOB chars. */
1650                 register int number_to_move = (yy_n_chars) + 2;
1651                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1652                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1653                 register char *source =
1654                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1656                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1657                         *--dest = *--source;
1659                 yy_cp += (int) (dest - source);
1660                 yy_bp += (int) (dest - source);
1661                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1662                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1664                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1665                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1666                 }
1668         *--yy_cp = (char) c;
1670         (yytext_ptr) = yy_bp;
1671         (yy_hold_char) = *yy_cp;
1672         (yy_c_buf_p) = yy_cp;
1675 #ifndef YY_NO_INPUT
1676 #ifdef __cplusplus
1677     static int yyinput (void)
1678 #else
1679     static int input  (void)
1680 #endif
1683         int c;
1684     
1685         *(yy_c_buf_p) = (yy_hold_char);
1687         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1688                 {
1689                 /* yy_c_buf_p now points to the character we want to return.
1690                  * If this occurs *before* the EOB characters, then it's a
1691                  * valid NUL; if not, then we've hit the end of the buffer.
1692                  */
1693                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1694                         /* This was really a NUL. */
1695                         *(yy_c_buf_p) = '\0';
1697                 else
1698                         { /* need more input */
1699                         int offset = (yy_c_buf_p) - (yytext_ptr);
1700                         ++(yy_c_buf_p);
1702                         switch ( yy_get_next_buffer(  ) )
1703                                 {
1704                                 case EOB_ACT_LAST_MATCH:
1705                                         /* This happens because yy_g_n_b()
1706                                          * sees that we've accumulated a
1707                                          * token and flags that we need to
1708                                          * try matching the token before
1709                                          * proceeding.  But for input(),
1710                                          * there's no matching to consider.
1711                                          * So convert the EOB_ACT_LAST_MATCH
1712                                          * to EOB_ACT_END_OF_FILE.
1713                                          */
1715                                         /* Reset buffer status. */
1716                                         zconfrestart(zconfin );
1718                                         /*FALLTHROUGH*/
1720                                 case EOB_ACT_END_OF_FILE:
1721                                         {
1722                                         if ( zconfwrap( ) )
1723                                                 return EOF;
1725                                         if ( ! (yy_did_buffer_switch_on_eof) )
1726                                                 YY_NEW_FILE;
1727 #ifdef __cplusplus
1728                                         return yyinput();
1729 #else
1730                                         return input();
1731 #endif
1732                                         }
1734                                 case EOB_ACT_CONTINUE_SCAN:
1735                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1736                                         break;
1737                                 }
1738                         }
1739                 }
1741         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1742         *(yy_c_buf_p) = '\0';   /* preserve zconftext */
1743         (yy_hold_char) = *++(yy_c_buf_p);
1745         return c;
1747 #endif  /* ifndef YY_NO_INPUT */
1749 /** Immediately switch to a different input stream.
1750  * @param input_file A readable stream.
1751  * 
1752  * @note This function does not reset the start condition to @c INITIAL .
1753  */
1754     void zconfrestart  (FILE * input_file )
1756     
1757         if ( ! YY_CURRENT_BUFFER ){
1758         zconfensure_buffer_stack ();
1759                 YY_CURRENT_BUFFER_LVALUE =
1760             zconf_create_buffer(zconfin,YY_BUF_SIZE );
1761         }
1763         zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
1764         zconf_load_buffer_state( );
1767 /** Switch to a different input buffer.
1768  * @param new_buffer The new input buffer.
1769  * 
1770  */
1771     void zconf_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1773     
1774         /* TODO. We should be able to replace this entire function body
1775          * with
1776          *              zconfpop_buffer_state();
1777          *              zconfpush_buffer_state(new_buffer);
1778      */
1779         zconfensure_buffer_stack ();
1780         if ( YY_CURRENT_BUFFER == new_buffer )
1781                 return;
1783         if ( YY_CURRENT_BUFFER )
1784                 {
1785                 /* Flush out information for old buffer. */
1786                 *(yy_c_buf_p) = (yy_hold_char);
1787                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1788                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1789                 }
1791         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1792         zconf_load_buffer_state( );
1794         /* We don't actually know whether we did this switch during
1795          * EOF (zconfwrap()) processing, but the only time this flag
1796          * is looked at is after zconfwrap() is called, so it's safe
1797          * to go ahead and always set it.
1798          */
1799         (yy_did_buffer_switch_on_eof) = 1;
1802 static void zconf_load_buffer_state  (void)
1804         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1805         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1806         zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1807         (yy_hold_char) = *(yy_c_buf_p);
1810 /** Allocate and initialize an input buffer state.
1811  * @param file A readable stream.
1812  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1813  * 
1814  * @return the allocated buffer state.
1815  */
1816     YY_BUFFER_STATE zconf_create_buffer  (FILE * file, int  size )
1818         YY_BUFFER_STATE b;
1819     
1820         b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
1821         if ( ! b )
1822                 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1824         b->yy_buf_size = size;
1826         /* yy_ch_buf has to be 2 characters longer than the size given because
1827          * we need to put in 2 end-of-buffer characters.
1828          */
1829         b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2  );
1830         if ( ! b->yy_ch_buf )
1831                 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1833         b->yy_is_our_buffer = 1;
1835         zconf_init_buffer(b,file );
1837         return b;
1840 /** Destroy the buffer.
1841  * @param b a buffer created with zconf_create_buffer()
1842  * 
1843  */
1844     void zconf_delete_buffer (YY_BUFFER_STATE  b )
1846     
1847         if ( ! b )
1848                 return;
1850         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1851                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1853         if ( b->yy_is_our_buffer )
1854                 zconffree((void *) b->yy_ch_buf  );
1856         zconffree((void *) b  );
1859 /* Initializes or reinitializes a buffer.
1860  * This function is sometimes called more than once on the same buffer,
1861  * such as during a zconfrestart() or at EOF.
1862  */
1863     static void zconf_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1866         int oerrno = errno;
1867     
1868         zconf_flush_buffer(b );
1870         b->yy_input_file = file;
1871         b->yy_fill_buffer = 1;
1873     /* If b is the current buffer, then zconf_init_buffer was _probably_
1874      * called from zconfrestart() or through yy_get_next_buffer.
1875      * In that case, we don't want to reset the lineno or column.
1876      */
1877     if (b != YY_CURRENT_BUFFER){
1878         b->yy_bs_lineno = 1;
1879         b->yy_bs_column = 0;
1880     }
1882         b->yy_is_interactive = 0;
1883     
1884         errno = oerrno;
1887 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1888  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1889  * 
1890  */
1891     void zconf_flush_buffer (YY_BUFFER_STATE  b )
1893         if ( ! b )
1894                 return;
1896         b->yy_n_chars = 0;
1898         /* We always need two end-of-buffer characters.  The first causes
1899          * a transition to the end-of-buffer state.  The second causes
1900          * a jam in that state.
1901          */
1902         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1903         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1905         b->yy_buf_pos = &b->yy_ch_buf[0];
1907         b->yy_at_bol = 1;
1908         b->yy_buffer_status = YY_BUFFER_NEW;
1910         if ( b == YY_CURRENT_BUFFER )
1911                 zconf_load_buffer_state( );
1914 /** Pushes the new state onto the stack. The new state becomes
1915  *  the current state. This function will allocate the stack
1916  *  if necessary.
1917  *  @param new_buffer The new state.
1918  *  
1919  */
1920 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
1922         if (new_buffer == NULL)
1923                 return;
1925         zconfensure_buffer_stack();
1927         /* This block is copied from zconf_switch_to_buffer. */
1928         if ( YY_CURRENT_BUFFER )
1929                 {
1930                 /* Flush out information for old buffer. */
1931                 *(yy_c_buf_p) = (yy_hold_char);
1932                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1933                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1934                 }
1936         /* Only push if top exists. Otherwise, replace top. */
1937         if (YY_CURRENT_BUFFER)
1938                 (yy_buffer_stack_top)++;
1939         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1941         /* copied from zconf_switch_to_buffer. */
1942         zconf_load_buffer_state( );
1943         (yy_did_buffer_switch_on_eof) = 1;
1946 /** Removes and deletes the top of the stack, if present.
1947  *  The next element becomes the new top.
1948  *  
1949  */
1950 void zconfpop_buffer_state (void)
1952         if (!YY_CURRENT_BUFFER)
1953                 return;
1955         zconf_delete_buffer(YY_CURRENT_BUFFER );
1956         YY_CURRENT_BUFFER_LVALUE = NULL;
1957         if ((yy_buffer_stack_top) > 0)
1958                 --(yy_buffer_stack_top);
1960         if (YY_CURRENT_BUFFER) {
1961                 zconf_load_buffer_state( );
1962                 (yy_did_buffer_switch_on_eof) = 1;
1963         }
1966 /* Allocates the stack if it does not exist.
1967  *  Guarantees space for at least one push.
1968  */
1969 static void zconfensure_buffer_stack (void)
1971         int num_to_alloc;
1972     
1973         if (!(yy_buffer_stack)) {
1975                 /* First allocation is just for 2 elements, since we don't know if this
1976                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1977                  * immediate realloc on the next call.
1978          */
1979                 num_to_alloc = 1;
1980                 (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
1981                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1982                                                                 );
1983                 if ( ! (yy_buffer_stack) )
1984                         YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
1985                                                                   
1986                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1987                                 
1988                 (yy_buffer_stack_max) = num_to_alloc;
1989                 (yy_buffer_stack_top) = 0;
1990                 return;
1991         }
1993         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1995                 /* Increase the buffer to prepare for a possible push. */
1996                 int grow_size = 8 /* arbitrary grow size */;
1998                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1999                 (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
2000                                                                 ((yy_buffer_stack),
2001                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2002                                                                 );
2003                 if ( ! (yy_buffer_stack) )
2004                         YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
2006                 /* zero only the new slots.*/
2007                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2008                 (yy_buffer_stack_max) = num_to_alloc;
2009         }
2012 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2013  * @param base the character buffer
2014  * @param size the size in bytes of the character buffer
2015  * 
2016  * @return the newly allocated buffer state object. 
2017  */
2018 YY_BUFFER_STATE zconf_scan_buffer  (char * base, yy_size_t  size )
2020         YY_BUFFER_STATE b;
2021     
2022         if ( size < 2 ||
2023              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2024              base[size-1] != YY_END_OF_BUFFER_CHAR )
2025                 /* They forgot to leave room for the EOB's. */
2026                 return 0;
2028         b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
2029         if ( ! b )
2030                 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
2032         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2033         b->yy_buf_pos = b->yy_ch_buf = base;
2034         b->yy_is_our_buffer = 0;
2035         b->yy_input_file = 0;
2036         b->yy_n_chars = b->yy_buf_size;
2037         b->yy_is_interactive = 0;
2038         b->yy_at_bol = 1;
2039         b->yy_fill_buffer = 0;
2040         b->yy_buffer_status = YY_BUFFER_NEW;
2042         zconf_switch_to_buffer(b  );
2044         return b;
2047 /** Setup the input buffer state to scan a string. The next call to zconflex() will
2048  * scan from a @e copy of @a str.
2049  * @param yystr a NUL-terminated string to scan
2050  * 
2051  * @return the newly allocated buffer state object.
2052  * @note If you want to scan bytes that may contain NUL values, then use
2053  *       zconf_scan_bytes() instead.
2054  */
2055 YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
2057     
2058         return zconf_scan_bytes(yystr,strlen(yystr) );
2061 /** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
2062  * scan from a @e copy of @a bytes.
2063  * @param bytes the byte buffer to scan
2064  * @param len the number of bytes in the buffer pointed to by @a bytes.
2065  * 
2066  * @return the newly allocated buffer state object.
2067  */
2068 YY_BUFFER_STATE zconf_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2070         YY_BUFFER_STATE b;
2071         char *buf;
2072         yy_size_t n;
2073         int i;
2074     
2075         /* Get memory for full buffer, including space for trailing EOB's. */
2076         n = _yybytes_len + 2;
2077         buf = (char *) zconfalloc(n  );
2078         if ( ! buf )
2079                 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
2081         for ( i = 0; i < _yybytes_len; ++i )
2082                 buf[i] = yybytes[i];
2084         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2086         b = zconf_scan_buffer(buf,n );
2087         if ( ! b )
2088                 YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
2090         /* It's okay to grow etc. this buffer, and we should throw it
2091          * away when we're done.
2092          */
2093         b->yy_is_our_buffer = 1;
2095         return b;
2098 #ifndef YY_EXIT_FAILURE
2099 #define YY_EXIT_FAILURE 2
2100 #endif
2102 static void yy_fatal_error (yyconst char* msg )
2104         (void) fprintf( stderr, "%s\n", msg );
2105         exit( YY_EXIT_FAILURE );
2108 /* Redefine yyless() so it works in section 3 code. */
2110 #undef yyless
2111 #define yyless(n) \
2112         do \
2113                 { \
2114                 /* Undo effects of setting up zconftext. */ \
2115         int yyless_macro_arg = (n); \
2116         YY_LESS_LINENO(yyless_macro_arg);\
2117                 zconftext[zconfleng] = (yy_hold_char); \
2118                 (yy_c_buf_p) = zconftext + yyless_macro_arg; \
2119                 (yy_hold_char) = *(yy_c_buf_p); \
2120                 *(yy_c_buf_p) = '\0'; \
2121                 zconfleng = yyless_macro_arg; \
2122                 } \
2123         while ( 0 )
2125 /* Accessor  methods (get/set functions) to struct members. */
2127 /** Get the current line number.
2128  * 
2129  */
2130 int zconfget_lineno  (void)
2132         
2133     return zconflineno;
2136 /** Get the input stream.
2137  * 
2138  */
2139 FILE *zconfget_in  (void)
2141         return zconfin;
2144 /** Get the output stream.
2145  * 
2146  */
2147 FILE *zconfget_out  (void)
2149         return zconfout;
2152 /** Get the length of the current token.
2153  * 
2154  */
2155 int zconfget_leng  (void)
2157         return zconfleng;
2160 /** Get the current token.
2161  * 
2162  */
2164 char *zconfget_text  (void)
2166         return zconftext;
2169 /** Set the current line number.
2170  * @param line_number
2171  * 
2172  */
2173 void zconfset_lineno (int  line_number )
2175     
2176     zconflineno = line_number;
2179 /** Set the input stream. This does not discard the current
2180  * input buffer.
2181  * @param in_str A readable stream.
2182  * 
2183  * @see zconf_switch_to_buffer
2184  */
2185 void zconfset_in (FILE *  in_str )
2187         zconfin = in_str ;
2190 void zconfset_out (FILE *  out_str )
2192         zconfout = out_str ;
2195 int zconfget_debug  (void)
2197         return zconf_flex_debug;
2200 void zconfset_debug (int  bdebug )
2202         zconf_flex_debug = bdebug ;
2205 static int yy_init_globals (void)
2207         /* Initialization is the same as for the non-reentrant scanner.
2208      * This function is called from zconflex_destroy(), so don't allocate here.
2209      */
2211     (yy_buffer_stack) = 0;
2212     (yy_buffer_stack_top) = 0;
2213     (yy_buffer_stack_max) = 0;
2214     (yy_c_buf_p) = (char *) 0;
2215     (yy_init) = 0;
2216     (yy_start) = 0;
2218 /* Defined in main.c */
2219 #ifdef YY_STDINIT
2220     zconfin = stdin;
2221     zconfout = stdout;
2222 #else
2223     zconfin = (FILE *) 0;
2224     zconfout = (FILE *) 0;
2225 #endif
2227     /* For future reference: Set errno on error, since we are called by
2228      * zconflex_init()
2229      */
2230     return 0;
2233 /* zconflex_destroy is for both reentrant and non-reentrant scanners. */
2234 int zconflex_destroy  (void)
2236     
2237     /* Pop the buffer stack, destroying each element. */
2238         while(YY_CURRENT_BUFFER){
2239                 zconf_delete_buffer(YY_CURRENT_BUFFER  );
2240                 YY_CURRENT_BUFFER_LVALUE = NULL;
2241                 zconfpop_buffer_state();
2242         }
2244         /* Destroy the stack itself. */
2245         zconffree((yy_buffer_stack) );
2246         (yy_buffer_stack) = NULL;
2248     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2249      * zconflex() is called, initialization will occur. */
2250     yy_init_globals( );
2252     return 0;
2256  * Internal utility routines.
2257  */
2259 #ifndef yytext_ptr
2260 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2262         register int i;
2263         for ( i = 0; i < n; ++i )
2264                 s1[i] = s2[i];
2266 #endif
2268 #ifdef YY_NEED_STRLEN
2269 static int yy_flex_strlen (yyconst char * s )
2271         register int n;
2272         for ( n = 0; s[n]; ++n )
2273                 ;
2275         return n;
2277 #endif
2279 void *zconfalloc (yy_size_t  size )
2281         return (void *) malloc( size );
2284 void *zconfrealloc  (void * ptr, yy_size_t  size )
2286         /* The cast to (char *) in the following accommodates both
2287          * implementations that use char* generic pointers, and those
2288          * that use void* generic pointers.  It works with the latter
2289          * because both ANSI C and C++ allow castless assignment from
2290          * any pointer type to void*, and deal with argument conversions
2291          * as though doing an assignment.
2292          */
2293         return (void *) realloc( (char *) ptr, size );
2296 void zconffree (void * ptr )
2298         free( (char *) ptr );   /* see zconfrealloc() for (char *) cast */
2301 #define YYTABLES_NAME "yytables"
2303 void zconf_starthelp(void)
2305         new_string();
2306         last_ts = first_ts = 0;
2307         BEGIN(HELP);
2310 static void zconf_endhelp(void)
2312         zconflval.string = text;
2313         BEGIN(INITIAL);
2317  * Try to open specified file with following names:
2318  * ./name
2319  * $(srctree)/name
2320  * The latter is used when srctree is separate from objtree
2321  * when compiling the kernel.
2322  * Return NULL if file is not found.
2323  */
2324 FILE *zconf_fopen(const char *name)
2326         char *env, fullname[PATH_MAX+1];
2327         FILE *f;
2329         f = fopen(name, "r");
2330         if (!f && name != NULL && name[0] != '/') {
2331                 env = getenv(SRCTREE);
2332                 if (env) {
2333                         sprintf(fullname, "%s/%s", env, name);
2334                         f = fopen(fullname, "r");
2335                 }
2336         }
2337         return f;
2340 void zconf_initscan(const char *name)
2342         zconfin = zconf_fopen(name);
2343         if (!zconfin) {
2344                 printf("can't find file %s\n", name);
2345                 exit(1);
2346         }
2348         current_buf = malloc(sizeof(*current_buf));
2349         memset(current_buf, 0, sizeof(*current_buf));
2351         current_file = file_lookup(name);
2352         current_file->lineno = 1;
2353         current_file->flags = FILE_BUSY;
2356 void zconf_nextfile(const char *name)
2358         struct file *file = file_lookup(name);
2359         struct buffer *buf = malloc(sizeof(*buf));
2360         memset(buf, 0, sizeof(*buf));
2362         current_buf->state = YY_CURRENT_BUFFER;
2363         zconfin = zconf_fopen(name);
2364         if (!zconfin) {
2365                 printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
2366                 exit(1);
2367         }
2368         zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
2369         buf->parent = current_buf;
2370         current_buf = buf;
2372         if (file->flags & FILE_BUSY) {
2373                 printf("%s:%d: do not source '%s' from itself\n",
2374                        zconf_curname(), zconf_lineno(), name);
2375                 exit(1);
2376         }
2377         if (file->flags & FILE_SCANNED) {
2378                 printf("%s:%d: file '%s' is already sourced from '%s'\n",
2379                        zconf_curname(), zconf_lineno(), name,
2380                        file->parent->name);
2381                 exit(1);
2382         }
2383         file->flags |= FILE_BUSY;
2384         file->lineno = 1;
2385         file->parent = current_file;
2386         current_file = file;
2389 static void zconf_endfile(void)
2391         struct buffer *parent;
2393         current_file->flags |= FILE_SCANNED;
2394         current_file->flags &= ~FILE_BUSY;
2395         current_file = current_file->parent;
2397         parent = current_buf->parent;
2398         if (parent) {
2399                 fclose(zconfin);
2400                 zconf_delete_buffer(YY_CURRENT_BUFFER);
2401                 zconf_switch_to_buffer(parent->state);
2402         }
2403         free(current_buf);
2404         current_buf = parent;
2407 int zconf_lineno(void)
2409         return current_pos.lineno;
2412 char *zconf_curname(void)
2414         return current_pos.file ? current_pos.file->name : "<none>";