source: debwrt/trunk/config/mconf/lex.zconf.c_shipped @ 1

Last change on this file since 1 was 1, checked in by amain, 13 years ago

Initial import of the build environment for DebWrt

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