Chameleon

Chameleon Svn Source Tree

Root/branches/chucko/i386/config/lex.zconf.c

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

Archive Download this file

Revision: 2295