blob: 7342ce0a77801ff031e81e88f6ff1de3d48e7f4e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001
Roman Zippel7a884882005-11-08 21:34:51 -08002#line 3 "scripts/kconfig/lex.zconf.c"
Linus Torvalds1da177e2005-04-16 15:20:36 -07003
4#define YY_INT_ALIGNED short int
5
6/* A lexical scanner generated by flex */
7
Adrian Bunkbe2be1d2008-07-17 02:07:59 +03008#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#define FLEX_SCANNER
28#define YY_FLEX_MAJOR_VERSION 2
29#define YY_FLEX_MINOR_VERSION 5
Adrian Bunkbe2be1d2008-07-17 02:07:59 +030030#define YY_FLEX_SUBMINOR_VERSION 35
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#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
Adrian Bunkbe2be1d2008-07-17 02:07:59 +030052#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
Roman Zippelf6a88aa2006-06-08 22:12:44 -070053
54/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
Sam Ravnborg14f31562007-09-26 20:15:39 +020055 * if you want the limit (max/min) macros for int types.
Roman Zippelf6a88aa2006-06-08 22:12:44 -070056 */
57#ifndef __STDC_LIMIT_MACROS
58#define __STDC_LIMIT_MACROS 1
59#endif
60
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
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
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300105#endif /* ! C99 */
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#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
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300116/* C99 requires __STDC__ to be defined as 1. */
117#if defined (__STDC__)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119#define YY_USE_CONST
120
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300121#endif /* defined (__STDC__) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122#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
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700166/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170#ifndef YY_TYPEDEF_YY_BUFFER_STATE
171#define YY_TYPEDEF_YY_BUFFER_STATE
172typedef struct yy_buffer_state *YY_BUFFER_STATE;
173#endif
174
175extern int zconfleng;
176
177extern FILE *zconfin, *zconfout;
178
179#define EOB_ACT_CONTINUE_SCAN 0
180#define EOB_ACT_END_OF_FILE 1
181#define EOB_ACT_LAST_MATCH 2
182
183 #define YY_LESS_LINENO(n)
184
185/* Return all but the first "n" matched characters back to the input stream. */
186#define yyless(n) \
187 do \
188 { \
189 /* Undo effects of setting up zconftext. */ \
190 int yyless_macro_arg = (n); \
191 YY_LESS_LINENO(yyless_macro_arg);\
192 *yy_cp = (yy_hold_char); \
193 YY_RESTORE_YY_MORE_OFFSET \
194 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195 YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
196 } \
197 while ( 0 )
198
199#define unput(c) yyunput( c, (yytext_ptr) )
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201#ifndef YY_TYPEDEF_YY_SIZE_T
202#define YY_TYPEDEF_YY_SIZE_T
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300203typedef size_t yy_size_t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204#endif
205
206#ifndef YY_STRUCT_YY_BUFFER_STATE
207#define YY_STRUCT_YY_BUFFER_STATE
208struct 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 int 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. */
272static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
273static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
274static 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. */
292static char yy_hold_char;
293static int yy_n_chars; /* number of characters read into yy_ch_buf */
294int zconfleng;
295
296/* Points to current character in buffer. */
297static char *yy_c_buf_p = (char *) 0;
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700298static int yy_init = 0; /* whether we need to initialize */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299static 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 */
304static int yy_did_buffer_switch_on_eof;
305
306void zconfrestart (FILE *input_file );
307void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer );
308YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size );
309void zconf_delete_buffer (YY_BUFFER_STATE b );
310void zconf_flush_buffer (YY_BUFFER_STATE b );
311void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer );
312void zconfpop_buffer_state (void );
313
314static void zconfensure_buffer_stack (void );
315static void zconf_load_buffer_state (void );
316static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file );
317
318#define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
319
320YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size );
321YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str );
322YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len );
323
324void *zconfalloc (yy_size_t );
325void *zconfrealloc (void *,yy_size_t );
326void 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
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300354#define zconfwrap(n) 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355#define YY_SKIP_YYWRAP
356
357typedef unsigned char YY_CHAR;
358
359FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
360
361typedef int yy_state_type;
362
363extern int zconflineno;
364
365int zconflineno = 1;
366
367extern char *zconftext;
368#define yytext_ptr zconftext
Roman Zippel7a884882005-11-08 21:34:51 -0800369static yyconst flex_int16_t yy_nxt[][17] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 {
371 {
372 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Roman Zippel7a884882005-11-08 21:34:51 -0800373 0, 0, 0, 0, 0, 0, 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 },
375
376 {
377 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
Roman Zippel7a884882005-11-08 21:34:51 -0800378 12, 12, 12, 12, 12, 12, 12
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 },
380
381 {
382 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
Roman Zippel7a884882005-11-08 21:34:51 -0800383 12, 12, 12, 12, 12, 12, 12
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 },
385
386 {
387 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
Roman Zippel7a884882005-11-08 21:34:51 -0800388 16, 16, 16, 18, 16, 16, 16
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 },
390
391 {
392 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
Roman Zippel7a884882005-11-08 21:34:51 -0800393 16, 16, 16, 18, 16, 16, 16
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 },
396
397 {
Roman Zippel7a884882005-11-08 21:34:51 -0800398 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
399 19, 19, 19, 19, 19, 19, 19
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 },
401
402 {
Roman Zippel7a884882005-11-08 21:34:51 -0800403 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
404 19, 19, 19, 19, 19, 19, 19
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 },
406
407 {
Roman Zippel7a884882005-11-08 21:34:51 -0800408 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
409 22, 22, 22, 22, 22, 25, 22
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 },
411
412 {
Roman Zippel7a884882005-11-08 21:34:51 -0800413 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
414 22, 22, 22, 22, 22, 25, 22
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 },
416
417 {
Roman Zippel7a884882005-11-08 21:34:51 -0800418 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
419 33, 34, 35, 35, 36, 37, 38
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 },
422
423 {
Roman Zippel7a884882005-11-08 21:34:51 -0800424 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
425 33, 34, 35, 35, 36, 37, 38
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 },
427
428 {
429 -11, -11, -11, -11, -11, -11, -11, -11, -11, -11,
Roman Zippel7a884882005-11-08 21:34:51 -0800430 -11, -11, -11, -11, -11, -11, -11
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 },
432
433 {
434 11, -12, -12, -12, -12, -12, -12, -12, -12, -12,
Roman Zippel7a884882005-11-08 21:34:51 -0800435 -12, -12, -12, -12, -12, -12, -12
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 },
437
438 {
Roman Zippel7a884882005-11-08 21:34:51 -0800439 11, -13, 39, 40, -13, -13, 41, -13, -13, -13,
440 -13, -13, -13, -13, -13, -13, -13
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 },
442
443 {
444 11, -14, -14, -14, -14, -14, -14, -14, -14, -14,
Roman Zippel7a884882005-11-08 21:34:51 -0800445 -14, -14, -14, -14, -14, -14, -14
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
447 },
448
449 {
Roman Zippel7a884882005-11-08 21:34:51 -0800450 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
451 42, 42, 42, 42, 42, 42, 42
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 },
453
454 {
455 11, -16, -16, -16, -16, -16, -16, -16, -16, -16,
Roman Zippel7a884882005-11-08 21:34:51 -0800456 -16, -16, -16, -16, -16, -16, -16
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 },
458
459 {
460 11, -17, -17, -17, -17, -17, -17, -17, -17, -17,
Roman Zippel7a884882005-11-08 21:34:51 -0800461 -17, -17, -17, -17, -17, -17, -17
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 },
463
464 {
465 11, -18, -18, -18, -18, -18, -18, -18, -18, -18,
Roman Zippel7a884882005-11-08 21:34:51 -0800466 -18, -18, -18, 44, -18, -18, -18
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 },
468
469 {
Roman Zippel7a884882005-11-08 21:34:51 -0800470 11, 45, 45, -19, 45, 45, 45, 45, 45, 45,
471 45, 45, 45, 45, 45, 45, 45
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473 },
474
475 {
Roman Zippel7a884882005-11-08 21:34:51 -0800476 11, -20, 46, 47, -20, -20, -20, -20, -20, -20,
477 -20, -20, -20, -20, -20, -20, -20
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 },
479
480 {
Roman Zippel7a884882005-11-08 21:34:51 -0800481 11, 48, -21, -21, 48, 48, 48, 48, 48, 48,
482 48, 48, 48, 48, 48, 48, 48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 },
484
485 {
Roman Zippel7a884882005-11-08 21:34:51 -0800486 11, 49, 49, 50, 49, -22, 49, 49, -22, 49,
487 49, 49, 49, 49, 49, -22, 49
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 },
489
490 {
491 11, -23, -23, -23, -23, -23, -23, -23, -23, -23,
Roman Zippel7a884882005-11-08 21:34:51 -0800492 -23, -23, -23, -23, -23, -23, -23
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 },
494
495 {
496 11, -24, -24, -24, -24, -24, -24, -24, -24, -24,
Roman Zippel7a884882005-11-08 21:34:51 -0800497 -24, -24, -24, -24, -24, -24, -24
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
499 },
500
501 {
Roman Zippel7a884882005-11-08 21:34:51 -0800502 11, 51, 51, 52, 51, 51, 51, 51, 51, 51,
503 51, 51, 51, 51, 51, 51, 51
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 },
505
506 {
507 11, -26, -26, -26, -26, -26, -26, -26, -26, -26,
Roman Zippel7a884882005-11-08 21:34:51 -0800508 -26, -26, -26, -26, -26, -26, -26
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 },
510
511 {
512 11, -27, -27, -27, -27, -27, -27, -27, -27, -27,
Roman Zippel7a884882005-11-08 21:34:51 -0800513 -27, -27, -27, -27, -27, -27, -27
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 },
515
516 {
517 11, -28, -28, -28, -28, -28, -28, -28, -28, -28,
Roman Zippel7a884882005-11-08 21:34:51 -0800518 -28, -28, -28, -28, 53, -28, -28
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 },
520
521 {
522 11, -29, -29, -29, -29, -29, -29, -29, -29, -29,
Roman Zippel7a884882005-11-08 21:34:51 -0800523 -29, -29, -29, -29, -29, -29, -29
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524
525 },
526
527 {
Roman Zippel7a884882005-11-08 21:34:51 -0800528 11, 54, 54, -30, 54, 54, 54, 54, 54, 54,
529 54, 54, 54, 54, 54, 54, 54
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 },
531
532 {
Roman Zippel7a884882005-11-08 21:34:51 -0800533 11, -31, -31, -31, -31, -31, -31, 55, -31, -31,
534 -31, -31, -31, -31, -31, -31, -31
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 },
536
537 {
Roman Zippel7a884882005-11-08 21:34:51 -0800538 11, -32, -32, -32, -32, -32, -32, -32, -32, -32,
539 -32, -32, -32, -32, -32, -32, -32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 },
541
542 {
Roman Zippel7a884882005-11-08 21:34:51 -0800543 11, -33, -33, -33, -33, -33, -33, -33, -33, -33,
544 -33, -33, -33, -33, -33, -33, -33
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 },
546
547 {
Roman Zippel7a884882005-11-08 21:34:51 -0800548 11, -34, -34, -34, -34, -34, -34, -34, -34, -34,
549 -34, 56, 57, 57, -34, -34, -34
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
551 },
552
553 {
554 11, -35, -35, -35, -35, -35, -35, -35, -35, -35,
Roman Zippel7a884882005-11-08 21:34:51 -0800555 -35, 57, 57, 57, -35, -35, -35
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 },
557
558 {
559 11, -36, -36, -36, -36, -36, -36, -36, -36, -36,
Roman Zippel7a884882005-11-08 21:34:51 -0800560 -36, -36, -36, -36, -36, -36, -36
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 },
562
563 {
Roman Zippel7a884882005-11-08 21:34:51 -0800564 11, -37, -37, 58, -37, -37, -37, -37, -37, -37,
565 -37, -37, -37, -37, -37, -37, -37
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 },
567
568 {
569 11, -38, -38, -38, -38, -38, -38, -38, -38, -38,
Roman Zippel7a884882005-11-08 21:34:51 -0800570 -38, -38, -38, -38, -38, -38, 59
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 },
572
573 {
Roman Zippel7a884882005-11-08 21:34:51 -0800574 11, -39, 39, 40, -39, -39, 41, -39, -39, -39,
575 -39, -39, -39, -39, -39, -39, -39
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
577 },
578
579 {
580 11, -40, -40, -40, -40, -40, -40, -40, -40, -40,
Roman Zippel7a884882005-11-08 21:34:51 -0800581 -40, -40, -40, -40, -40, -40, -40
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 },
583
584 {
Roman Zippel7a884882005-11-08 21:34:51 -0800585 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
586 42, 42, 42, 42, 42, 42, 42
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 },
588
589 {
Roman Zippel7a884882005-11-08 21:34:51 -0800590 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
591 42, 42, 42, 42, 42, 42, 42
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 },
593
594 {
Roman Zippel7a884882005-11-08 21:34:51 -0800595 11, -43, -43, -43, -43, -43, -43, -43, -43, -43,
596 -43, -43, -43, -43, -43, -43, -43
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 },
598
599 {
600 11, -44, -44, -44, -44, -44, -44, -44, -44, -44,
Roman Zippel7a884882005-11-08 21:34:51 -0800601 -44, -44, -44, 44, -44, -44, -44
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 },
604
605 {
Roman Zippel7a884882005-11-08 21:34:51 -0800606 11, 45, 45, -45, 45, 45, 45, 45, 45, 45,
607 45, 45, 45, 45, 45, 45, 45
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 },
609
610 {
Roman Zippel7a884882005-11-08 21:34:51 -0800611 11, -46, 46, 47, -46, -46, -46, -46, -46, -46,
612 -46, -46, -46, -46, -46, -46, -46
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 },
614
615 {
Roman Zippel7a884882005-11-08 21:34:51 -0800616 11, 48, -47, -47, 48, 48, 48, 48, 48, 48,
617 48, 48, 48, 48, 48, 48, 48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 },
619
620 {
621 11, -48, -48, -48, -48, -48, -48, -48, -48, -48,
Roman Zippel7a884882005-11-08 21:34:51 -0800622 -48, -48, -48, -48, -48, -48, -48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 },
624
625 {
Roman Zippel7a884882005-11-08 21:34:51 -0800626 11, 49, 49, 50, 49, -49, 49, 49, -49, 49,
627 49, 49, 49, 49, 49, -49, 49
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629 },
630
631 {
632 11, -50, -50, -50, -50, -50, -50, -50, -50, -50,
Roman Zippel7a884882005-11-08 21:34:51 -0800633 -50, -50, -50, -50, -50, -50, -50
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 },
635
636 {
Roman Zippel7a884882005-11-08 21:34:51 -0800637 11, -51, -51, 52, -51, -51, -51, -51, -51, -51,
638 -51, -51, -51, -51, -51, -51, -51
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 },
640
641 {
642 11, -52, -52, -52, -52, -52, -52, -52, -52, -52,
Roman Zippel7a884882005-11-08 21:34:51 -0800643 -52, -52, -52, -52, -52, -52, -52
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 },
645
646 {
Roman Zippel7a884882005-11-08 21:34:51 -0800647 11, -53, -53, -53, -53, -53, -53, -53, -53, -53,
648 -53, -53, -53, -53, -53, -53, -53
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 },
650
651 {
Roman Zippel7a884882005-11-08 21:34:51 -0800652 11, 54, 54, -54, 54, 54, 54, 54, 54, 54,
653 54, 54, 54, 54, 54, 54, 54
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655 },
656
657 {
Roman Zippel7a884882005-11-08 21:34:51 -0800658 11, -55, -55, -55, -55, -55, -55, -55, -55, -55,
659 -55, -55, -55, -55, -55, -55, -55
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 },
661
662 {
Roman Zippel7a884882005-11-08 21:34:51 -0800663 11, -56, -56, -56, -56, -56, -56, -56, -56, -56,
664 -56, 60, 57, 57, -56, -56, -56
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 },
666
667 {
668 11, -57, -57, -57, -57, -57, -57, -57, -57, -57,
Roman Zippel7a884882005-11-08 21:34:51 -0800669 -57, 57, 57, 57, -57, -57, -57
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 },
671
672 {
673 11, -58, -58, -58, -58, -58, -58, -58, -58, -58,
Roman Zippel7a884882005-11-08 21:34:51 -0800674 -58, -58, -58, -58, -58, -58, -58
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 },
676
677 {
678 11, -59, -59, -59, -59, -59, -59, -59, -59, -59,
Roman Zippel7a884882005-11-08 21:34:51 -0800679 -59, -59, -59, -59, -59, -59, -59
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
681 },
682
683 {
684 11, -60, -60, -60, -60, -60, -60, -60, -60, -60,
Roman Zippel7a884882005-11-08 21:34:51 -0800685 -60, 57, 57, 57, -60, -60, -60
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 },
687
688 } ;
689
690static yy_state_type yy_get_previous_state (void );
691static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
692static int yy_get_next_buffer (void );
693static 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
Roman Zippel7a884882005-11-08 21:34:51 -0800705#define YY_NUM_RULES 33
706#define YY_END_OF_BUFFER 34
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707/* This struct is not used in this scanner,
708 but its presence is necessary. */
709struct yy_trans_info
710 {
711 flex_int32_t yy_verify;
712 flex_int32_t yy_nxt;
713 };
Roman Zippel7a884882005-11-08 21:34:51 -0800714static yyconst flex_int16_t yy_accept[61] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 { 0,
716 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Roman Zippela02f0572005-11-08 21:34:53 -0800717 34, 5, 4, 2, 3, 7, 8, 6, 32, 29,
Roman Zippel7a884882005-11-08 21:34:51 -0800718 31, 24, 28, 27, 26, 22, 17, 13, 16, 20,
Roman Zippela02f0572005-11-08 21:34:53 -0800719 22, 11, 12, 19, 19, 14, 22, 22, 4, 2,
720 3, 3, 1, 6, 32, 29, 31, 30, 24, 23,
Roman Zippel7a884882005-11-08 21:34:51 -0800721 26, 25, 15, 20, 9, 19, 19, 21, 10, 18
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 } ;
723
724static 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,
Roman Zippel7a884882005-11-08 21:34:51 -0800735 1, 15, 1, 1, 13, 1, 13, 13, 13, 13,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Roman Zippel7a884882005-11-08 21:34:51 -0800737 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 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
756extern int zconf_flex_debug;
757int 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
766char *zconftext;
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300767#define YY_NO_INPUT 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
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
780#define LKC_DIRECT_LINK
781#include "lkc.h"
782
783#define START_STRSIZE 16
784
Roman Zippela02f0572005-11-08 21:34:53 -0800785static struct {
786 struct file *file;
787 int lineno;
788} current_pos;
789
Roman Zippel7a884882005-11-08 21:34:51 -0800790static char *text;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791static int text_size, text_asize;
792
793struct buffer {
794 struct buffer *parent;
795 YY_BUFFER_STATE state;
796};
797
798struct buffer *current_buf;
799
800static int last_ts, first_ts;
801
802static void zconf_endhelp(void);
Roman Zippela02f0572005-11-08 21:34:53 -0800803static void zconf_endfile(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805void new_string(void)
806{
807 text = malloc(START_STRSIZE);
808 text_asize = START_STRSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 text_size = 0;
Roman Zippel7a884882005-11-08 21:34:51 -0800810 *text = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
812
813void append_string(const char *str, int size)
814{
815 int new_size = text_size + size + 1;
816 if (new_size > text_asize) {
Roman Zippel7a884882005-11-08 21:34:51 -0800817 new_size += START_STRSIZE - 1;
818 new_size &= -START_STRSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 text = realloc(text, new_size);
820 text_asize = new_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 }
Roman Zippel7a884882005-11-08 21:34:51 -0800822 memcpy(text + text_size, str, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 text_size += size;
Roman Zippel7a884882005-11-08 21:34:51 -0800824 text[text_size] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
826
827void alloc_string(const char *str, int size)
828{
829 text = malloc(size + 1);
830 memcpy(text, str, size);
831 text[size] = 0;
832}
833
834#define INITIAL 0
835#define COMMAND 1
836#define HELP 2
837#define STRING 3
838#define PARAM 4
839
Roman Zippel7a884882005-11-08 21:34:51 -0800840#ifndef YY_NO_UNISTD_H
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841/* Special case for "unistd.h", since it is non-ANSI. We include it way
842 * down here because we want the user's section 1 to have been scanned first.
843 * The user has a chance to override it with an option.
844 */
845#include <unistd.h>
Roman Zippel7a884882005-11-08 21:34:51 -0800846#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
848#ifndef YY_EXTRA_TYPE
849#define YY_EXTRA_TYPE void *
850#endif
851
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700852static int yy_init_globals (void );
853
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300854/* Accessor methods to globals.
855 These are made visible to non-reentrant scanners for convenience. */
856
857int zconflex_destroy (void );
858
859int zconfget_debug (void );
860
861void zconfset_debug (int debug_flag );
862
863YY_EXTRA_TYPE zconfget_extra (void );
864
865void zconfset_extra (YY_EXTRA_TYPE user_defined );
866
867FILE *zconfget_in (void );
868
869void zconfset_in (FILE * in_str );
870
871FILE *zconfget_out (void );
872
873void zconfset_out (FILE * out_str );
874
875int zconfget_leng (void );
876
877char *zconfget_text (void );
878
879int zconfget_lineno (void );
880
881void zconfset_lineno (int line_number );
882
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883/* Macros after this point can all be overridden by user definitions in
884 * section 1.
885 */
886
887#ifndef YY_SKIP_YYWRAP
888#ifdef __cplusplus
889extern "C" int zconfwrap (void );
890#else
891extern int zconfwrap (void );
892#endif
893#endif
894
895 static void yyunput (int c,char *buf_ptr );
896
897#ifndef yytext_ptr
898static void yy_flex_strncpy (char *,yyconst char *,int );
899#endif
900
901#ifdef YY_NEED_STRLEN
902static int yy_flex_strlen (yyconst char * );
903#endif
904
905#ifndef YY_NO_INPUT
906
907#ifdef __cplusplus
908static int yyinput (void );
909#else
910static int input (void );
911#endif
912
913#endif
914
915/* Amount of stuff to slurp up with each read. */
916#ifndef YY_READ_BUF_SIZE
917#define YY_READ_BUF_SIZE 8192
918#endif
919
920/* Copy whatever the last rule matched to the standard output. */
921#ifndef ECHO
922/* This used to be an fputs(), but since the string might contain NUL's,
923 * we now use fwrite().
924 */
Adrian Bunkbe2be1d2008-07-17 02:07:59 +0300925#define ECHO fwrite( zconftext, zconfleng, 1, zconfout )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926#endif
927
928/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
929 * is returned in "result".
930 */
931#ifndef YY_INPUT
932#define YY_INPUT(buf,result,max_size) \
933 errno=0; \
934 while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
935 { \
936 if( errno != EINTR) \
937 { \
938 YY_FATAL_ERROR( "input in flex scanner failed" ); \
939 break; \
940 } \
941 errno=0; \
942 clearerr(zconfin); \
943 }\
944\
945
946#endif
947
948/* No semi-colon after return; correct usage is to write "yyterminate();" -
949 * we don't want an extra ';' after the "return" because that will cause
950 * some compilers to complain about unreachable statements.
951 */
952#ifndef yyterminate
953#define yyterminate() return YY_NULL
954#endif
955
956/* Number of entries by which start-condition stack grows. */
957#ifndef YY_START_STACK_INCR
958#define YY_START_STACK_INCR 25
959#endif
960
961/* Report a fatal error. */
962#ifndef YY_FATAL_ERROR
963#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
964#endif
965
966/* end tables serialization structures and prototypes */
967
968/* Default declaration of generated scanner - a define so the user can
969 * easily add parameters.
970 */
971#ifndef YY_DECL
972#define YY_DECL_IS_OURS 1
973
974extern int zconflex (void);
975
976#define YY_DECL int zconflex (void)
977#endif /* !YY_DECL */
978
979/* Code executed at the beginning of each rule, after zconftext and zconfleng
980 * have been set up.
981 */
982#ifndef YY_USER_ACTION
983#define YY_USER_ACTION
984#endif
985
986/* Code executed at the end of each rule. */
987#ifndef YY_BREAK
988#define YY_BREAK break;
989#endif
990
991#define YY_RULE_SETUP \
992 YY_USER_ACTION
993
994/** The main scanner function which does all the work.
995 */
996YY_DECL
997{
998 register yy_state_type yy_current_state;
999 register char *yy_cp, *yy_bp;
1000 register int yy_act;
1001
1002 int str = 0;
1003 int ts, i;
1004
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001005 if ( !(yy_init) )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 {
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001007 (yy_init) = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
1009#ifdef YY_USER_INIT
1010 YY_USER_INIT;
1011#endif
1012
1013 if ( ! (yy_start) )
1014 (yy_start) = 1; /* first start state */
1015
1016 if ( ! zconfin )
1017 zconfin = stdin;
1018
1019 if ( ! zconfout )
1020 zconfout = stdout;
1021
1022 if ( ! YY_CURRENT_BUFFER ) {
1023 zconfensure_buffer_stack ();
1024 YY_CURRENT_BUFFER_LVALUE =
1025 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1026 }
1027
1028 zconf_load_buffer_state( );
1029 }
1030
1031 while ( 1 ) /* loops until end-of-file is reached */
1032 {
1033 yy_cp = (yy_c_buf_p);
1034
1035 /* Support of zconftext. */
1036 *yy_cp = (yy_hold_char);
1037
1038 /* yy_bp points to the position in yy_ch_buf of the start of
1039 * the current run.
1040 */
1041 yy_bp = yy_cp;
1042
1043 yy_current_state = (yy_start);
1044yy_match:
1045 while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)] ]) > 0 )
1046 ++yy_cp;
1047
1048 yy_current_state = -yy_current_state;
1049
1050yy_find_action:
1051 yy_act = yy_accept[yy_current_state];
1052
1053 YY_DO_BEFORE_ACTION;
1054
1055do_action: /* This label is used only to access EOF actions. */
1056
1057 switch ( yy_act )
1058 { /* beginning of action switch */
1059case 1:
1060/* rule 1 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061case 2:
Roman Zippela02f0572005-11-08 21:34:53 -08001062/* rule 2 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063YY_RULE_SETUP
Roman Zippela02f0572005-11-08 21:34:53 -08001064{
1065 current_file->lineno++;
1066 return T_EOL;
1067}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 YY_BREAK
1069case 3:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070YY_RULE_SETUP
Roman Zippela02f0572005-11-08 21:34:53 -08001071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 YY_BREAK
1073case 4:
1074YY_RULE_SETUP
1075{
1076 BEGIN(COMMAND);
1077}
1078 YY_BREAK
1079case 5:
1080YY_RULE_SETUP
1081{
1082 unput(zconftext[0]);
1083 BEGIN(COMMAND);
1084}
1085 YY_BREAK
1086
1087case 6:
1088YY_RULE_SETUP
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089{
Roman Zippel7a884882005-11-08 21:34:51 -08001090 struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
Roman Zippela02f0572005-11-08 21:34:53 -08001091 BEGIN(PARAM);
1092 current_pos.file = current_file;
1093 current_pos.lineno = current_file->lineno;
Roman Zippel7a884882005-11-08 21:34:51 -08001094 if (id && id->flags & TF_COMMAND) {
Roman Zippel3370f9f2005-11-08 21:34:52 -08001095 zconflval.id = id;
Roman Zippel7a884882005-11-08 21:34:51 -08001096 return id->token;
1097 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 alloc_string(zconftext, zconfleng);
1099 zconflval.string = text;
1100 return T_WORD;
1101 }
1102 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001103case 7:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104YY_RULE_SETUP
1105
1106 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001107case 8:
1108/* rule 8 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109YY_RULE_SETUP
Roman Zippela02f0572005-11-08 21:34:53 -08001110{
1111 BEGIN(INITIAL);
1112 current_file->lineno++;
1113 return T_EOL;
1114 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 YY_BREAK
1116
Roman Zippel7a884882005-11-08 21:34:51 -08001117case 9:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118YY_RULE_SETUP
1119return T_AND;
1120 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001121case 10:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122YY_RULE_SETUP
1123return T_OR;
1124 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001125case 11:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126YY_RULE_SETUP
1127return T_OPEN_PAREN;
1128 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001129case 12:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130YY_RULE_SETUP
1131return T_CLOSE_PAREN;
1132 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001133case 13:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134YY_RULE_SETUP
1135return T_NOT;
1136 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001137case 14:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138YY_RULE_SETUP
1139return T_EQUAL;
1140 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001141case 15:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142YY_RULE_SETUP
1143return T_UNEQUAL;
1144 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001145case 16:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146YY_RULE_SETUP
1147{
1148 str = zconftext[0];
1149 new_string();
1150 BEGIN(STRING);
1151 }
1152 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001153case 17:
1154/* rule 17 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155YY_RULE_SETUP
1156BEGIN(INITIAL); current_file->lineno++; return T_EOL;
1157 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001158case 18:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159YY_RULE_SETUP
1160/* ignore */
1161 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001162case 19:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163YY_RULE_SETUP
1164{
Roman Zippel7a884882005-11-08 21:34:51 -08001165 struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
Roman Zippel3370f9f2005-11-08 21:34:52 -08001166 if (id && id->flags & TF_PARAM) {
1167 zconflval.id = id;
Roman Zippel7a884882005-11-08 21:34:51 -08001168 return id->token;
Roman Zippel3370f9f2005-11-08 21:34:52 -08001169 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 alloc_string(zconftext, zconfleng);
1171 zconflval.string = text;
1172 return T_WORD;
1173 }
1174 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001175case 20:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176YY_RULE_SETUP
1177/* comment */
1178 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001179case 21:
1180/* rule 21 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181YY_RULE_SETUP
1182current_file->lineno++;
1183 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001184case 22:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185YY_RULE_SETUP
1186
1187 YY_BREAK
1188case YY_STATE_EOF(PARAM):
1189{
1190 BEGIN(INITIAL);
1191 }
1192 YY_BREAK
1193
Roman Zippel7a884882005-11-08 21:34:51 -08001194case 23:
1195/* rule 23 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1197(yy_c_buf_p) = yy_cp -= 1;
1198YY_DO_BEFORE_ACTION; /* set up zconftext again */
1199YY_RULE_SETUP
1200{
1201 append_string(zconftext, zconfleng);
1202 zconflval.string = text;
1203 return T_WORD_QUOTE;
1204 }
1205 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001206case 24:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207YY_RULE_SETUP
1208{
1209 append_string(zconftext, zconfleng);
1210 }
1211 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001212case 25:
1213/* rule 25 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1215(yy_c_buf_p) = yy_cp -= 1;
1216YY_DO_BEFORE_ACTION; /* set up zconftext again */
1217YY_RULE_SETUP
1218{
1219 append_string(zconftext + 1, zconfleng - 1);
1220 zconflval.string = text;
1221 return T_WORD_QUOTE;
1222 }
1223 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001224case 26:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225YY_RULE_SETUP
1226{
1227 append_string(zconftext + 1, zconfleng - 1);
1228 }
1229 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001230case 27:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231YY_RULE_SETUP
1232{
1233 if (str == zconftext[0]) {
1234 BEGIN(PARAM);
1235 zconflval.string = text;
1236 return T_WORD_QUOTE;
1237 } else
1238 append_string(zconftext, 1);
1239 }
1240 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001241case 28:
1242/* rule 28 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243YY_RULE_SETUP
1244{
1245 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
1246 current_file->lineno++;
1247 BEGIN(INITIAL);
1248 return T_EOL;
1249 }
1250 YY_BREAK
1251case YY_STATE_EOF(STRING):
1252{
1253 BEGIN(INITIAL);
1254 }
1255 YY_BREAK
1256
Roman Zippel7a884882005-11-08 21:34:51 -08001257case 29:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258YY_RULE_SETUP
1259{
1260 ts = 0;
1261 for (i = 0; i < zconfleng; i++) {
1262 if (zconftext[i] == '\t')
1263 ts = (ts & ~7) + 8;
1264 else
1265 ts++;
1266 }
1267 last_ts = ts;
1268 if (first_ts) {
1269 if (ts < first_ts) {
1270 zconf_endhelp();
1271 return T_HELPTEXT;
1272 }
1273 ts -= first_ts;
1274 while (ts > 8) {
1275 append_string(" ", 8);
1276 ts -= 8;
1277 }
1278 append_string(" ", ts);
1279 }
1280 }
1281 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001282case 30:
1283/* rule 30 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1285(yy_c_buf_p) = yy_cp -= 1;
1286YY_DO_BEFORE_ACTION; /* set up zconftext again */
1287YY_RULE_SETUP
1288{
1289 current_file->lineno++;
1290 zconf_endhelp();
1291 return T_HELPTEXT;
1292 }
1293 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001294case 31:
1295/* rule 31 can match eol */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296YY_RULE_SETUP
1297{
1298 current_file->lineno++;
1299 append_string("\n", 1);
1300 }
1301 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001302case 32:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303YY_RULE_SETUP
1304{
EGRY Gaborf7a4b4c2008-01-11 23:55:20 +01001305 while (zconfleng) {
1306 if ((zconftext[zconfleng-1] != ' ') && (zconftext[zconfleng-1] != '\t'))
1307 break;
1308 zconfleng--;
1309 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 append_string(zconftext, zconfleng);
1311 if (!first_ts)
1312 first_ts = last_ts;
1313 }
1314 YY_BREAK
1315case YY_STATE_EOF(HELP):
1316{
1317 zconf_endhelp();
1318 return T_HELPTEXT;
1319 }
1320 YY_BREAK
1321
1322case YY_STATE_EOF(INITIAL):
1323case YY_STATE_EOF(COMMAND):
1324{
Roman Zippela02f0572005-11-08 21:34:53 -08001325 if (current_file) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 zconf_endfile();
Roman Zippela02f0572005-11-08 21:34:53 -08001327 return T_EOL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 }
1329 fclose(zconfin);
1330 yyterminate();
1331}
1332 YY_BREAK
Roman Zippel7a884882005-11-08 21:34:51 -08001333case 33:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334YY_RULE_SETUP
1335YY_FATAL_ERROR( "flex scanner jammed" );
1336 YY_BREAK
1337
1338 case YY_END_OF_BUFFER:
1339 {
1340 /* Amount of text matched not including the EOB char. */
1341 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1342
1343 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1344 *yy_cp = (yy_hold_char);
1345 YY_RESTORE_YY_MORE_OFFSET
1346
1347 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1348 {
1349 /* We're scanning a new file or input source. It's
1350 * possible that this happened because the user
1351 * just pointed zconfin at a new source and called
1352 * zconflex(). If so, then we have to assure
1353 * consistency between YY_CURRENT_BUFFER and our
1354 * globals. Here is the right place to do so, because
1355 * this is the first action (other than possibly a
1356 * back-up) that will match for the new input source.
1357 */
1358 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1359 YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
1360 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1361 }
1362
1363 /* Note that here we test for yy_c_buf_p "<=" to the position
1364 * of the first EOB in the buffer, since yy_c_buf_p will
1365 * already have been incremented past the NUL character
1366 * (since all states make transitions on EOB to the
1367 * end-of-buffer state). Contrast this with the test
1368 * in input().
1369 */
1370 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1371 { /* This was really a NUL. */
1372 yy_state_type yy_next_state;
1373
1374 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1375
1376 yy_current_state = yy_get_previous_state( );
1377
1378 /* Okay, we're now positioned to make the NUL
1379 * transition. We couldn't have
1380 * yy_get_previous_state() go ahead and do it
1381 * for us because it doesn't know how to deal
1382 * with the possibility of jamming (and we don't
1383 * want to build jamming into it because then it
1384 * will run more slowly).
1385 */
1386
1387 yy_next_state = yy_try_NUL_trans( yy_current_state );
1388
1389 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1390
1391 if ( yy_next_state )
1392 {
1393 /* Consume the NUL. */
1394 yy_cp = ++(yy_c_buf_p);
1395 yy_current_state = yy_next_state;
1396 goto yy_match;
1397 }
1398
1399 else
1400 {
1401 yy_cp = (yy_c_buf_p);
1402 goto yy_find_action;
1403 }
1404 }
1405
1406 else switch ( yy_get_next_buffer( ) )
1407 {
1408 case EOB_ACT_END_OF_FILE:
1409 {
1410 (yy_did_buffer_switch_on_eof) = 0;
1411
1412 if ( zconfwrap( ) )
1413 {
1414 /* Note: because we've taken care in
1415 * yy_get_next_buffer() to have set up
1416 * zconftext, we can now set up
1417 * yy_c_buf_p so that if some total
1418 * hoser (like flex itself) wants to
1419 * call the scanner after we return the
1420 * YY_NULL, it'll still work - another
1421 * YY_NULL will get returned.
1422 */
1423 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1424
1425 yy_act = YY_STATE_EOF(YY_START);
1426 goto do_action;
1427 }
1428
1429 else
1430 {
1431 if ( ! (yy_did_buffer_switch_on_eof) )
1432 YY_NEW_FILE;
1433 }
1434 break;
1435 }
1436
1437 case EOB_ACT_CONTINUE_SCAN:
1438 (yy_c_buf_p) =
1439 (yytext_ptr) + yy_amount_of_matched_text;
1440
1441 yy_current_state = yy_get_previous_state( );
1442
1443 yy_cp = (yy_c_buf_p);
1444 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1445 goto yy_match;
1446
1447 case EOB_ACT_LAST_MATCH:
1448 (yy_c_buf_p) =
1449 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1450
1451 yy_current_state = yy_get_previous_state( );
1452
1453 yy_cp = (yy_c_buf_p);
1454 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1455 goto yy_find_action;
1456 }
1457 break;
1458 }
1459
1460 default:
1461 YY_FATAL_ERROR(
1462 "fatal flex scanner internal error--no action found" );
1463 } /* end of action switch */
1464 } /* end of scanning one token */
1465} /* end of zconflex */
1466
1467/* yy_get_next_buffer - try to read in a new buffer
1468 *
1469 * Returns a code representing an action:
1470 * EOB_ACT_LAST_MATCH -
1471 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1472 * EOB_ACT_END_OF_FILE - end of file
1473 */
1474static int yy_get_next_buffer (void)
1475{
1476 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1477 register char *source = (yytext_ptr);
1478 register int number_to_move, i;
1479 int ret_val;
1480
1481 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1482 YY_FATAL_ERROR(
1483 "fatal flex scanner internal error--end of buffer missed" );
1484
1485 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1486 { /* Don't try to fill the buffer, so this is an EOF. */
1487 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1488 {
1489 /* We matched a single character, the EOB, so
1490 * treat this as a final EOF.
1491 */
1492 return EOB_ACT_END_OF_FILE;
1493 }
1494
1495 else
1496 {
1497 /* We matched some text prior to the EOB, first
1498 * process it.
1499 */
1500 return EOB_ACT_LAST_MATCH;
1501 }
1502 }
1503
1504 /* Try to read more data. */
1505
1506 /* First move last chars to start of buffer. */
1507 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1508
1509 for ( i = 0; i < number_to_move; ++i )
1510 *(dest++) = *(source++);
1511
1512 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1513 /* don't do the read, it's not guaranteed to return an EOF,
1514 * just force an EOF
1515 */
1516 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1517
1518 else
1519 {
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001520 int num_to_read =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1522
1523 while ( num_to_read <= 0 )
1524 { /* Not enough room in the buffer - grow it. */
1525
1526 /* just a shorter name for the current buffer */
1527 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1528
1529 int yy_c_buf_p_offset =
1530 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1531
1532 if ( b->yy_is_our_buffer )
1533 {
1534 int new_size = b->yy_buf_size * 2;
1535
1536 if ( new_size <= 0 )
1537 b->yy_buf_size += b->yy_buf_size / 8;
1538 else
1539 b->yy_buf_size *= 2;
1540
1541 b->yy_ch_buf = (char *)
1542 /* Include room in for 2 EOB chars. */
1543 zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1544 }
1545 else
1546 /* Can't grow it, we don't own it. */
1547 b->yy_ch_buf = 0;
1548
1549 if ( ! b->yy_ch_buf )
1550 YY_FATAL_ERROR(
1551 "fatal error - scanner input buffer overflow" );
1552
1553 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1554
1555 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1556 number_to_move - 1;
1557
1558 }
1559
1560 if ( num_to_read > YY_READ_BUF_SIZE )
1561 num_to_read = YY_READ_BUF_SIZE;
1562
1563 /* Read in more data. */
1564 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
Roman Zippel5a1aa8a2008-02-29 05:11:50 +01001565 (yy_n_chars), (size_t) num_to_read );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566
1567 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1568 }
1569
1570 if ( (yy_n_chars) == 0 )
1571 {
1572 if ( number_to_move == YY_MORE_ADJ )
1573 {
1574 ret_val = EOB_ACT_END_OF_FILE;
1575 zconfrestart(zconfin );
1576 }
1577
1578 else
1579 {
1580 ret_val = EOB_ACT_LAST_MATCH;
1581 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1582 YY_BUFFER_EOF_PENDING;
1583 }
1584 }
1585
1586 else
1587 ret_val = EOB_ACT_CONTINUE_SCAN;
1588
Adrian Bunkbe2be1d2008-07-17 02:07:59 +03001589 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1590 /* Extend the array by 50%, plus the number we really need. */
1591 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1592 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) zconfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1593 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1594 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1595 }
1596
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 (yy_n_chars) += number_to_move;
1598 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1599 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1600
1601 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1602
1603 return ret_val;
1604}
1605
1606/* yy_get_previous_state - get the state just before the EOB char was reached */
1607
1608 static yy_state_type yy_get_previous_state (void)
1609{
1610 register yy_state_type yy_current_state;
1611 register char *yy_cp;
1612
1613 yy_current_state = (yy_start);
1614
1615 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1616 {
1617 yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
1618 }
1619
1620 return yy_current_state;
1621}
1622
1623/* yy_try_NUL_trans - try to make a transition on the NUL character
1624 *
1625 * synopsis
1626 * next_state = yy_try_NUL_trans( current_state );
1627 */
1628 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1629{
1630 register int yy_is_jam;
1631
1632 yy_current_state = yy_nxt[yy_current_state][1];
1633 yy_is_jam = (yy_current_state <= 0);
1634
1635 return yy_is_jam ? 0 : yy_current_state;
1636}
1637
1638 static void yyunput (int c, register char * yy_bp )
1639{
1640 register char *yy_cp;
1641
1642 yy_cp = (yy_c_buf_p);
1643
1644 /* undo effects of setting up zconftext */
1645 *yy_cp = (yy_hold_char);
1646
1647 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1648 { /* need to shift things up to make room */
1649 /* +2 for EOB chars. */
1650 register int number_to_move = (yy_n_chars) + 2;
1651 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1652 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1653 register char *source =
1654 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1655
1656 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1657 *--dest = *--source;
1658
1659 yy_cp += (int) (dest - source);
1660 yy_bp += (int) (dest - source);
1661 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1662 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1663
1664 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1665 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1666 }
1667
1668 *--yy_cp = (char) c;
1669
1670 (yytext_ptr) = yy_bp;
1671 (yy_hold_char) = *yy_cp;
1672 (yy_c_buf_p) = yy_cp;
1673}
1674
1675#ifndef YY_NO_INPUT
1676#ifdef __cplusplus
1677 static int yyinput (void)
1678#else
1679 static int input (void)
1680#endif
1681
1682{
1683 int c;
1684
1685 *(yy_c_buf_p) = (yy_hold_char);
1686
1687 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1688 {
1689 /* yy_c_buf_p now points to the character we want to return.
1690 * If this occurs *before* the EOB characters, then it's a
1691 * valid NUL; if not, then we've hit the end of the buffer.
1692 */
1693 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1694 /* This was really a NUL. */
1695 *(yy_c_buf_p) = '\0';
1696
1697 else
1698 { /* need more input */
1699 int offset = (yy_c_buf_p) - (yytext_ptr);
1700 ++(yy_c_buf_p);
1701
1702 switch ( yy_get_next_buffer( ) )
1703 {
1704 case EOB_ACT_LAST_MATCH:
1705 /* This happens because yy_g_n_b()
1706 * sees that we've accumulated a
1707 * token and flags that we need to
1708 * try matching the token before
1709 * proceeding. But for input(),
1710 * there's no matching to consider.
1711 * So convert the EOB_ACT_LAST_MATCH
1712 * to EOB_ACT_END_OF_FILE.
1713 */
1714
1715 /* Reset buffer status. */
1716 zconfrestart(zconfin );
1717
1718 /*FALLTHROUGH*/
1719
1720 case EOB_ACT_END_OF_FILE:
1721 {
1722 if ( zconfwrap( ) )
1723 return EOF;
1724
1725 if ( ! (yy_did_buffer_switch_on_eof) )
1726 YY_NEW_FILE;
1727#ifdef __cplusplus
1728 return yyinput();
1729#else
1730 return input();
1731#endif
1732 }
1733
1734 case EOB_ACT_CONTINUE_SCAN:
1735 (yy_c_buf_p) = (yytext_ptr) + offset;
1736 break;
1737 }
1738 }
1739 }
1740
1741 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1742 *(yy_c_buf_p) = '\0'; /* preserve zconftext */
1743 (yy_hold_char) = *++(yy_c_buf_p);
1744
1745 return c;
1746}
1747#endif /* ifndef YY_NO_INPUT */
1748
1749/** Immediately switch to a different input stream.
1750 * @param input_file A readable stream.
1751 *
1752 * @note This function does not reset the start condition to @c INITIAL .
1753 */
1754 void zconfrestart (FILE * input_file )
1755{
1756
1757 if ( ! YY_CURRENT_BUFFER ){
1758 zconfensure_buffer_stack ();
1759 YY_CURRENT_BUFFER_LVALUE =
1760 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1761 }
1762
1763 zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
1764 zconf_load_buffer_state( );
1765}
1766
1767/** Switch to a different input buffer.
1768 * @param new_buffer The new input buffer.
1769 *
1770 */
1771 void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1772{
1773
1774 /* TODO. We should be able to replace this entire function body
1775 * with
1776 * zconfpop_buffer_state();
1777 * zconfpush_buffer_state(new_buffer);
1778 */
1779 zconfensure_buffer_stack ();
1780 if ( YY_CURRENT_BUFFER == new_buffer )
1781 return;
1782
1783 if ( YY_CURRENT_BUFFER )
1784 {
1785 /* Flush out information for old buffer. */
1786 *(yy_c_buf_p) = (yy_hold_char);
1787 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1788 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1789 }
1790
1791 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1792 zconf_load_buffer_state( );
1793
1794 /* We don't actually know whether we did this switch during
1795 * EOF (zconfwrap()) processing, but the only time this flag
1796 * is looked at is after zconfwrap() is called, so it's safe
1797 * to go ahead and always set it.
1798 */
1799 (yy_did_buffer_switch_on_eof) = 1;
1800}
1801
1802static void zconf_load_buffer_state (void)
1803{
1804 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1805 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1806 zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1807 (yy_hold_char) = *(yy_c_buf_p);
1808}
1809
1810/** Allocate and initialize an input buffer state.
1811 * @param file A readable stream.
1812 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1813 *
1814 * @return the allocated buffer state.
1815 */
1816 YY_BUFFER_STATE zconf_create_buffer (FILE * file, int size )
1817{
1818 YY_BUFFER_STATE b;
1819
1820 b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
1821 if ( ! b )
1822 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1823
1824 b->yy_buf_size = size;
1825
1826 /* yy_ch_buf has to be 2 characters longer than the size given because
1827 * we need to put in 2 end-of-buffer characters.
1828 */
1829 b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2 );
1830 if ( ! b->yy_ch_buf )
1831 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1832
1833 b->yy_is_our_buffer = 1;
1834
1835 zconf_init_buffer(b,file );
1836
1837 return b;
1838}
1839
1840/** Destroy the buffer.
1841 * @param b a buffer created with zconf_create_buffer()
1842 *
1843 */
1844 void zconf_delete_buffer (YY_BUFFER_STATE b )
1845{
1846
1847 if ( ! b )
1848 return;
1849
1850 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1851 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1852
1853 if ( b->yy_is_our_buffer )
1854 zconffree((void *) b->yy_ch_buf );
1855
1856 zconffree((void *) b );
1857}
1858
1859/* Initializes or reinitializes a buffer.
1860 * This function is sometimes called more than once on the same buffer,
1861 * such as during a zconfrestart() or at EOF.
1862 */
1863 static void zconf_init_buffer (YY_BUFFER_STATE b, FILE * file )
1864
1865{
1866 int oerrno = errno;
1867
1868 zconf_flush_buffer(b );
1869
1870 b->yy_input_file = file;
1871 b->yy_fill_buffer = 1;
1872
1873 /* If b is the current buffer, then zconf_init_buffer was _probably_
1874 * called from zconfrestart() or through yy_get_next_buffer.
1875 * In that case, we don't want to reset the lineno or column.
1876 */
1877 if (b != YY_CURRENT_BUFFER){
1878 b->yy_bs_lineno = 1;
1879 b->yy_bs_column = 0;
1880 }
1881
1882 b->yy_is_interactive = 0;
1883
1884 errno = oerrno;
1885}
1886
1887/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1888 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1889 *
1890 */
1891 void zconf_flush_buffer (YY_BUFFER_STATE b )
1892{
1893 if ( ! b )
1894 return;
1895
1896 b->yy_n_chars = 0;
1897
1898 /* We always need two end-of-buffer characters. The first causes
1899 * a transition to the end-of-buffer state. The second causes
1900 * a jam in that state.
1901 */
1902 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1903 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1904
1905 b->yy_buf_pos = &b->yy_ch_buf[0];
1906
1907 b->yy_at_bol = 1;
1908 b->yy_buffer_status = YY_BUFFER_NEW;
1909
1910 if ( b == YY_CURRENT_BUFFER )
1911 zconf_load_buffer_state( );
1912}
1913
1914/** Pushes the new state onto the stack. The new state becomes
1915 * the current state. This function will allocate the stack
1916 * if necessary.
1917 * @param new_buffer The new state.
1918 *
1919 */
1920void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
1921{
1922 if (new_buffer == NULL)
1923 return;
1924
1925 zconfensure_buffer_stack();
1926
1927 /* This block is copied from zconf_switch_to_buffer. */
1928 if ( YY_CURRENT_BUFFER )
1929 {
1930 /* Flush out information for old buffer. */
1931 *(yy_c_buf_p) = (yy_hold_char);
1932 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1933 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1934 }
1935
1936 /* Only push if top exists. Otherwise, replace top. */
1937 if (YY_CURRENT_BUFFER)
1938 (yy_buffer_stack_top)++;
1939 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1940
1941 /* copied from zconf_switch_to_buffer. */
1942 zconf_load_buffer_state( );
1943 (yy_did_buffer_switch_on_eof) = 1;
1944}
1945
1946/** Removes and deletes the top of the stack, if present.
1947 * The next element becomes the new top.
1948 *
1949 */
1950void zconfpop_buffer_state (void)
1951{
1952 if (!YY_CURRENT_BUFFER)
1953 return;
1954
1955 zconf_delete_buffer(YY_CURRENT_BUFFER );
1956 YY_CURRENT_BUFFER_LVALUE = NULL;
1957 if ((yy_buffer_stack_top) > 0)
1958 --(yy_buffer_stack_top);
1959
1960 if (YY_CURRENT_BUFFER) {
1961 zconf_load_buffer_state( );
1962 (yy_did_buffer_switch_on_eof) = 1;
1963 }
1964}
1965
1966/* Allocates the stack if it does not exist.
1967 * Guarantees space for at least one push.
1968 */
1969static void zconfensure_buffer_stack (void)
1970{
1971 int num_to_alloc;
1972
1973 if (!(yy_buffer_stack)) {
1974
1975 /* First allocation is just for 2 elements, since we don't know if this
1976 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1977 * immediate realloc on the next call.
1978 */
1979 num_to_alloc = 1;
1980 (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
1981 (num_to_alloc * sizeof(struct yy_buffer_state*)
1982 );
Adrian Bunkbe2be1d2008-07-17 02:07:59 +03001983 if ( ! (yy_buffer_stack) )
1984 YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
1985
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1987
1988 (yy_buffer_stack_max) = num_to_alloc;
1989 (yy_buffer_stack_top) = 0;
1990 return;
1991 }
1992
1993 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1994
1995 /* Increase the buffer to prepare for a possible push. */
1996 int grow_size = 8 /* arbitrary grow size */;
1997
1998 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1999 (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
2000 ((yy_buffer_stack),
2001 num_to_alloc * sizeof(struct yy_buffer_state*)
2002 );
Adrian Bunkbe2be1d2008-07-17 02:07:59 +03002003 if ( ! (yy_buffer_stack) )
2004 YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005
2006 /* zero only the new slots.*/
2007 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2008 (yy_buffer_stack_max) = num_to_alloc;
2009 }
2010}
2011
2012/** Setup the input buffer state to scan directly from a user-specified character buffer.
2013 * @param base the character buffer
2014 * @param size the size in bytes of the character buffer
2015 *
2016 * @return the newly allocated buffer state object.
2017 */
2018YY_BUFFER_STATE zconf_scan_buffer (char * base, yy_size_t size )
2019{
2020 YY_BUFFER_STATE b;
2021
2022 if ( size < 2 ||
2023 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2024 base[size-1] != YY_END_OF_BUFFER_CHAR )
2025 /* They forgot to leave room for the EOB's. */
2026 return 0;
2027
2028 b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
2029 if ( ! b )
2030 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
2031
2032 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2033 b->yy_buf_pos = b->yy_ch_buf = base;
2034 b->yy_is_our_buffer = 0;
2035 b->yy_input_file = 0;
2036 b->yy_n_chars = b->yy_buf_size;
2037 b->yy_is_interactive = 0;
2038 b->yy_at_bol = 1;
2039 b->yy_fill_buffer = 0;
2040 b->yy_buffer_status = YY_BUFFER_NEW;
2041
2042 zconf_switch_to_buffer(b );
2043
2044 return b;
2045}
2046
2047/** Setup the input buffer state to scan a string. The next call to zconflex() will
2048 * scan from a @e copy of @a str.
Roman Zippel5a1aa8a2008-02-29 05:11:50 +01002049 * @param yystr a NUL-terminated string to scan
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 *
2051 * @return the newly allocated buffer state object.
2052 * @note If you want to scan bytes that may contain NUL values, then use
2053 * zconf_scan_bytes() instead.
2054 */
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002055YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056{
2057
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002058 return zconf_scan_bytes(yystr,strlen(yystr) );
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059}
2060
2061/** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
2062 * scan from a @e copy of @a bytes.
2063 * @param bytes the byte buffer to scan
2064 * @param len the number of bytes in the buffer pointed to by @a bytes.
2065 *
2066 * @return the newly allocated buffer state object.
2067 */
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002068YY_BUFFER_STATE zconf_scan_bytes (yyconst char * yybytes, int _yybytes_len )
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069{
2070 YY_BUFFER_STATE b;
2071 char *buf;
2072 yy_size_t n;
2073 int i;
2074
2075 /* Get memory for full buffer, including space for trailing EOB's. */
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002076 n = _yybytes_len + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 buf = (char *) zconfalloc(n );
2078 if ( ! buf )
2079 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
2080
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002081 for ( i = 0; i < _yybytes_len; ++i )
2082 buf[i] = yybytes[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002084 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085
2086 b = zconf_scan_buffer(buf,n );
2087 if ( ! b )
2088 YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
2089
2090 /* It's okay to grow etc. this buffer, and we should throw it
2091 * away when we're done.
2092 */
2093 b->yy_is_our_buffer = 1;
2094
2095 return b;
2096}
2097
2098#ifndef YY_EXIT_FAILURE
2099#define YY_EXIT_FAILURE 2
2100#endif
2101
2102static void yy_fatal_error (yyconst char* msg )
2103{
2104 (void) fprintf( stderr, "%s\n", msg );
2105 exit( YY_EXIT_FAILURE );
2106}
2107
2108/* Redefine yyless() so it works in section 3 code. */
2109
2110#undef yyless
2111#define yyless(n) \
2112 do \
2113 { \
2114 /* Undo effects of setting up zconftext. */ \
2115 int yyless_macro_arg = (n); \
2116 YY_LESS_LINENO(yyless_macro_arg);\
2117 zconftext[zconfleng] = (yy_hold_char); \
2118 (yy_c_buf_p) = zconftext + yyless_macro_arg; \
2119 (yy_hold_char) = *(yy_c_buf_p); \
2120 *(yy_c_buf_p) = '\0'; \
2121 zconfleng = yyless_macro_arg; \
2122 } \
2123 while ( 0 )
2124
2125/* Accessor methods (get/set functions) to struct members. */
2126
2127/** Get the current line number.
2128 *
2129 */
2130int zconfget_lineno (void)
2131{
2132
2133 return zconflineno;
2134}
2135
2136/** Get the input stream.
2137 *
2138 */
2139FILE *zconfget_in (void)
2140{
2141 return zconfin;
2142}
2143
2144/** Get the output stream.
2145 *
2146 */
2147FILE *zconfget_out (void)
2148{
2149 return zconfout;
2150}
2151
2152/** Get the length of the current token.
2153 *
2154 */
2155int zconfget_leng (void)
2156{
2157 return zconfleng;
2158}
2159
2160/** Get the current token.
2161 *
2162 */
2163
2164char *zconfget_text (void)
2165{
2166 return zconftext;
2167}
2168
2169/** Set the current line number.
2170 * @param line_number
2171 *
2172 */
2173void zconfset_lineno (int line_number )
2174{
2175
2176 zconflineno = line_number;
2177}
2178
2179/** Set the input stream. This does not discard the current
2180 * input buffer.
2181 * @param in_str A readable stream.
2182 *
2183 * @see zconf_switch_to_buffer
2184 */
2185void zconfset_in (FILE * in_str )
2186{
2187 zconfin = in_str ;
2188}
2189
2190void zconfset_out (FILE * out_str )
2191{
2192 zconfout = out_str ;
2193}
2194
2195int zconfget_debug (void)
2196{
2197 return zconf_flex_debug;
2198}
2199
2200void zconfset_debug (int bdebug )
2201{
2202 zconf_flex_debug = bdebug ;
2203}
2204
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002205static int yy_init_globals (void)
2206{
2207 /* Initialization is the same as for the non-reentrant scanner.
2208 * This function is called from zconflex_destroy(), so don't allocate here.
2209 */
2210
2211 (yy_buffer_stack) = 0;
2212 (yy_buffer_stack_top) = 0;
2213 (yy_buffer_stack_max) = 0;
2214 (yy_c_buf_p) = (char *) 0;
2215 (yy_init) = 0;
2216 (yy_start) = 0;
2217
2218/* Defined in main.c */
2219#ifdef YY_STDINIT
2220 zconfin = stdin;
2221 zconfout = stdout;
2222#else
2223 zconfin = (FILE *) 0;
2224 zconfout = (FILE *) 0;
2225#endif
2226
2227 /* For future reference: Set errno on error, since we are called by
2228 * zconflex_init()
2229 */
2230 return 0;
2231}
2232
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233/* zconflex_destroy is for both reentrant and non-reentrant scanners. */
2234int zconflex_destroy (void)
2235{
2236
2237 /* Pop the buffer stack, destroying each element. */
2238 while(YY_CURRENT_BUFFER){
2239 zconf_delete_buffer(YY_CURRENT_BUFFER );
2240 YY_CURRENT_BUFFER_LVALUE = NULL;
2241 zconfpop_buffer_state();
2242 }
2243
2244 /* Destroy the stack itself. */
2245 zconffree((yy_buffer_stack) );
2246 (yy_buffer_stack) = NULL;
2247
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002248 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2249 * zconflex() is called, initialization will occur. */
2250 yy_init_globals( );
2251
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 return 0;
2253}
2254
2255/*
2256 * Internal utility routines.
2257 */
2258
2259#ifndef yytext_ptr
2260static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2261{
2262 register int i;
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002263 for ( i = 0; i < n; ++i )
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 s1[i] = s2[i];
2265}
2266#endif
2267
2268#ifdef YY_NEED_STRLEN
2269static int yy_flex_strlen (yyconst char * s )
2270{
2271 register int n;
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002272 for ( n = 0; s[n]; ++n )
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 ;
2274
2275 return n;
2276}
2277#endif
2278
2279void *zconfalloc (yy_size_t size )
2280{
2281 return (void *) malloc( size );
2282}
2283
2284void *zconfrealloc (void * ptr, yy_size_t size )
2285{
2286 /* The cast to (char *) in the following accommodates both
2287 * implementations that use char* generic pointers, and those
2288 * that use void* generic pointers. It works with the latter
2289 * because both ANSI C and C++ allow castless assignment from
2290 * any pointer type to void*, and deal with argument conversions
2291 * as though doing an assignment.
2292 */
2293 return (void *) realloc( (char *) ptr, size );
2294}
2295
2296void zconffree (void * ptr )
2297{
2298 free( (char *) ptr ); /* see zconfrealloc() for (char *) cast */
2299}
2300
2301#define YYTABLES_NAME "yytables"
2302
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303void zconf_starthelp(void)
2304{
2305 new_string();
2306 last_ts = first_ts = 0;
2307 BEGIN(HELP);
2308}
2309
2310static void zconf_endhelp(void)
2311{
2312 zconflval.string = text;
2313 BEGIN(INITIAL);
2314}
2315
2316/*
2317 * Try to open specified file with following names:
2318 * ./name
2319 * $(srctree)/name
2320 * The latter is used when srctree is separate from objtree
2321 * when compiling the kernel.
2322 * Return NULL if file is not found.
2323 */
2324FILE *zconf_fopen(const char *name)
2325{
2326 char *env, fullname[PATH_MAX+1];
2327 FILE *f;
2328
2329 f = fopen(name, "r");
Marcin Garski11de39e2007-05-05 22:49:00 +02002330 if (!f && name != NULL && name[0] != '/') {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 env = getenv(SRCTREE);
2332 if (env) {
2333 sprintf(fullname, "%s/%s", env, name);
2334 f = fopen(fullname, "r");
2335 }
2336 }
2337 return f;
2338}
2339
2340void zconf_initscan(const char *name)
2341{
2342 zconfin = zconf_fopen(name);
2343 if (!zconfin) {
2344 printf("can't find file %s\n", name);
2345 exit(1);
2346 }
2347
2348 current_buf = malloc(sizeof(*current_buf));
2349 memset(current_buf, 0, sizeof(*current_buf));
2350
2351 current_file = file_lookup(name);
2352 current_file->lineno = 1;
2353 current_file->flags = FILE_BUSY;
2354}
2355
2356void zconf_nextfile(const char *name)
2357{
2358 struct file *file = file_lookup(name);
2359 struct buffer *buf = malloc(sizeof(*buf));
2360 memset(buf, 0, sizeof(*buf));
2361
2362 current_buf->state = YY_CURRENT_BUFFER;
2363 zconfin = zconf_fopen(name);
2364 if (!zconfin) {
2365 printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
2366 exit(1);
2367 }
2368 zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
2369 buf->parent = current_buf;
2370 current_buf = buf;
2371
2372 if (file->flags & FILE_BUSY) {
2373 printf("recursive scan (%s)?\n", name);
2374 exit(1);
2375 }
2376 if (file->flags & FILE_SCANNED) {
2377 printf("file %s already scanned?\n", name);
2378 exit(1);
2379 }
2380 file->flags |= FILE_BUSY;
2381 file->lineno = 1;
2382 file->parent = current_file;
2383 current_file = file;
2384}
2385
Roman Zippela02f0572005-11-08 21:34:53 -08002386static void zconf_endfile(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387{
2388 struct buffer *parent;
2389
2390 current_file->flags |= FILE_SCANNED;
2391 current_file->flags &= ~FILE_BUSY;
2392 current_file = current_file->parent;
2393
2394 parent = current_buf->parent;
2395 if (parent) {
2396 fclose(zconfin);
2397 zconf_delete_buffer(YY_CURRENT_BUFFER);
2398 zconf_switch_to_buffer(parent->state);
2399 }
2400 free(current_buf);
2401 current_buf = parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402}
2403
2404int zconf_lineno(void)
2405{
Roman Zippela02f0572005-11-08 21:34:53 -08002406 return current_pos.lineno;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407}
2408
2409char *zconf_curname(void)
2410{
Roman Zippela02f0572005-11-08 21:34:53 -08002411 return current_pos.file ? current_pos.file->name : "<none>";
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412}
2413