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