Simplify conf and mconf generation. We don't care for the _shipped stuff.
/trunk/kconfig/kconfig.mk | 4 0 4 0 ----
1 file changed, 4 deletions(-)
1.1 --- a/kconfig/kconfig.mk Sun Sep 28 08:14:33 2008 +0000
1.2 +++ b/kconfig/kconfig.mk Sun Sep 28 10:33:30 2008 +0000
1.3 @@ -148,10 +148,6 @@
1.4
1.5 SHIPPED := $(CT_LIB_DIR)/kconfig/zconf.tab.c $(CT_LIB_DIR)/kconfig/lex.zconf.c $(CT_LIB_DIR)/kconfig/zconf.hash.c
1.6
1.7 -%.c: %.c_shipped
1.8 - @echo ' LN kconfig/$(notdir $@)'
1.9 - @ln -s $(notdir $<) $@
1.10 -
1.11 $(obj)/conf $(obj)/mconf: $(obj)
1.12
1.13 $(obj):
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
2.2 +++ b/kconfig/lex.zconf.c Sun Sep 28 10:33:30 2008 +0000
2.3 @@ -0,0 +1,2350 @@
2.4 +
2.5 +#line 3 "scripts/kconfig/lex.zconf.c"
2.6 +
2.7 +#define YY_INT_ALIGNED short int
2.8 +
2.9 +/* A lexical scanner generated by flex */
2.10 +
2.11 +#define FLEX_SCANNER
2.12 +#define YY_FLEX_MAJOR_VERSION 2
2.13 +#define YY_FLEX_MINOR_VERSION 5
2.14 +#define YY_FLEX_SUBMINOR_VERSION 33
2.15 +#if YY_FLEX_SUBMINOR_VERSION > 0
2.16 +#define FLEX_BETA
2.17 +#endif
2.18 +
2.19 +/* First, we deal with platform-specific or compiler-specific issues. */
2.20 +
2.21 +/* begin standard C headers. */
2.22 +#include <stdio.h>
2.23 +#include <string.h>
2.24 +#include <errno.h>
2.25 +#include <stdlib.h>
2.26 +
2.27 +/* end standard C headers. */
2.28 +
2.29 +/* flex integer type definitions */
2.30 +
2.31 +#ifndef FLEXINT_H
2.32 +#define FLEXINT_H
2.33 +
2.34 +/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
2.35 +
2.36 +#if __STDC_VERSION__ >= 199901L
2.37 +
2.38 +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
2.39 + * if you want the limit (max/min) macros for int types.
2.40 + */
2.41 +#ifndef __STDC_LIMIT_MACROS
2.42 +#define __STDC_LIMIT_MACROS 1
2.43 +#endif
2.44 +
2.45 +#include <inttypes.h>
2.46 +typedef int8_t flex_int8_t;
2.47 +typedef uint8_t flex_uint8_t;
2.48 +typedef int16_t flex_int16_t;
2.49 +typedef uint16_t flex_uint16_t;
2.50 +typedef int32_t flex_int32_t;
2.51 +typedef uint32_t flex_uint32_t;
2.52 +#else
2.53 +typedef signed char flex_int8_t;
2.54 +typedef short int flex_int16_t;
2.55 +typedef int flex_int32_t;
2.56 +typedef unsigned char flex_uint8_t;
2.57 +typedef unsigned short int flex_uint16_t;
2.58 +typedef unsigned int flex_uint32_t;
2.59 +#endif /* ! C99 */
2.60 +
2.61 +/* Limits of integral types. */
2.62 +#ifndef INT8_MIN
2.63 +#define INT8_MIN (-128)
2.64 +#endif
2.65 +#ifndef INT16_MIN
2.66 +#define INT16_MIN (-32767-1)
2.67 +#endif
2.68 +#ifndef INT32_MIN
2.69 +#define INT32_MIN (-2147483647-1)
2.70 +#endif
2.71 +#ifndef INT8_MAX
2.72 +#define INT8_MAX (127)
2.73 +#endif
2.74 +#ifndef INT16_MAX
2.75 +#define INT16_MAX (32767)
2.76 +#endif
2.77 +#ifndef INT32_MAX
2.78 +#define INT32_MAX (2147483647)
2.79 +#endif
2.80 +#ifndef UINT8_MAX
2.81 +#define UINT8_MAX (255U)
2.82 +#endif
2.83 +#ifndef UINT16_MAX
2.84 +#define UINT16_MAX (65535U)
2.85 +#endif
2.86 +#ifndef UINT32_MAX
2.87 +#define UINT32_MAX (4294967295U)
2.88 +#endif
2.89 +
2.90 +#endif /* ! FLEXINT_H */
2.91 +
2.92 +#ifdef __cplusplus
2.93 +
2.94 +/* The "const" storage-class-modifier is valid. */
2.95 +#define YY_USE_CONST
2.96 +
2.97 +#else /* ! __cplusplus */
2.98 +
2.99 +#if __STDC__
2.100 +
2.101 +#define YY_USE_CONST
2.102 +
2.103 +#endif /* __STDC__ */
2.104 +#endif /* ! __cplusplus */
2.105 +
2.106 +#ifdef YY_USE_CONST
2.107 +#define yyconst const
2.108 +#else
2.109 +#define yyconst
2.110 +#endif
2.111 +
2.112 +/* Returned upon end-of-file. */
2.113 +#define YY_NULL 0
2.114 +
2.115 +/* Promotes a possibly negative, possibly signed char to an unsigned
2.116 + * integer for use as an array index. If the signed char is negative,
2.117 + * we want to instead treat it as an 8-bit unsigned char, hence the
2.118 + * double cast.
2.119 + */
2.120 +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
2.121 +
2.122 +/* Enter a start condition. This macro really ought to take a parameter,
2.123 + * but we do it the disgusting crufty way forced on us by the ()-less
2.124 + * definition of BEGIN.
2.125 + */
2.126 +#define BEGIN (yy_start) = 1 + 2 *
2.127 +
2.128 +/* Translate the current start state into a value that can be later handed
2.129 + * to BEGIN to return to the state. The YYSTATE alias is for lex
2.130 + * compatibility.
2.131 + */
2.132 +#define YY_START (((yy_start) - 1) / 2)
2.133 +#define YYSTATE YY_START
2.134 +
2.135 +/* Action number for EOF rule of a given start state. */
2.136 +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
2.137 +
2.138 +/* Special action meaning "start processing a new file". */
2.139 +#define YY_NEW_FILE zconfrestart(zconfin )
2.140 +
2.141 +#define YY_END_OF_BUFFER_CHAR 0
2.142 +
2.143 +/* Size of default input buffer. */
2.144 +#ifndef YY_BUF_SIZE
2.145 +#define YY_BUF_SIZE 16384
2.146 +#endif
2.147 +
2.148 +/* The state buf must be large enough to hold one state per character in the main buffer.
2.149 + */
2.150 +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
2.151 +
2.152 +#ifndef YY_TYPEDEF_YY_BUFFER_STATE
2.153 +#define YY_TYPEDEF_YY_BUFFER_STATE
2.154 +typedef struct yy_buffer_state *YY_BUFFER_STATE;
2.155 +#endif
2.156 +
2.157 +extern int zconfleng;
2.158 +
2.159 +extern FILE *zconfin, *zconfout;
2.160 +
2.161 +#define EOB_ACT_CONTINUE_SCAN 0
2.162 +#define EOB_ACT_END_OF_FILE 1
2.163 +#define EOB_ACT_LAST_MATCH 2
2.164 +
2.165 + #define YY_LESS_LINENO(n)
2.166 +
2.167 +/* Return all but the first "n" matched characters back to the input stream. */
2.168 +#define yyless(n) \
2.169 + do \
2.170 + { \
2.171 + /* Undo effects of setting up zconftext. */ \
2.172 + int yyless_macro_arg = (n); \
2.173 + YY_LESS_LINENO(yyless_macro_arg);\
2.174 + *yy_cp = (yy_hold_char); \
2.175 + YY_RESTORE_YY_MORE_OFFSET \
2.176 + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
2.177 + YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
2.178 + } \
2.179 + while ( 0 )
2.180 +
2.181 +#define unput(c) yyunput( c, (yytext_ptr) )
2.182 +
2.183 +/* The following is because we cannot portably get our hands on size_t
2.184 + * (without autoconf's help, which isn't available because we want
2.185 + * flex-generated scanners to compile on their own).
2.186 + */
2.187 +
2.188 +#ifndef YY_TYPEDEF_YY_SIZE_T
2.189 +#define YY_TYPEDEF_YY_SIZE_T
2.190 +typedef unsigned int yy_size_t;
2.191 +#endif
2.192 +
2.193 +#ifndef YY_STRUCT_YY_BUFFER_STATE
2.194 +#define YY_STRUCT_YY_BUFFER_STATE
2.195 +struct yy_buffer_state
2.196 + {
2.197 + FILE *yy_input_file;
2.198 +
2.199 + char *yy_ch_buf; /* input buffer */
2.200 + char *yy_buf_pos; /* current position in input buffer */
2.201 +
2.202 + /* Size of input buffer in bytes, not including room for EOB
2.203 + * characters.
2.204 + */
2.205 + yy_size_t yy_buf_size;
2.206 +
2.207 + /* Number of characters read into yy_ch_buf, not including EOB
2.208 + * characters.
2.209 + */
2.210 + int yy_n_chars;
2.211 +
2.212 + /* Whether we "own" the buffer - i.e., we know we created it,
2.213 + * and can realloc() it to grow it, and should free() it to
2.214 + * delete it.
2.215 + */
2.216 + int yy_is_our_buffer;
2.217 +
2.218 + /* Whether this is an "interactive" input source; if so, and
2.219 + * if we're using stdio for input, then we want to use getc()
2.220 + * instead of fread(), to make sure we stop fetching input after
2.221 + * each newline.
2.222 + */
2.223 + int yy_is_interactive;
2.224 +
2.225 + /* Whether we're considered to be at the beginning of a line.
2.226 + * If so, '^' rules will be active on the next match, otherwise
2.227 + * not.
2.228 + */
2.229 + int yy_at_bol;
2.230 +
2.231 + int yy_bs_lineno; /**< The line count. */
2.232 + int yy_bs_column; /**< The column count. */
2.233 +
2.234 + /* Whether to try to fill the input buffer when we reach the
2.235 + * end of it.
2.236 + */
2.237 + int yy_fill_buffer;
2.238 +
2.239 + int yy_buffer_status;
2.240 +
2.241 +#define YY_BUFFER_NEW 0
2.242 +#define YY_BUFFER_NORMAL 1
2.243 + /* When an EOF's been seen but there's still some text to process
2.244 + * then we mark the buffer as YY_EOF_PENDING, to indicate that we
2.245 + * shouldn't try reading from the input source any more. We might
2.246 + * still have a bunch of tokens to match, though, because of
2.247 + * possible backing-up.
2.248 + *
2.249 + * When we actually see the EOF, we change the status to "new"
2.250 + * (via zconfrestart()), so that the user can continue scanning by
2.251 + * just pointing zconfin at a new input file.
2.252 + */
2.253 +#define YY_BUFFER_EOF_PENDING 2
2.254 +
2.255 + };
2.256 +#endif /* !YY_STRUCT_YY_BUFFER_STATE */
2.257 +
2.258 +/* Stack of input buffers. */
2.259 +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
2.260 +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
2.261 +static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
2.262 +
2.263 +/* We provide macros for accessing buffer states in case in the
2.264 + * future we want to put the buffer states in a more general
2.265 + * "scanner state".
2.266 + *
2.267 + * Returns the top of the stack, or NULL.
2.268 + */
2.269 +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
2.270 + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
2.271 + : NULL)
2.272 +
2.273 +/* Same as previous macro, but useful when we know that the buffer stack is not
2.274 + * NULL or when we need an lvalue. For internal use only.
2.275 + */
2.276 +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
2.277 +
2.278 +/* yy_hold_char holds the character lost when zconftext is formed. */
2.279 +static char yy_hold_char;
2.280 +static int yy_n_chars; /* number of characters read into yy_ch_buf */
2.281 +int zconfleng;
2.282 +
2.283 +/* Points to current character in buffer. */
2.284 +static char *yy_c_buf_p = (char *) 0;
2.285 +static int yy_init = 0; /* whether we need to initialize */
2.286 +static int yy_start = 0; /* start state number */
2.287 +
2.288 +/* Flag which is used to allow zconfwrap()'s to do buffer switches
2.289 + * instead of setting up a fresh zconfin. A bit of a hack ...
2.290 + */
2.291 +static int yy_did_buffer_switch_on_eof;
2.292 +
2.293 +void zconfrestart (FILE *input_file );
2.294 +void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer );
2.295 +YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size );
2.296 +void zconf_delete_buffer (YY_BUFFER_STATE b );
2.297 +void zconf_flush_buffer (YY_BUFFER_STATE b );
2.298 +void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer );
2.299 +void zconfpop_buffer_state (void );
2.300 +
2.301 +static void zconfensure_buffer_stack (void );
2.302 +static void zconf_load_buffer_state (void );
2.303 +static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file );
2.304 +
2.305 +#define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
2.306 +
2.307 +YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size );
2.308 +YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str );
2.309 +YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len );
2.310 +
2.311 +void *zconfalloc (yy_size_t );
2.312 +void *zconfrealloc (void *,yy_size_t );
2.313 +void zconffree (void * );
2.314 +
2.315 +#define yy_new_buffer zconf_create_buffer
2.316 +
2.317 +#define yy_set_interactive(is_interactive) \
2.318 + { \
2.319 + if ( ! YY_CURRENT_BUFFER ){ \
2.320 + zconfensure_buffer_stack (); \
2.321 + YY_CURRENT_BUFFER_LVALUE = \
2.322 + zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
2.323 + } \
2.324 + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
2.325 + }
2.326 +
2.327 +#define yy_set_bol(at_bol) \
2.328 + { \
2.329 + if ( ! YY_CURRENT_BUFFER ){\
2.330 + zconfensure_buffer_stack (); \
2.331 + YY_CURRENT_BUFFER_LVALUE = \
2.332 + zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
2.333 + } \
2.334 + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
2.335 + }
2.336 +
2.337 +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
2.338 +
2.339 +/* Begin user sect3 */
2.340 +
2.341 +#define zconfwrap() 1
2.342 +#define YY_SKIP_YYWRAP
2.343 +
2.344 +typedef unsigned char YY_CHAR;
2.345 +
2.346 +FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
2.347 +
2.348 +typedef int yy_state_type;
2.349 +
2.350 +extern int zconflineno;
2.351 +
2.352 +int zconflineno = 1;
2.353 +
2.354 +extern char *zconftext;
2.355 +#define yytext_ptr zconftext
2.356 +static yyconst flex_int16_t yy_nxt[][17] =
2.357 + {
2.358 + {
2.359 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2.360 + 0, 0, 0, 0, 0, 0, 0
2.361 + },
2.362 +
2.363 + {
2.364 + 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
2.365 + 12, 12, 12, 12, 12, 12, 12
2.366 + },
2.367 +
2.368 + {
2.369 + 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
2.370 + 12, 12, 12, 12, 12, 12, 12
2.371 + },
2.372 +
2.373 + {
2.374 + 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
2.375 + 16, 16, 16, 18, 16, 16, 16
2.376 + },
2.377 +
2.378 + {
2.379 + 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
2.380 + 16, 16, 16, 18, 16, 16, 16
2.381 +
2.382 + },
2.383 +
2.384 + {
2.385 + 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
2.386 + 19, 19, 19, 19, 19, 19, 19
2.387 + },
2.388 +
2.389 + {
2.390 + 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
2.391 + 19, 19, 19, 19, 19, 19, 19
2.392 + },
2.393 +
2.394 + {
2.395 + 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
2.396 + 22, 22, 22, 22, 22, 25, 22
2.397 + },
2.398 +
2.399 + {
2.400 + 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
2.401 + 22, 22, 22, 22, 22, 25, 22
2.402 + },
2.403 +
2.404 + {
2.405 + 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
2.406 + 33, 34, 35, 35, 36, 37, 38
2.407 +
2.408 + },
2.409 +
2.410 + {
2.411 + 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
2.412 + 33, 34, 35, 35, 36, 37, 38
2.413 + },
2.414 +
2.415 + {
2.416 + -11, -11, -11, -11, -11, -11, -11, -11, -11, -11,
2.417 + -11, -11, -11, -11, -11, -11, -11
2.418 + },
2.419 +
2.420 + {
2.421 + 11, -12, -12, -12, -12, -12, -12, -12, -12, -12,
2.422 + -12, -12, -12, -12, -12, -12, -12
2.423 + },
2.424 +
2.425 + {
2.426 + 11, -13, 39, 40, -13, -13, 41, -13, -13, -13,
2.427 + -13, -13, -13, -13, -13, -13, -13
2.428 + },
2.429 +
2.430 + {
2.431 + 11, -14, -14, -14, -14, -14, -14, -14, -14, -14,
2.432 + -14, -14, -14, -14, -14, -14, -14
2.433 +
2.434 + },
2.435 +
2.436 + {
2.437 + 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
2.438 + 42, 42, 42, 42, 42, 42, 42
2.439 + },
2.440 +
2.441 + {
2.442 + 11, -16, -16, -16, -16, -16, -16, -16, -16, -16,
2.443 + -16, -16, -16, -16, -16, -16, -16
2.444 + },
2.445 +
2.446 + {
2.447 + 11, -17, -17, -17, -17, -17, -17, -17, -17, -17,
2.448 + -17, -17, -17, -17, -17, -17, -17
2.449 + },
2.450 +
2.451 + {
2.452 + 11, -18, -18, -18, -18, -18, -18, -18, -18, -18,
2.453 + -18, -18, -18, 44, -18, -18, -18
2.454 + },
2.455 +
2.456 + {
2.457 + 11, 45, 45, -19, 45, 45, 45, 45, 45, 45,
2.458 + 45, 45, 45, 45, 45, 45, 45
2.459 +
2.460 + },
2.461 +
2.462 + {
2.463 + 11, -20, 46, 47, -20, -20, -20, -20, -20, -20,
2.464 + -20, -20, -20, -20, -20, -20, -20
2.465 + },
2.466 +
2.467 + {
2.468 + 11, 48, -21, -21, 48, 48, 48, 48, 48, 48,
2.469 + 48, 48, 48, 48, 48, 48, 48
2.470 + },
2.471 +
2.472 + {
2.473 + 11, 49, 49, 50, 49, -22, 49, 49, -22, 49,
2.474 + 49, 49, 49, 49, 49, -22, 49
2.475 + },
2.476 +
2.477 + {
2.478 + 11, -23, -23, -23, -23, -23, -23, -23, -23, -23,
2.479 + -23, -23, -23, -23, -23, -23, -23
2.480 + },
2.481 +
2.482 + {
2.483 + 11, -24, -24, -24, -24, -24, -24, -24, -24, -24,
2.484 + -24, -24, -24, -24, -24, -24, -24
2.485 +
2.486 + },
2.487 +
2.488 + {
2.489 + 11, 51, 51, 52, 51, 51, 51, 51, 51, 51,
2.490 + 51, 51, 51, 51, 51, 51, 51
2.491 + },
2.492 +
2.493 + {
2.494 + 11, -26, -26, -26, -26, -26, -26, -26, -26, -26,
2.495 + -26, -26, -26, -26, -26, -26, -26
2.496 + },
2.497 +
2.498 + {
2.499 + 11, -27, -27, -27, -27, -27, -27, -27, -27, -27,
2.500 + -27, -27, -27, -27, -27, -27, -27
2.501 + },
2.502 +
2.503 + {
2.504 + 11, -28, -28, -28, -28, -28, -28, -28, -28, -28,
2.505 + -28, -28, -28, -28, 53, -28, -28
2.506 + },
2.507 +
2.508 + {
2.509 + 11, -29, -29, -29, -29, -29, -29, -29, -29, -29,
2.510 + -29, -29, -29, -29, -29, -29, -29
2.511 +
2.512 + },
2.513 +
2.514 + {
2.515 + 11, 54, 54, -30, 54, 54, 54, 54, 54, 54,
2.516 + 54, 54, 54, 54, 54, 54, 54
2.517 + },
2.518 +
2.519 + {
2.520 + 11, -31, -31, -31, -31, -31, -31, 55, -31, -31,
2.521 + -31, -31, -31, -31, -31, -31, -31
2.522 + },
2.523 +
2.524 + {
2.525 + 11, -32, -32, -32, -32, -32, -32, -32, -32, -32,
2.526 + -32, -32, -32, -32, -32, -32, -32
2.527 + },
2.528 +
2.529 + {
2.530 + 11, -33, -33, -33, -33, -33, -33, -33, -33, -33,
2.531 + -33, -33, -33, -33, -33, -33, -33
2.532 + },
2.533 +
2.534 + {
2.535 + 11, -34, -34, -34, -34, -34, -34, -34, -34, -34,
2.536 + -34, 56, 57, 57, -34, -34, -34
2.537 +
2.538 + },
2.539 +
2.540 + {
2.541 + 11, -35, -35, -35, -35, -35, -35, -35, -35, -35,
2.542 + -35, 57, 57, 57, -35, -35, -35
2.543 + },
2.544 +
2.545 + {
2.546 + 11, -36, -36, -36, -36, -36, -36, -36, -36, -36,
2.547 + -36, -36, -36, -36, -36, -36, -36
2.548 + },
2.549 +
2.550 + {
2.551 + 11, -37, -37, 58, -37, -37, -37, -37, -37, -37,
2.552 + -37, -37, -37, -37, -37, -37, -37
2.553 + },
2.554 +
2.555 + {
2.556 + 11, -38, -38, -38, -38, -38, -38, -38, -38, -38,
2.557 + -38, -38, -38, -38, -38, -38, 59
2.558 + },
2.559 +
2.560 + {
2.561 + 11, -39, 39, 40, -39, -39, 41, -39, -39, -39,
2.562 + -39, -39, -39, -39, -39, -39, -39
2.563 +
2.564 + },
2.565 +
2.566 + {
2.567 + 11, -40, -40, -40, -40, -40, -40, -40, -40, -40,
2.568 + -40, -40, -40, -40, -40, -40, -40
2.569 + },
2.570 +
2.571 + {
2.572 + 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
2.573 + 42, 42, 42, 42, 42, 42, 42
2.574 + },
2.575 +
2.576 + {
2.577 + 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
2.578 + 42, 42, 42, 42, 42, 42, 42
2.579 + },
2.580 +
2.581 + {
2.582 + 11, -43, -43, -43, -43, -43, -43, -43, -43, -43,
2.583 + -43, -43, -43, -43, -43, -43, -43
2.584 + },
2.585 +
2.586 + {
2.587 + 11, -44, -44, -44, -44, -44, -44, -44, -44, -44,
2.588 + -44, -44, -44, 44, -44, -44, -44
2.589 +
2.590 + },
2.591 +
2.592 + {
2.593 + 11, 45, 45, -45, 45, 45, 45, 45, 45, 45,
2.594 + 45, 45, 45, 45, 45, 45, 45
2.595 + },
2.596 +
2.597 + {
2.598 + 11, -46, 46, 47, -46, -46, -46, -46, -46, -46,
2.599 + -46, -46, -46, -46, -46, -46, -46
2.600 + },
2.601 +
2.602 + {
2.603 + 11, 48, -47, -47, 48, 48, 48, 48, 48, 48,
2.604 + 48, 48, 48, 48, 48, 48, 48
2.605 + },
2.606 +
2.607 + {
2.608 + 11, -48, -48, -48, -48, -48, -48, -48, -48, -48,
2.609 + -48, -48, -48, -48, -48, -48, -48
2.610 + },
2.611 +
2.612 + {
2.613 + 11, 49, 49, 50, 49, -49, 49, 49, -49, 49,
2.614 + 49, 49, 49, 49, 49, -49, 49
2.615 +
2.616 + },
2.617 +
2.618 + {
2.619 + 11, -50, -50, -50, -50, -50, -50, -50, -50, -50,
2.620 + -50, -50, -50, -50, -50, -50, -50
2.621 + },
2.622 +
2.623 + {
2.624 + 11, -51, -51, 52, -51, -51, -51, -51, -51, -51,
2.625 + -51, -51, -51, -51, -51, -51, -51
2.626 + },
2.627 +
2.628 + {
2.629 + 11, -52, -52, -52, -52, -52, -52, -52, -52, -52,
2.630 + -52, -52, -52, -52, -52, -52, -52
2.631 + },
2.632 +
2.633 + {
2.634 + 11, -53, -53, -53, -53, -53, -53, -53, -53, -53,
2.635 + -53, -53, -53, -53, -53, -53, -53
2.636 + },
2.637 +
2.638 + {
2.639 + 11, 54, 54, -54, 54, 54, 54, 54, 54, 54,
2.640 + 54, 54, 54, 54, 54, 54, 54
2.641 +
2.642 + },
2.643 +
2.644 + {
2.645 + 11, -55, -55, -55, -55, -55, -55, -55, -55, -55,
2.646 + -55, -55, -55, -55, -55, -55, -55
2.647 + },
2.648 +
2.649 + {
2.650 + 11, -56, -56, -56, -56, -56, -56, -56, -56, -56,
2.651 + -56, 60, 57, 57, -56, -56, -56
2.652 + },
2.653 +
2.654 + {
2.655 + 11, -57, -57, -57, -57, -57, -57, -57, -57, -57,
2.656 + -57, 57, 57, 57, -57, -57, -57
2.657 + },
2.658 +
2.659 + {
2.660 + 11, -58, -58, -58, -58, -58, -58, -58, -58, -58,
2.661 + -58, -58, -58, -58, -58, -58, -58
2.662 + },
2.663 +
2.664 + {
2.665 + 11, -59, -59, -59, -59, -59, -59, -59, -59, -59,
2.666 + -59, -59, -59, -59, -59, -59, -59
2.667 +
2.668 + },
2.669 +
2.670 + {
2.671 + 11, -60, -60, -60, -60, -60, -60, -60, -60, -60,
2.672 + -60, 57, 57, 57, -60, -60, -60
2.673 + },
2.674 +
2.675 + } ;
2.676 +
2.677 +static yy_state_type yy_get_previous_state (void );
2.678 +static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
2.679 +static int yy_get_next_buffer (void );
2.680 +static void yy_fatal_error (yyconst char msg[] );
2.681 +
2.682 +/* Done after the current pattern has been matched and before the
2.683 + * corresponding action - sets up zconftext.
2.684 + */
2.685 +#define YY_DO_BEFORE_ACTION \
2.686 + (yytext_ptr) = yy_bp; \
2.687 + zconfleng = (size_t) (yy_cp - yy_bp); \
2.688 + (yy_hold_char) = *yy_cp; \
2.689 + *yy_cp = '\0'; \
2.690 + (yy_c_buf_p) = yy_cp;
2.691 +
2.692 +#define YY_NUM_RULES 33
2.693 +#define YY_END_OF_BUFFER 34
2.694 +/* This struct is not used in this scanner,
2.695 + but its presence is necessary. */
2.696 +struct yy_trans_info
2.697 + {
2.698 + flex_int32_t yy_verify;
2.699 + flex_int32_t yy_nxt;
2.700 + };
2.701 +static yyconst flex_int16_t yy_accept[61] =
2.702 + { 0,
2.703 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2.704 + 34, 5, 4, 2, 3, 7, 8, 6, 32, 29,
2.705 + 31, 24, 28, 27, 26, 22, 17, 13, 16, 20,
2.706 + 22, 11, 12, 19, 19, 14, 22, 22, 4, 2,
2.707 + 3, 3, 1, 6, 32, 29, 31, 30, 24, 23,
2.708 + 26, 25, 15, 20, 9, 19, 19, 21, 10, 18
2.709 + } ;
2.710 +
2.711 +static yyconst flex_int32_t yy_ec[256] =
2.712 + { 0,
2.713 + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
2.714 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.715 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.716 + 1, 2, 4, 5, 6, 1, 1, 7, 8, 9,
2.717 + 10, 1, 1, 1, 11, 12, 12, 13, 13, 13,
2.718 + 13, 13, 13, 13, 13, 13, 13, 1, 1, 1,
2.719 + 14, 1, 1, 1, 13, 13, 13, 13, 13, 13,
2.720 + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
2.721 + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
2.722 + 1, 15, 1, 1, 13, 1, 13, 13, 13, 13,
2.723 +
2.724 + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
2.725 + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
2.726 + 13, 13, 1, 16, 1, 1, 1, 1, 1, 1,
2.727 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.728 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.729 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.730 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.731 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.732 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.733 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.734 +
2.735 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.736 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.737 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.738 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.739 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2.740 + 1, 1, 1, 1, 1
2.741 + } ;
2.742 +
2.743 +extern int zconf_flex_debug;
2.744 +int zconf_flex_debug = 0;
2.745 +
2.746 +/* The intent behind this definition is that it'll catch
2.747 + * any uses of REJECT which flex missed.
2.748 + */
2.749 +#define REJECT reject_used_but_not_detected
2.750 +#define yymore() yymore_used_but_not_detected
2.751 +#define YY_MORE_ADJ 0
2.752 +#define YY_RESTORE_YY_MORE_OFFSET
2.753 +char *zconftext;
2.754 +
2.755 +/*
2.756 + * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
2.757 + * Released under the terms of the GNU GPL v2.0.
2.758 + */
2.759 +
2.760 +#include <limits.h>
2.761 +#include <stdio.h>
2.762 +#include <stdlib.h>
2.763 +#include <string.h>
2.764 +#include <unistd.h>
2.765 +
2.766 +#define LKC_DIRECT_LINK
2.767 +#include "lkc.h"
2.768 +
2.769 +#define START_STRSIZE 16
2.770 +
2.771 +static struct {
2.772 + struct file *file;
2.773 + int lineno;
2.774 +} current_pos;
2.775 +
2.776 +static char *text;
2.777 +static int text_size, text_asize;
2.778 +
2.779 +struct buffer {
2.780 + struct buffer *parent;
2.781 + YY_BUFFER_STATE state;
2.782 +};
2.783 +
2.784 +struct buffer *current_buf;
2.785 +
2.786 +static int last_ts, first_ts;
2.787 +
2.788 +static void zconf_endhelp(void);
2.789 +static void zconf_endfile(void);
2.790 +
2.791 +void new_string(void)
2.792 +{
2.793 + text = malloc(START_STRSIZE);
2.794 + text_asize = START_STRSIZE;
2.795 + text_size = 0;
2.796 + *text = 0;
2.797 +}
2.798 +
2.799 +void append_string(const char *str, int size)
2.800 +{
2.801 + int new_size = text_size + size + 1;
2.802 + if (new_size > text_asize) {
2.803 + new_size += START_STRSIZE - 1;
2.804 + new_size &= -START_STRSIZE;
2.805 + text = realloc(text, new_size);
2.806 + text_asize = new_size;
2.807 + }
2.808 + memcpy(text + text_size, str, size);
2.809 + text_size += size;
2.810 + text[text_size] = 0;
2.811 +}
2.812 +
2.813 +void alloc_string(const char *str, int size)
2.814 +{
2.815 + text = malloc(size + 1);
2.816 + memcpy(text, str, size);
2.817 + text[size] = 0;
2.818 +}
2.819 +
2.820 +#define INITIAL 0
2.821 +#define COMMAND 1
2.822 +#define HELP 2
2.823 +#define STRING 3
2.824 +#define PARAM 4
2.825 +
2.826 +#ifndef YY_NO_UNISTD_H
2.827 +/* Special case for "unistd.h", since it is non-ANSI. We include it way
2.828 + * down here because we want the user's section 1 to have been scanned first.
2.829 + * The user has a chance to override it with an option.
2.830 + */
2.831 +#include <unistd.h>
2.832 +#endif
2.833 +
2.834 +#ifndef YY_EXTRA_TYPE
2.835 +#define YY_EXTRA_TYPE void *
2.836 +#endif
2.837 +
2.838 +static int yy_init_globals (void );
2.839 +
2.840 +/* Macros after this point can all be overridden by user definitions in
2.841 + * section 1.
2.842 + */
2.843 +
2.844 +#ifndef YY_SKIP_YYWRAP
2.845 +#ifdef __cplusplus
2.846 +extern "C" int zconfwrap (void );
2.847 +#else
2.848 +extern int zconfwrap (void );
2.849 +#endif
2.850 +#endif
2.851 +
2.852 + static void yyunput (int c,char *buf_ptr );
2.853 +
2.854 +#ifndef yytext_ptr
2.855 +static void yy_flex_strncpy (char *,yyconst char *,int );
2.856 +#endif
2.857 +
2.858 +#ifdef YY_NEED_STRLEN
2.859 +static int yy_flex_strlen (yyconst char * );
2.860 +#endif
2.861 +
2.862 +#ifndef YY_NO_INPUT
2.863 +
2.864 +#ifdef __cplusplus
2.865 +static int yyinput (void );
2.866 +#else
2.867 +static int input (void );
2.868 +#endif
2.869 +
2.870 +#endif
2.871 +
2.872 +/* Amount of stuff to slurp up with each read. */
2.873 +#ifndef YY_READ_BUF_SIZE
2.874 +#define YY_READ_BUF_SIZE 8192
2.875 +#endif
2.876 +
2.877 +/* Copy whatever the last rule matched to the standard output. */
2.878 +#ifndef ECHO
2.879 +/* This used to be an fputs(), but since the string might contain NUL's,
2.880 + * we now use fwrite().
2.881 + */
2.882 +#define ECHO (void) fwrite( zconftext, zconfleng, 1, zconfout )
2.883 +#endif
2.884 +
2.885 +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
2.886 + * is returned in "result".
2.887 + */
2.888 +#ifndef YY_INPUT
2.889 +#define YY_INPUT(buf,result,max_size) \
2.890 + errno=0; \
2.891 + while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
2.892 + { \
2.893 + if( errno != EINTR) \
2.894 + { \
2.895 + YY_FATAL_ERROR( "input in flex scanner failed" ); \
2.896 + break; \
2.897 + } \
2.898 + errno=0; \
2.899 + clearerr(zconfin); \
2.900 + }\
2.901 +\
2.902 +
2.903 +#endif
2.904 +
2.905 +/* No semi-colon after return; correct usage is to write "yyterminate();" -
2.906 + * we don't want an extra ';' after the "return" because that will cause
2.907 + * some compilers to complain about unreachable statements.
2.908 + */
2.909 +#ifndef yyterminate
2.910 +#define yyterminate() return YY_NULL
2.911 +#endif
2.912 +
2.913 +/* Number of entries by which start-condition stack grows. */
2.914 +#ifndef YY_START_STACK_INCR
2.915 +#define YY_START_STACK_INCR 25
2.916 +#endif
2.917 +
2.918 +/* Report a fatal error. */
2.919 +#ifndef YY_FATAL_ERROR
2.920 +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
2.921 +#endif
2.922 +
2.923 +/* end tables serialization structures and prototypes */
2.924 +
2.925 +/* Default declaration of generated scanner - a define so the user can
2.926 + * easily add parameters.
2.927 + */
2.928 +#ifndef YY_DECL
2.929 +#define YY_DECL_IS_OURS 1
2.930 +
2.931 +extern int zconflex (void);
2.932 +
2.933 +#define YY_DECL int zconflex (void)
2.934 +#endif /* !YY_DECL */
2.935 +
2.936 +/* Code executed at the beginning of each rule, after zconftext and zconfleng
2.937 + * have been set up.
2.938 + */
2.939 +#ifndef YY_USER_ACTION
2.940 +#define YY_USER_ACTION
2.941 +#endif
2.942 +
2.943 +/* Code executed at the end of each rule. */
2.944 +#ifndef YY_BREAK
2.945 +#define YY_BREAK break;
2.946 +#endif
2.947 +
2.948 +#define YY_RULE_SETUP \
2.949 + YY_USER_ACTION
2.950 +
2.951 +/** The main scanner function which does all the work.
2.952 + */
2.953 +YY_DECL
2.954 +{
2.955 + register yy_state_type yy_current_state;
2.956 + register char *yy_cp, *yy_bp;
2.957 + register int yy_act;
2.958 +
2.959 + int str = 0;
2.960 + int ts, i;
2.961 +
2.962 + if ( !(yy_init) )
2.963 + {
2.964 + (yy_init) = 1;
2.965 +
2.966 +#ifdef YY_USER_INIT
2.967 + YY_USER_INIT;
2.968 +#endif
2.969 +
2.970 + if ( ! (yy_start) )
2.971 + (yy_start) = 1; /* first start state */
2.972 +
2.973 + if ( ! zconfin )
2.974 + zconfin = stdin;
2.975 +
2.976 + if ( ! zconfout )
2.977 + zconfout = stdout;
2.978 +
2.979 + if ( ! YY_CURRENT_BUFFER ) {
2.980 + zconfensure_buffer_stack ();
2.981 + YY_CURRENT_BUFFER_LVALUE =
2.982 + zconf_create_buffer(zconfin,YY_BUF_SIZE );
2.983 + }
2.984 +
2.985 + zconf_load_buffer_state( );
2.986 + }
2.987 +
2.988 + while ( 1 ) /* loops until end-of-file is reached */
2.989 + {
2.990 + yy_cp = (yy_c_buf_p);
2.991 +
2.992 + /* Support of zconftext. */
2.993 + *yy_cp = (yy_hold_char);
2.994 +
2.995 + /* yy_bp points to the position in yy_ch_buf of the start of
2.996 + * the current run.
2.997 + */
2.998 + yy_bp = yy_cp;
2.999 +
2.1000 + yy_current_state = (yy_start);
2.1001 +yy_match:
2.1002 + while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)] ]) > 0 )
2.1003 + ++yy_cp;
2.1004 +
2.1005 + yy_current_state = -yy_current_state;
2.1006 +
2.1007 +yy_find_action:
2.1008 + yy_act = yy_accept[yy_current_state];
2.1009 +
2.1010 + YY_DO_BEFORE_ACTION;
2.1011 +
2.1012 +do_action: /* This label is used only to access EOF actions. */
2.1013 +
2.1014 + switch ( yy_act )
2.1015 + { /* beginning of action switch */
2.1016 +case 1:
2.1017 +/* rule 1 can match eol */
2.1018 +case 2:
2.1019 +/* rule 2 can match eol */
2.1020 +YY_RULE_SETUP
2.1021 +{
2.1022 + current_file->lineno++;
2.1023 + return T_EOL;
2.1024 +}
2.1025 + YY_BREAK
2.1026 +case 3:
2.1027 +YY_RULE_SETUP
2.1028 +
2.1029 + YY_BREAK
2.1030 +case 4:
2.1031 +YY_RULE_SETUP
2.1032 +{
2.1033 + BEGIN(COMMAND);
2.1034 +}
2.1035 + YY_BREAK
2.1036 +case 5:
2.1037 +YY_RULE_SETUP
2.1038 +{
2.1039 + unput(zconftext[0]);
2.1040 + BEGIN(COMMAND);
2.1041 +}
2.1042 + YY_BREAK
2.1043 +
2.1044 +case 6:
2.1045 +YY_RULE_SETUP
2.1046 +{
2.1047 + struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
2.1048 + BEGIN(PARAM);
2.1049 + current_pos.file = current_file;
2.1050 + current_pos.lineno = current_file->lineno;
2.1051 + if (id && id->flags & TF_COMMAND) {
2.1052 + zconflval.id = id;
2.1053 + return id->token;
2.1054 + }
2.1055 + alloc_string(zconftext, zconfleng);
2.1056 + zconflval.string = text;
2.1057 + return T_WORD;
2.1058 + }
2.1059 + YY_BREAK
2.1060 +case 7:
2.1061 +YY_RULE_SETUP
2.1062 +
2.1063 + YY_BREAK
2.1064 +case 8:
2.1065 +/* rule 8 can match eol */
2.1066 +YY_RULE_SETUP
2.1067 +{
2.1068 + BEGIN(INITIAL);
2.1069 + current_file->lineno++;
2.1070 + return T_EOL;
2.1071 + }
2.1072 + YY_BREAK
2.1073 +
2.1074 +case 9:
2.1075 +YY_RULE_SETUP
2.1076 +return T_AND;
2.1077 + YY_BREAK
2.1078 +case 10:
2.1079 +YY_RULE_SETUP
2.1080 +return T_OR;
2.1081 + YY_BREAK
2.1082 +case 11:
2.1083 +YY_RULE_SETUP
2.1084 +return T_OPEN_PAREN;
2.1085 + YY_BREAK
2.1086 +case 12:
2.1087 +YY_RULE_SETUP
2.1088 +return T_CLOSE_PAREN;
2.1089 + YY_BREAK
2.1090 +case 13:
2.1091 +YY_RULE_SETUP
2.1092 +return T_NOT;
2.1093 + YY_BREAK
2.1094 +case 14:
2.1095 +YY_RULE_SETUP
2.1096 +return T_EQUAL;
2.1097 + YY_BREAK
2.1098 +case 15:
2.1099 +YY_RULE_SETUP
2.1100 +return T_UNEQUAL;
2.1101 + YY_BREAK
2.1102 +case 16:
2.1103 +YY_RULE_SETUP
2.1104 +{
2.1105 + str = zconftext[0];
2.1106 + new_string();
2.1107 + BEGIN(STRING);
2.1108 + }
2.1109 + YY_BREAK
2.1110 +case 17:
2.1111 +/* rule 17 can match eol */
2.1112 +YY_RULE_SETUP
2.1113 +BEGIN(INITIAL); current_file->lineno++; return T_EOL;
2.1114 + YY_BREAK
2.1115 +case 18:
2.1116 +YY_RULE_SETUP
2.1117 +/* ignore */
2.1118 + YY_BREAK
2.1119 +case 19:
2.1120 +YY_RULE_SETUP
2.1121 +{
2.1122 + struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
2.1123 + if (id && id->flags & TF_PARAM) {
2.1124 + zconflval.id = id;
2.1125 + return id->token;
2.1126 + }
2.1127 + alloc_string(zconftext, zconfleng);
2.1128 + zconflval.string = text;
2.1129 + return T_WORD;
2.1130 + }
2.1131 + YY_BREAK
2.1132 +case 20:
2.1133 +YY_RULE_SETUP
2.1134 +/* comment */
2.1135 + YY_BREAK
2.1136 +case 21:
2.1137 +/* rule 21 can match eol */
2.1138 +YY_RULE_SETUP
2.1139 +current_file->lineno++;
2.1140 + YY_BREAK
2.1141 +case 22:
2.1142 +YY_RULE_SETUP
2.1143 +
2.1144 + YY_BREAK
2.1145 +case YY_STATE_EOF(PARAM):
2.1146 +{
2.1147 + BEGIN(INITIAL);
2.1148 + }
2.1149 + YY_BREAK
2.1150 +
2.1151 +case 23:
2.1152 +/* rule 23 can match eol */
2.1153 +*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
2.1154 +(yy_c_buf_p) = yy_cp -= 1;
2.1155 +YY_DO_BEFORE_ACTION; /* set up zconftext again */
2.1156 +YY_RULE_SETUP
2.1157 +{
2.1158 + append_string(zconftext, zconfleng);
2.1159 + zconflval.string = text;
2.1160 + return T_WORD_QUOTE;
2.1161 + }
2.1162 + YY_BREAK
2.1163 +case 24:
2.1164 +YY_RULE_SETUP
2.1165 +{
2.1166 + append_string(zconftext, zconfleng);
2.1167 + }
2.1168 + YY_BREAK
2.1169 +case 25:
2.1170 +/* rule 25 can match eol */
2.1171 +*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
2.1172 +(yy_c_buf_p) = yy_cp -= 1;
2.1173 +YY_DO_BEFORE_ACTION; /* set up zconftext again */
2.1174 +YY_RULE_SETUP
2.1175 +{
2.1176 + append_string(zconftext + 1, zconfleng - 1);
2.1177 + zconflval.string = text;
2.1178 + return T_WORD_QUOTE;
2.1179 + }
2.1180 + YY_BREAK
2.1181 +case 26:
2.1182 +YY_RULE_SETUP
2.1183 +{
2.1184 + append_string(zconftext + 1, zconfleng - 1);
2.1185 + }
2.1186 + YY_BREAK
2.1187 +case 27:
2.1188 +YY_RULE_SETUP
2.1189 +{
2.1190 + if (str == zconftext[0]) {
2.1191 + BEGIN(PARAM);
2.1192 + zconflval.string = text;
2.1193 + return T_WORD_QUOTE;
2.1194 + } else
2.1195 + append_string(zconftext, 1);
2.1196 + }
2.1197 + YY_BREAK
2.1198 +case 28:
2.1199 +/* rule 28 can match eol */
2.1200 +YY_RULE_SETUP
2.1201 +{
2.1202 + printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
2.1203 + current_file->lineno++;
2.1204 + BEGIN(INITIAL);
2.1205 + return T_EOL;
2.1206 + }
2.1207 + YY_BREAK
2.1208 +case YY_STATE_EOF(STRING):
2.1209 +{
2.1210 + BEGIN(INITIAL);
2.1211 + }
2.1212 + YY_BREAK
2.1213 +
2.1214 +case 29:
2.1215 +YY_RULE_SETUP
2.1216 +{
2.1217 + ts = 0;
2.1218 + for (i = 0; i < zconfleng; i++) {
2.1219 + if (zconftext[i] == '\t')
2.1220 + ts = (ts & ~7) + 8;
2.1221 + else
2.1222 + ts++;
2.1223 + }
2.1224 + last_ts = ts;
2.1225 + if (first_ts) {
2.1226 + if (ts < first_ts) {
2.1227 + zconf_endhelp();
2.1228 + return T_HELPTEXT;
2.1229 + }
2.1230 + ts -= first_ts;
2.1231 + while (ts > 8) {
2.1232 + append_string(" ", 8);
2.1233 + ts -= 8;
2.1234 + }
2.1235 + append_string(" ", ts);
2.1236 + }
2.1237 + }
2.1238 + YY_BREAK
2.1239 +case 30:
2.1240 +/* rule 30 can match eol */
2.1241 +*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
2.1242 +(yy_c_buf_p) = yy_cp -= 1;
2.1243 +YY_DO_BEFORE_ACTION; /* set up zconftext again */
2.1244 +YY_RULE_SETUP
2.1245 +{
2.1246 + current_file->lineno++;
2.1247 + zconf_endhelp();
2.1248 + return T_HELPTEXT;
2.1249 + }
2.1250 + YY_BREAK
2.1251 +case 31:
2.1252 +/* rule 31 can match eol */
2.1253 +YY_RULE_SETUP
2.1254 +{
2.1255 + current_file->lineno++;
2.1256 + append_string("\n", 1);
2.1257 + }
2.1258 + YY_BREAK
2.1259 +case 32:
2.1260 +YY_RULE_SETUP
2.1261 +{
2.1262 + append_string(zconftext, zconfleng);
2.1263 + if (!first_ts)
2.1264 + first_ts = last_ts;
2.1265 + }
2.1266 + YY_BREAK
2.1267 +case YY_STATE_EOF(HELP):
2.1268 +{
2.1269 + zconf_endhelp();
2.1270 + return T_HELPTEXT;
2.1271 + }
2.1272 + YY_BREAK
2.1273 +
2.1274 +case YY_STATE_EOF(INITIAL):
2.1275 +case YY_STATE_EOF(COMMAND):
2.1276 +{
2.1277 + if (current_file) {
2.1278 + zconf_endfile();
2.1279 + return T_EOL;
2.1280 + }
2.1281 + fclose(zconfin);
2.1282 + yyterminate();
2.1283 +}
2.1284 + YY_BREAK
2.1285 +case 33:
2.1286 +YY_RULE_SETUP
2.1287 +YY_FATAL_ERROR( "flex scanner jammed" );
2.1288 + YY_BREAK
2.1289 +
2.1290 + case YY_END_OF_BUFFER:
2.1291 + {
2.1292 + /* Amount of text matched not including the EOB char. */
2.1293 + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2.1294 +
2.1295 + /* Undo the effects of YY_DO_BEFORE_ACTION. */
2.1296 + *yy_cp = (yy_hold_char);
2.1297 + YY_RESTORE_YY_MORE_OFFSET
2.1298 +
2.1299 + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2.1300 + {
2.1301 + /* We're scanning a new file or input source. It's
2.1302 + * possible that this happened because the user
2.1303 + * just pointed zconfin at a new source and called
2.1304 + * zconflex(). If so, then we have to assure
2.1305 + * consistency between YY_CURRENT_BUFFER and our
2.1306 + * globals. Here is the right place to do so, because
2.1307 + * this is the first action (other than possibly a
2.1308 + * back-up) that will match for the new input source.
2.1309 + */
2.1310 + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2.1311 + YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
2.1312 + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2.1313 + }
2.1314 +
2.1315 + /* Note that here we test for yy_c_buf_p "<=" to the position
2.1316 + * of the first EOB in the buffer, since yy_c_buf_p will
2.1317 + * already have been incremented past the NUL character
2.1318 + * (since all states make transitions on EOB to the
2.1319 + * end-of-buffer state). Contrast this with the test
2.1320 + * in input().
2.1321 + */
2.1322 + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2.1323 + { /* This was really a NUL. */
2.1324 + yy_state_type yy_next_state;
2.1325 +
2.1326 + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2.1327 +
2.1328 + yy_current_state = yy_get_previous_state( );
2.1329 +
2.1330 + /* Okay, we're now positioned to make the NUL
2.1331 + * transition. We couldn't have
2.1332 + * yy_get_previous_state() go ahead and do it
2.1333 + * for us because it doesn't know how to deal
2.1334 + * with the possibility of jamming (and we don't
2.1335 + * want to build jamming into it because then it
2.1336 + * will run more slowly).
2.1337 + */
2.1338 +
2.1339 + yy_next_state = yy_try_NUL_trans( yy_current_state );
2.1340 +
2.1341 + yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2.1342 +
2.1343 + if ( yy_next_state )
2.1344 + {
2.1345 + /* Consume the NUL. */
2.1346 + yy_cp = ++(yy_c_buf_p);
2.1347 + yy_current_state = yy_next_state;
2.1348 + goto yy_match;
2.1349 + }
2.1350 +
2.1351 + else
2.1352 + {
2.1353 + yy_cp = (yy_c_buf_p);
2.1354 + goto yy_find_action;
2.1355 + }
2.1356 + }
2.1357 +
2.1358 + else switch ( yy_get_next_buffer( ) )
2.1359 + {
2.1360 + case EOB_ACT_END_OF_FILE:
2.1361 + {
2.1362 + (yy_did_buffer_switch_on_eof) = 0;
2.1363 +
2.1364 + if ( zconfwrap( ) )
2.1365 + {
2.1366 + /* Note: because we've taken care in
2.1367 + * yy_get_next_buffer() to have set up
2.1368 + * zconftext, we can now set up
2.1369 + * yy_c_buf_p so that if some total
2.1370 + * hoser (like flex itself) wants to
2.1371 + * call the scanner after we return the
2.1372 + * YY_NULL, it'll still work - another
2.1373 + * YY_NULL will get returned.
2.1374 + */
2.1375 + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2.1376 +
2.1377 + yy_act = YY_STATE_EOF(YY_START);
2.1378 + goto do_action;
2.1379 + }
2.1380 +
2.1381 + else
2.1382 + {
2.1383 + if ( ! (yy_did_buffer_switch_on_eof) )
2.1384 + YY_NEW_FILE;
2.1385 + }
2.1386 + break;
2.1387 + }
2.1388 +
2.1389 + case EOB_ACT_CONTINUE_SCAN:
2.1390 + (yy_c_buf_p) =
2.1391 + (yytext_ptr) + yy_amount_of_matched_text;
2.1392 +
2.1393 + yy_current_state = yy_get_previous_state( );
2.1394 +
2.1395 + yy_cp = (yy_c_buf_p);
2.1396 + yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2.1397 + goto yy_match;
2.1398 +
2.1399 + case EOB_ACT_LAST_MATCH:
2.1400 + (yy_c_buf_p) =
2.1401 + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2.1402 +
2.1403 + yy_current_state = yy_get_previous_state( );
2.1404 +
2.1405 + yy_cp = (yy_c_buf_p);
2.1406 + yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2.1407 + goto yy_find_action;
2.1408 + }
2.1409 + break;
2.1410 + }
2.1411 +
2.1412 + default:
2.1413 + YY_FATAL_ERROR(
2.1414 + "fatal flex scanner internal error--no action found" );
2.1415 + } /* end of action switch */
2.1416 + } /* end of scanning one token */
2.1417 +} /* end of zconflex */
2.1418 +
2.1419 +/* yy_get_next_buffer - try to read in a new buffer
2.1420 + *
2.1421 + * Returns a code representing an action:
2.1422 + * EOB_ACT_LAST_MATCH -
2.1423 + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2.1424 + * EOB_ACT_END_OF_FILE - end of file
2.1425 + */
2.1426 +static int yy_get_next_buffer (void)
2.1427 +{
2.1428 + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2.1429 + register char *source = (yytext_ptr);
2.1430 + register int number_to_move, i;
2.1431 + int ret_val;
2.1432 +
2.1433 + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2.1434 + YY_FATAL_ERROR(
2.1435 + "fatal flex scanner internal error--end of buffer missed" );
2.1436 +
2.1437 + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2.1438 + { /* Don't try to fill the buffer, so this is an EOF. */
2.1439 + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2.1440 + {
2.1441 + /* We matched a single character, the EOB, so
2.1442 + * treat this as a final EOF.
2.1443 + */
2.1444 + return EOB_ACT_END_OF_FILE;
2.1445 + }
2.1446 +
2.1447 + else
2.1448 + {
2.1449 + /* We matched some text prior to the EOB, first
2.1450 + * process it.
2.1451 + */
2.1452 + return EOB_ACT_LAST_MATCH;
2.1453 + }
2.1454 + }
2.1455 +
2.1456 + /* Try to read more data. */
2.1457 +
2.1458 + /* First move last chars to start of buffer. */
2.1459 + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2.1460 +
2.1461 + for ( i = 0; i < number_to_move; ++i )
2.1462 + *(dest++) = *(source++);
2.1463 +
2.1464 + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2.1465 + /* don't do the read, it's not guaranteed to return an EOF,
2.1466 + * just force an EOF
2.1467 + */
2.1468 + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2.1469 +
2.1470 + else
2.1471 + {
2.1472 + int num_to_read =
2.1473 + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2.1474 +
2.1475 + while ( num_to_read <= 0 )
2.1476 + { /* Not enough room in the buffer - grow it. */
2.1477 +
2.1478 + /* just a shorter name for the current buffer */
2.1479 + YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
2.1480 +
2.1481 + int yy_c_buf_p_offset =
2.1482 + (int) ((yy_c_buf_p) - b->yy_ch_buf);
2.1483 +
2.1484 + if ( b->yy_is_our_buffer )
2.1485 + {
2.1486 + int new_size = b->yy_buf_size * 2;
2.1487 +
2.1488 + if ( new_size <= 0 )
2.1489 + b->yy_buf_size += b->yy_buf_size / 8;
2.1490 + else
2.1491 + b->yy_buf_size *= 2;
2.1492 +
2.1493 + b->yy_ch_buf = (char *)
2.1494 + /* Include room in for 2 EOB chars. */
2.1495 + zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
2.1496 + }
2.1497 + else
2.1498 + /* Can't grow it, we don't own it. */
2.1499 + b->yy_ch_buf = 0;
2.1500 +
2.1501 + if ( ! b->yy_ch_buf )
2.1502 + YY_FATAL_ERROR(
2.1503 + "fatal error - scanner input buffer overflow" );
2.1504 +
2.1505 + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2.1506 +
2.1507 + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2.1508 + number_to_move - 1;
2.1509 +
2.1510 + }
2.1511 +
2.1512 + if ( num_to_read > YY_READ_BUF_SIZE )
2.1513 + num_to_read = YY_READ_BUF_SIZE;
2.1514 +
2.1515 + /* Read in more data. */
2.1516 + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2.1517 + (yy_n_chars), num_to_read );
2.1518 +
2.1519 + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2.1520 + }
2.1521 +
2.1522 + if ( (yy_n_chars) == 0 )
2.1523 + {
2.1524 + if ( number_to_move == YY_MORE_ADJ )
2.1525 + {
2.1526 + ret_val = EOB_ACT_END_OF_FILE;
2.1527 + zconfrestart(zconfin );
2.1528 + }
2.1529 +
2.1530 + else
2.1531 + {
2.1532 + ret_val = EOB_ACT_LAST_MATCH;
2.1533 + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2.1534 + YY_BUFFER_EOF_PENDING;
2.1535 + }
2.1536 + }
2.1537 +
2.1538 + else
2.1539 + ret_val = EOB_ACT_CONTINUE_SCAN;
2.1540 +
2.1541 + (yy_n_chars) += number_to_move;
2.1542 + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2.1543 + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2.1544 +
2.1545 + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2.1546 +
2.1547 + return ret_val;
2.1548 +}
2.1549 +
2.1550 +/* yy_get_previous_state - get the state just before the EOB char was reached */
2.1551 +
2.1552 + static yy_state_type yy_get_previous_state (void)
2.1553 +{
2.1554 + register yy_state_type yy_current_state;
2.1555 + register char *yy_cp;
2.1556 +
2.1557 + yy_current_state = (yy_start);
2.1558 +
2.1559 + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2.1560 + {
2.1561 + yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
2.1562 + }
2.1563 +
2.1564 + return yy_current_state;
2.1565 +}
2.1566 +
2.1567 +/* yy_try_NUL_trans - try to make a transition on the NUL character
2.1568 + *
2.1569 + * synopsis
2.1570 + * next_state = yy_try_NUL_trans( current_state );
2.1571 + */
2.1572 + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
2.1573 +{
2.1574 + register int yy_is_jam;
2.1575 +
2.1576 + yy_current_state = yy_nxt[yy_current_state][1];
2.1577 + yy_is_jam = (yy_current_state <= 0);
2.1578 +
2.1579 + return yy_is_jam ? 0 : yy_current_state;
2.1580 +}
2.1581 +
2.1582 + static void yyunput (int c, register char * yy_bp )
2.1583 +{
2.1584 + register char *yy_cp;
2.1585 +
2.1586 + yy_cp = (yy_c_buf_p);
2.1587 +
2.1588 + /* undo effects of setting up zconftext */
2.1589 + *yy_cp = (yy_hold_char);
2.1590 +
2.1591 + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2.1592 + { /* need to shift things up to make room */
2.1593 + /* +2 for EOB chars. */
2.1594 + register int number_to_move = (yy_n_chars) + 2;
2.1595 + register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2.1596 + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2.1597 + register char *source =
2.1598 + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2.1599 +
2.1600 + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2.1601 + *--dest = *--source;
2.1602 +
2.1603 + yy_cp += (int) (dest - source);
2.1604 + yy_bp += (int) (dest - source);
2.1605 + YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2.1606 + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2.1607 +
2.1608 + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2.1609 + YY_FATAL_ERROR( "flex scanner push-back overflow" );
2.1610 + }
2.1611 +
2.1612 + *--yy_cp = (char) c;
2.1613 +
2.1614 + (yytext_ptr) = yy_bp;
2.1615 + (yy_hold_char) = *yy_cp;
2.1616 + (yy_c_buf_p) = yy_cp;
2.1617 +}
2.1618 +
2.1619 +#ifndef YY_NO_INPUT
2.1620 +#ifdef __cplusplus
2.1621 + static int yyinput (void)
2.1622 +#else
2.1623 + static int input (void)
2.1624 +#endif
2.1625 +
2.1626 +{
2.1627 + int c;
2.1628 +
2.1629 + *(yy_c_buf_p) = (yy_hold_char);
2.1630 +
2.1631 + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2.1632 + {
2.1633 + /* yy_c_buf_p now points to the character we want to return.
2.1634 + * If this occurs *before* the EOB characters, then it's a
2.1635 + * valid NUL; if not, then we've hit the end of the buffer.
2.1636 + */
2.1637 + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2.1638 + /* This was really a NUL. */
2.1639 + *(yy_c_buf_p) = '\0';
2.1640 +
2.1641 + else
2.1642 + { /* need more input */
2.1643 + int offset = (yy_c_buf_p) - (yytext_ptr);
2.1644 + ++(yy_c_buf_p);
2.1645 +
2.1646 + switch ( yy_get_next_buffer( ) )
2.1647 + {
2.1648 + case EOB_ACT_LAST_MATCH:
2.1649 + /* This happens because yy_g_n_b()
2.1650 + * sees that we've accumulated a
2.1651 + * token and flags that we need to
2.1652 + * try matching the token before
2.1653 + * proceeding. But for input(),
2.1654 + * there's no matching to consider.
2.1655 + * So convert the EOB_ACT_LAST_MATCH
2.1656 + * to EOB_ACT_END_OF_FILE.
2.1657 + */
2.1658 +
2.1659 + /* Reset buffer status. */
2.1660 + zconfrestart(zconfin );
2.1661 +
2.1662 + /*FALLTHROUGH*/
2.1663 +
2.1664 + case EOB_ACT_END_OF_FILE:
2.1665 + {
2.1666 + if ( zconfwrap( ) )
2.1667 + return EOF;
2.1668 +
2.1669 + if ( ! (yy_did_buffer_switch_on_eof) )
2.1670 + YY_NEW_FILE;
2.1671 +#ifdef __cplusplus
2.1672 + return yyinput();
2.1673 +#else
2.1674 + return input();
2.1675 +#endif
2.1676 + }
2.1677 +
2.1678 + case EOB_ACT_CONTINUE_SCAN:
2.1679 + (yy_c_buf_p) = (yytext_ptr) + offset;
2.1680 + break;
2.1681 + }
2.1682 + }
2.1683 + }
2.1684 +
2.1685 + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2.1686 + *(yy_c_buf_p) = '\0'; /* preserve zconftext */
2.1687 + (yy_hold_char) = *++(yy_c_buf_p);
2.1688 +
2.1689 + return c;
2.1690 +}
2.1691 +#endif /* ifndef YY_NO_INPUT */
2.1692 +
2.1693 +/** Immediately switch to a different input stream.
2.1694 + * @param input_file A readable stream.
2.1695 + *
2.1696 + * @note This function does not reset the start condition to @c INITIAL .
2.1697 + */
2.1698 + void zconfrestart (FILE * input_file )
2.1699 +{
2.1700 +
2.1701 + if ( ! YY_CURRENT_BUFFER ){
2.1702 + zconfensure_buffer_stack ();
2.1703 + YY_CURRENT_BUFFER_LVALUE =
2.1704 + zconf_create_buffer(zconfin,YY_BUF_SIZE );
2.1705 + }
2.1706 +
2.1707 + zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
2.1708 + zconf_load_buffer_state( );
2.1709 +}
2.1710 +
2.1711 +/** Switch to a different input buffer.
2.1712 + * @param new_buffer The new input buffer.
2.1713 + *
2.1714 + */
2.1715 + void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer )
2.1716 +{
2.1717 +
2.1718 + /* TODO. We should be able to replace this entire function body
2.1719 + * with
2.1720 + * zconfpop_buffer_state();
2.1721 + * zconfpush_buffer_state(new_buffer);
2.1722 + */
2.1723 + zconfensure_buffer_stack ();
2.1724 + if ( YY_CURRENT_BUFFER == new_buffer )
2.1725 + return;
2.1726 +
2.1727 + if ( YY_CURRENT_BUFFER )
2.1728 + {
2.1729 + /* Flush out information for old buffer. */
2.1730 + *(yy_c_buf_p) = (yy_hold_char);
2.1731 + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2.1732 + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2.1733 + }
2.1734 +
2.1735 + YY_CURRENT_BUFFER_LVALUE = new_buffer;
2.1736 + zconf_load_buffer_state( );
2.1737 +
2.1738 + /* We don't actually know whether we did this switch during
2.1739 + * EOF (zconfwrap()) processing, but the only time this flag
2.1740 + * is looked at is after zconfwrap() is called, so it's safe
2.1741 + * to go ahead and always set it.
2.1742 + */
2.1743 + (yy_did_buffer_switch_on_eof) = 1;
2.1744 +}
2.1745 +
2.1746 +static void zconf_load_buffer_state (void)
2.1747 +{
2.1748 + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2.1749 + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2.1750 + zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2.1751 + (yy_hold_char) = *(yy_c_buf_p);
2.1752 +}
2.1753 +
2.1754 +/** Allocate and initialize an input buffer state.
2.1755 + * @param file A readable stream.
2.1756 + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2.1757 + *
2.1758 + * @return the allocated buffer state.
2.1759 + */
2.1760 + YY_BUFFER_STATE zconf_create_buffer (FILE * file, int size )
2.1761 +{
2.1762 + YY_BUFFER_STATE b;
2.1763 +
2.1764 + b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
2.1765 + if ( ! b )
2.1766 + YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
2.1767 +
2.1768 + b->yy_buf_size = size;
2.1769 +
2.1770 + /* yy_ch_buf has to be 2 characters longer than the size given because
2.1771 + * we need to put in 2 end-of-buffer characters.
2.1772 + */
2.1773 + b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2 );
2.1774 + if ( ! b->yy_ch_buf )
2.1775 + YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
2.1776 +
2.1777 + b->yy_is_our_buffer = 1;
2.1778 +
2.1779 + zconf_init_buffer(b,file );
2.1780 +
2.1781 + return b;
2.1782 +}
2.1783 +
2.1784 +/** Destroy the buffer.
2.1785 + * @param b a buffer created with zconf_create_buffer()
2.1786 + *
2.1787 + */
2.1788 + void zconf_delete_buffer (YY_BUFFER_STATE b )
2.1789 +{
2.1790 +
2.1791 + if ( ! b )
2.1792 + return;
2.1793 +
2.1794 + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2.1795 + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2.1796 +
2.1797 + if ( b->yy_is_our_buffer )
2.1798 + zconffree((void *) b->yy_ch_buf );
2.1799 +
2.1800 + zconffree((void *) b );
2.1801 +}
2.1802 +
2.1803 +/* Initializes or reinitializes a buffer.
2.1804 + * This function is sometimes called more than once on the same buffer,
2.1805 + * such as during a zconfrestart() or at EOF.
2.1806 + */
2.1807 + static void zconf_init_buffer (YY_BUFFER_STATE b, FILE * file )
2.1808 +
2.1809 +{
2.1810 + int oerrno = errno;
2.1811 +
2.1812 + zconf_flush_buffer(b );
2.1813 +
2.1814 + b->yy_input_file = file;
2.1815 + b->yy_fill_buffer = 1;
2.1816 +
2.1817 + /* If b is the current buffer, then zconf_init_buffer was _probably_
2.1818 + * called from zconfrestart() or through yy_get_next_buffer.
2.1819 + * In that case, we don't want to reset the lineno or column.
2.1820 + */
2.1821 + if (b != YY_CURRENT_BUFFER){
2.1822 + b->yy_bs_lineno = 1;
2.1823 + b->yy_bs_column = 0;
2.1824 + }
2.1825 +
2.1826 + b->yy_is_interactive = 0;
2.1827 +
2.1828 + errno = oerrno;
2.1829 +}
2.1830 +
2.1831 +/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2.1832 + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2.1833 + *
2.1834 + */
2.1835 + void zconf_flush_buffer (YY_BUFFER_STATE b )
2.1836 +{
2.1837 + if ( ! b )
2.1838 + return;
2.1839 +
2.1840 + b->yy_n_chars = 0;
2.1841 +
2.1842 + /* We always need two end-of-buffer characters. The first causes
2.1843 + * a transition to the end-of-buffer state. The second causes
2.1844 + * a jam in that state.
2.1845 + */
2.1846 + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2.1847 + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2.1848 +
2.1849 + b->yy_buf_pos = &b->yy_ch_buf[0];
2.1850 +
2.1851 + b->yy_at_bol = 1;
2.1852 + b->yy_buffer_status = YY_BUFFER_NEW;
2.1853 +
2.1854 + if ( b == YY_CURRENT_BUFFER )
2.1855 + zconf_load_buffer_state( );
2.1856 +}
2.1857 +
2.1858 +/** Pushes the new state onto the stack. The new state becomes
2.1859 + * the current state. This function will allocate the stack
2.1860 + * if necessary.
2.1861 + * @param new_buffer The new state.
2.1862 + *
2.1863 + */
2.1864 +void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
2.1865 +{
2.1866 + if (new_buffer == NULL)
2.1867 + return;
2.1868 +
2.1869 + zconfensure_buffer_stack();
2.1870 +
2.1871 + /* This block is copied from zconf_switch_to_buffer. */
2.1872 + if ( YY_CURRENT_BUFFER )
2.1873 + {
2.1874 + /* Flush out information for old buffer. */
2.1875 + *(yy_c_buf_p) = (yy_hold_char);
2.1876 + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2.1877 + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2.1878 + }
2.1879 +
2.1880 + /* Only push if top exists. Otherwise, replace top. */
2.1881 + if (YY_CURRENT_BUFFER)
2.1882 + (yy_buffer_stack_top)++;
2.1883 + YY_CURRENT_BUFFER_LVALUE = new_buffer;
2.1884 +
2.1885 + /* copied from zconf_switch_to_buffer. */
2.1886 + zconf_load_buffer_state( );
2.1887 + (yy_did_buffer_switch_on_eof) = 1;
2.1888 +}
2.1889 +
2.1890 +/** Removes and deletes the top of the stack, if present.
2.1891 + * The next element becomes the new top.
2.1892 + *
2.1893 + */
2.1894 +void zconfpop_buffer_state (void)
2.1895 +{
2.1896 + if (!YY_CURRENT_BUFFER)
2.1897 + return;
2.1898 +
2.1899 + zconf_delete_buffer(YY_CURRENT_BUFFER );
2.1900 + YY_CURRENT_BUFFER_LVALUE = NULL;
2.1901 + if ((yy_buffer_stack_top) > 0)
2.1902 + --(yy_buffer_stack_top);
2.1903 +
2.1904 + if (YY_CURRENT_BUFFER) {
2.1905 + zconf_load_buffer_state( );
2.1906 + (yy_did_buffer_switch_on_eof) = 1;
2.1907 + }
2.1908 +}
2.1909 +
2.1910 +/* Allocates the stack if it does not exist.
2.1911 + * Guarantees space for at least one push.
2.1912 + */
2.1913 +static void zconfensure_buffer_stack (void)
2.1914 +{
2.1915 + int num_to_alloc;
2.1916 +
2.1917 + if (!(yy_buffer_stack)) {
2.1918 +
2.1919 + /* First allocation is just for 2 elements, since we don't know if this
2.1920 + * scanner will even need a stack. We use 2 instead of 1 to avoid an
2.1921 + * immediate realloc on the next call.
2.1922 + */
2.1923 + num_to_alloc = 1;
2.1924 + (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
2.1925 + (num_to_alloc * sizeof(struct yy_buffer_state*)
2.1926 + );
2.1927 +
2.1928 + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2.1929 +
2.1930 + (yy_buffer_stack_max) = num_to_alloc;
2.1931 + (yy_buffer_stack_top) = 0;
2.1932 + return;
2.1933 + }
2.1934 +
2.1935 + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2.1936 +
2.1937 + /* Increase the buffer to prepare for a possible push. */
2.1938 + int grow_size = 8 /* arbitrary grow size */;
2.1939 +
2.1940 + num_to_alloc = (yy_buffer_stack_max) + grow_size;
2.1941 + (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
2.1942 + ((yy_buffer_stack),
2.1943 + num_to_alloc * sizeof(struct yy_buffer_state*)
2.1944 + );
2.1945 +
2.1946 + /* zero only the new slots.*/
2.1947 + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2.1948 + (yy_buffer_stack_max) = num_to_alloc;
2.1949 + }
2.1950 +}
2.1951 +
2.1952 +/** Setup the input buffer state to scan directly from a user-specified character buffer.
2.1953 + * @param base the character buffer
2.1954 + * @param size the size in bytes of the character buffer
2.1955 + *
2.1956 + * @return the newly allocated buffer state object.
2.1957 + */
2.1958 +YY_BUFFER_STATE zconf_scan_buffer (char * base, yy_size_t size )
2.1959 +{
2.1960 + YY_BUFFER_STATE b;
2.1961 +
2.1962 + if ( size < 2 ||
2.1963 + base[size-2] != YY_END_OF_BUFFER_CHAR ||
2.1964 + base[size-1] != YY_END_OF_BUFFER_CHAR )
2.1965 + /* They forgot to leave room for the EOB's. */
2.1966 + return 0;
2.1967 +
2.1968 + b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
2.1969 + if ( ! b )
2.1970 + YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
2.1971 +
2.1972 + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2.1973 + b->yy_buf_pos = b->yy_ch_buf = base;
2.1974 + b->yy_is_our_buffer = 0;
2.1975 + b->yy_input_file = 0;
2.1976 + b->yy_n_chars = b->yy_buf_size;
2.1977 + b->yy_is_interactive = 0;
2.1978 + b->yy_at_bol = 1;
2.1979 + b->yy_fill_buffer = 0;
2.1980 + b->yy_buffer_status = YY_BUFFER_NEW;
2.1981 +
2.1982 + zconf_switch_to_buffer(b );
2.1983 +
2.1984 + return b;
2.1985 +}
2.1986 +
2.1987 +/** Setup the input buffer state to scan a string. The next call to zconflex() will
2.1988 + * scan from a @e copy of @a str.
2.1989 + * @param yystr a NUL-terminated string to scan
2.1990 + *
2.1991 + * @return the newly allocated buffer state object.
2.1992 + * @note If you want to scan bytes that may contain NUL values, then use
2.1993 + * zconf_scan_bytes() instead.
2.1994 + */
2.1995 +YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
2.1996 +{
2.1997 +
2.1998 + return zconf_scan_bytes(yystr,strlen(yystr) );
2.1999 +}
2.2000 +
2.2001 +/** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
2.2002 + * scan from a @e copy of @a bytes.
2.2003 + * @param bytes the byte buffer to scan
2.2004 + * @param len the number of bytes in the buffer pointed to by @a bytes.
2.2005 + *
2.2006 + * @return the newly allocated buffer state object.
2.2007 + */
2.2008 +YY_BUFFER_STATE zconf_scan_bytes (yyconst char * yybytes, int _yybytes_len )
2.2009 +{
2.2010 + YY_BUFFER_STATE b;
2.2011 + char *buf;
2.2012 + yy_size_t n;
2.2013 + int i;
2.2014 +
2.2015 + /* Get memory for full buffer, including space for trailing EOB's. */
2.2016 + n = _yybytes_len + 2;
2.2017 + buf = (char *) zconfalloc(n );
2.2018 + if ( ! buf )
2.2019 + YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
2.2020 +
2.2021 + for ( i = 0; i < _yybytes_len; ++i )
2.2022 + buf[i] = yybytes[i];
2.2023 +
2.2024 + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2.2025 +
2.2026 + b = zconf_scan_buffer(buf,n );
2.2027 + if ( ! b )
2.2028 + YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
2.2029 +
2.2030 + /* It's okay to grow etc. this buffer, and we should throw it
2.2031 + * away when we're done.
2.2032 + */
2.2033 + b->yy_is_our_buffer = 1;
2.2034 +
2.2035 + return b;
2.2036 +}
2.2037 +
2.2038 +#ifndef YY_EXIT_FAILURE
2.2039 +#define YY_EXIT_FAILURE 2
2.2040 +#endif
2.2041 +
2.2042 +static void yy_fatal_error (yyconst char* msg )
2.2043 +{
2.2044 + (void) fprintf( stderr, "%s\n", msg );
2.2045 + exit( YY_EXIT_FAILURE );
2.2046 +}
2.2047 +
2.2048 +/* Redefine yyless() so it works in section 3 code. */
2.2049 +
2.2050 +#undef yyless
2.2051 +#define yyless(n) \
2.2052 + do \
2.2053 + { \
2.2054 + /* Undo effects of setting up zconftext. */ \
2.2055 + int yyless_macro_arg = (n); \
2.2056 + YY_LESS_LINENO(yyless_macro_arg);\
2.2057 + zconftext[zconfleng] = (yy_hold_char); \
2.2058 + (yy_c_buf_p) = zconftext + yyless_macro_arg; \
2.2059 + (yy_hold_char) = *(yy_c_buf_p); \
2.2060 + *(yy_c_buf_p) = '\0'; \
2.2061 + zconfleng = yyless_macro_arg; \
2.2062 + } \
2.2063 + while ( 0 )
2.2064 +
2.2065 +/* Accessor methods (get/set functions) to struct members. */
2.2066 +
2.2067 +/** Get the current line number.
2.2068 + *
2.2069 + */
2.2070 +int zconfget_lineno (void)
2.2071 +{
2.2072 +
2.2073 + return zconflineno;
2.2074 +}
2.2075 +
2.2076 +/** Get the input stream.
2.2077 + *
2.2078 + */
2.2079 +FILE *zconfget_in (void)
2.2080 +{
2.2081 + return zconfin;
2.2082 +}
2.2083 +
2.2084 +/** Get the output stream.
2.2085 + *
2.2086 + */
2.2087 +FILE *zconfget_out (void)
2.2088 +{
2.2089 + return zconfout;
2.2090 +}
2.2091 +
2.2092 +/** Get the length of the current token.
2.2093 + *
2.2094 + */
2.2095 +int zconfget_leng (void)
2.2096 +{
2.2097 + return zconfleng;
2.2098 +}
2.2099 +
2.2100 +/** Get the current token.
2.2101 + *
2.2102 + */
2.2103 +
2.2104 +char *zconfget_text (void)
2.2105 +{
2.2106 + return zconftext;
2.2107 +}
2.2108 +
2.2109 +/** Set the current line number.
2.2110 + * @param line_number
2.2111 + *
2.2112 + */
2.2113 +void zconfset_lineno (int line_number )
2.2114 +{
2.2115 +
2.2116 + zconflineno = line_number;
2.2117 +}
2.2118 +
2.2119 +/** Set the input stream. This does not discard the current
2.2120 + * input buffer.
2.2121 + * @param in_str A readable stream.
2.2122 + *
2.2123 + * @see zconf_switch_to_buffer
2.2124 + */
2.2125 +void zconfset_in (FILE * in_str )
2.2126 +{
2.2127 + zconfin = in_str ;
2.2128 +}
2.2129 +
2.2130 +void zconfset_out (FILE * out_str )
2.2131 +{
2.2132 + zconfout = out_str ;
2.2133 +}
2.2134 +
2.2135 +int zconfget_debug (void)
2.2136 +{
2.2137 + return zconf_flex_debug;
2.2138 +}
2.2139 +
2.2140 +void zconfset_debug (int bdebug )
2.2141 +{
2.2142 + zconf_flex_debug = bdebug ;
2.2143 +}
2.2144 +
2.2145 +static int yy_init_globals (void)
2.2146 +{
2.2147 + /* Initialization is the same as for the non-reentrant scanner.
2.2148 + * This function is called from zconflex_destroy(), so don't allocate here.
2.2149 + */
2.2150 +
2.2151 + (yy_buffer_stack) = 0;
2.2152 + (yy_buffer_stack_top) = 0;
2.2153 + (yy_buffer_stack_max) = 0;
2.2154 + (yy_c_buf_p) = (char *) 0;
2.2155 + (yy_init) = 0;
2.2156 + (yy_start) = 0;
2.2157 +
2.2158 +/* Defined in main.c */
2.2159 +#ifdef YY_STDINIT
2.2160 + zconfin = stdin;
2.2161 + zconfout = stdout;
2.2162 +#else
2.2163 + zconfin = (FILE *) 0;
2.2164 + zconfout = (FILE *) 0;
2.2165 +#endif
2.2166 +
2.2167 + /* For future reference: Set errno on error, since we are called by
2.2168 + * zconflex_init()
2.2169 + */
2.2170 + return 0;
2.2171 +}
2.2172 +
2.2173 +/* zconflex_destroy is for both reentrant and non-reentrant scanners. */
2.2174 +int zconflex_destroy (void)
2.2175 +{
2.2176 +
2.2177 + /* Pop the buffer stack, destroying each element. */
2.2178 + while(YY_CURRENT_BUFFER){
2.2179 + zconf_delete_buffer(YY_CURRENT_BUFFER );
2.2180 + YY_CURRENT_BUFFER_LVALUE = NULL;
2.2181 + zconfpop_buffer_state();
2.2182 + }
2.2183 +
2.2184 + /* Destroy the stack itself. */
2.2185 + zconffree((yy_buffer_stack) );
2.2186 + (yy_buffer_stack) = NULL;
2.2187 +
2.2188 + /* Reset the globals. This is important in a non-reentrant scanner so the next time
2.2189 + * zconflex() is called, initialization will occur. */
2.2190 + yy_init_globals( );
2.2191 +
2.2192 + return 0;
2.2193 +}
2.2194 +
2.2195 +/*
2.2196 + * Internal utility routines.
2.2197 + */
2.2198 +
2.2199 +#ifndef yytext_ptr
2.2200 +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2.2201 +{
2.2202 + register int i;
2.2203 + for ( i = 0; i < n; ++i )
2.2204 + s1[i] = s2[i];
2.2205 +}
2.2206 +#endif
2.2207 +
2.2208 +#ifdef YY_NEED_STRLEN
2.2209 +static int yy_flex_strlen (yyconst char * s )
2.2210 +{
2.2211 + register int n;
2.2212 + for ( n = 0; s[n]; ++n )
2.2213 + ;
2.2214 +
2.2215 + return n;
2.2216 +}
2.2217 +#endif
2.2218 +
2.2219 +void *zconfalloc (yy_size_t size )
2.2220 +{
2.2221 + return (void *) malloc( size );
2.2222 +}
2.2223 +
2.2224 +void *zconfrealloc (void * ptr, yy_size_t size )
2.2225 +{
2.2226 + /* The cast to (char *) in the following accommodates both
2.2227 + * implementations that use char* generic pointers, and those
2.2228 + * that use void* generic pointers. It works with the latter
2.2229 + * because both ANSI C and C++ allow castless assignment from
2.2230 + * any pointer type to void*, and deal with argument conversions
2.2231 + * as though doing an assignment.
2.2232 + */
2.2233 + return (void *) realloc( (char *) ptr, size );
2.2234 +}
2.2235 +
2.2236 +void zconffree (void * ptr )
2.2237 +{
2.2238 + free( (char *) ptr ); /* see zconfrealloc() for (char *) cast */
2.2239 +}
2.2240 +
2.2241 +#define YYTABLES_NAME "yytables"
2.2242 +
2.2243 +void zconf_starthelp(void)
2.2244 +{
2.2245 + new_string();
2.2246 + last_ts = first_ts = 0;
2.2247 + BEGIN(HELP);
2.2248 +}
2.2249 +
2.2250 +static void zconf_endhelp(void)
2.2251 +{
2.2252 + zconflval.string = text;
2.2253 + BEGIN(INITIAL);
2.2254 +}
2.2255 +
2.2256 +/*
2.2257 + * Try to open specified file with following names:
2.2258 + * ./name
2.2259 + * $(srctree)/name
2.2260 + * The latter is used when srctree is separate from objtree
2.2261 + * when compiling the kernel.
2.2262 + * Return NULL if file is not found.
2.2263 + */
2.2264 +FILE *zconf_fopen(const char *name)
2.2265 +{
2.2266 + char *env, fullname[PATH_MAX+1];
2.2267 + FILE *f;
2.2268 +
2.2269 + f = fopen(name, "r");
2.2270 + if (!f && name[0] != '/') {
2.2271 + env = getenv(SRCTREE);
2.2272 + if (env) {
2.2273 + sprintf(fullname, "%s/%s", env, name);
2.2274 + f = fopen(fullname, "r");
2.2275 + }
2.2276 + }
2.2277 + return f;
2.2278 +}
2.2279 +
2.2280 +void zconf_initscan(const char *name)
2.2281 +{
2.2282 + zconfin = zconf_fopen(name);
2.2283 + if (!zconfin) {
2.2284 + printf("can't find file %s\n", name);
2.2285 + exit(1);
2.2286 + }
2.2287 +
2.2288 + current_buf = malloc(sizeof(*current_buf));
2.2289 + memset(current_buf, 0, sizeof(*current_buf));
2.2290 +
2.2291 + current_file = file_lookup(name);
2.2292 + current_file->lineno = 1;
2.2293 + current_file->flags = FILE_BUSY;
2.2294 +}
2.2295 +
2.2296 +void zconf_nextfile(const char *name)
2.2297 +{
2.2298 + struct file *file = file_lookup(name);
2.2299 + struct buffer *buf = malloc(sizeof(*buf));
2.2300 + memset(buf, 0, sizeof(*buf));
2.2301 +
2.2302 + current_buf->state = YY_CURRENT_BUFFER;
2.2303 + zconfin = zconf_fopen(name);
2.2304 + if (!zconfin) {
2.2305 + printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
2.2306 + exit(1);
2.2307 + }
2.2308 + zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
2.2309 + buf->parent = current_buf;
2.2310 + current_buf = buf;
2.2311 +
2.2312 + if (file->flags & FILE_BUSY) {
2.2313 + printf("recursive scan (%s)?\n", name);
2.2314 + exit(1);
2.2315 + }
2.2316 + if (file->flags & FILE_SCANNED) {
2.2317 + printf("file %s already scanned?\n", name);
2.2318 + exit(1);
2.2319 + }
2.2320 + file->flags |= FILE_BUSY;
2.2321 + file->lineno = 1;
2.2322 + file->parent = current_file;
2.2323 + current_file = file;
2.2324 +}
2.2325 +
2.2326 +static void zconf_endfile(void)
2.2327 +{
2.2328 + struct buffer *parent;
2.2329 +
2.2330 + current_file->flags |= FILE_SCANNED;
2.2331 + current_file->flags &= ~FILE_BUSY;
2.2332 + current_file = current_file->parent;
2.2333 +
2.2334 + parent = current_buf->parent;
2.2335 + if (parent) {
2.2336 + fclose(zconfin);
2.2337 + zconf_delete_buffer(YY_CURRENT_BUFFER);
2.2338 + zconf_switch_to_buffer(parent->state);
2.2339 + }
2.2340 + free(current_buf);
2.2341 + current_buf = parent;
2.2342 +}
2.2343 +
2.2344 +int zconf_lineno(void)
2.2345 +{
2.2346 + return current_pos.lineno;
2.2347 +}
2.2348 +
2.2349 +char *zconf_curname(void)
2.2350 +{
2.2351 + return current_pos.file ? current_pos.file->name : "<none>";
2.2352 +}
2.2353 +
3.1 --- a/kconfig/lex.zconf.c_shipped Sun Sep 28 08:14:33 2008 +0000
3.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
3.3 @@ -1,2350 +0,0 @@
3.4 -
3.5 -#line 3 "scripts/kconfig/lex.zconf.c"
3.6 -
3.7 -#define YY_INT_ALIGNED short int
3.8 -
3.9 -/* A lexical scanner generated by flex */
3.10 -
3.11 -#define FLEX_SCANNER
3.12 -#define YY_FLEX_MAJOR_VERSION 2
3.13 -#define YY_FLEX_MINOR_VERSION 5
3.14 -#define YY_FLEX_SUBMINOR_VERSION 33
3.15 -#if YY_FLEX_SUBMINOR_VERSION > 0
3.16 -#define FLEX_BETA
3.17 -#endif
3.18 -
3.19 -/* First, we deal with platform-specific or compiler-specific issues. */
3.20 -
3.21 -/* begin standard C headers. */
3.22 -#include <stdio.h>
3.23 -#include <string.h>
3.24 -#include <errno.h>
3.25 -#include <stdlib.h>
3.26 -
3.27 -/* end standard C headers. */
3.28 -
3.29 -/* flex integer type definitions */
3.30 -
3.31 -#ifndef FLEXINT_H
3.32 -#define FLEXINT_H
3.33 -
3.34 -/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
3.35 -
3.36 -#if __STDC_VERSION__ >= 199901L
3.37 -
3.38 -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
3.39 - * if you want the limit (max/min) macros for int types.
3.40 - */
3.41 -#ifndef __STDC_LIMIT_MACROS
3.42 -#define __STDC_LIMIT_MACROS 1
3.43 -#endif
3.44 -
3.45 -#include <inttypes.h>
3.46 -typedef int8_t flex_int8_t;
3.47 -typedef uint8_t flex_uint8_t;
3.48 -typedef int16_t flex_int16_t;
3.49 -typedef uint16_t flex_uint16_t;
3.50 -typedef int32_t flex_int32_t;
3.51 -typedef uint32_t flex_uint32_t;
3.52 -#else
3.53 -typedef signed char flex_int8_t;
3.54 -typedef short int flex_int16_t;
3.55 -typedef int flex_int32_t;
3.56 -typedef unsigned char flex_uint8_t;
3.57 -typedef unsigned short int flex_uint16_t;
3.58 -typedef unsigned int flex_uint32_t;
3.59 -#endif /* ! C99 */
3.60 -
3.61 -/* Limits of integral types. */
3.62 -#ifndef INT8_MIN
3.63 -#define INT8_MIN (-128)
3.64 -#endif
3.65 -#ifndef INT16_MIN
3.66 -#define INT16_MIN (-32767-1)
3.67 -#endif
3.68 -#ifndef INT32_MIN
3.69 -#define INT32_MIN (-2147483647-1)
3.70 -#endif
3.71 -#ifndef INT8_MAX
3.72 -#define INT8_MAX (127)
3.73 -#endif
3.74 -#ifndef INT16_MAX
3.75 -#define INT16_MAX (32767)
3.76 -#endif
3.77 -#ifndef INT32_MAX
3.78 -#define INT32_MAX (2147483647)
3.79 -#endif
3.80 -#ifndef UINT8_MAX
3.81 -#define UINT8_MAX (255U)
3.82 -#endif
3.83 -#ifndef UINT16_MAX
3.84 -#define UINT16_MAX (65535U)
3.85 -#endif
3.86 -#ifndef UINT32_MAX
3.87 -#define UINT32_MAX (4294967295U)
3.88 -#endif
3.89 -
3.90 -#endif /* ! FLEXINT_H */
3.91 -
3.92 -#ifdef __cplusplus
3.93 -
3.94 -/* The "const" storage-class-modifier is valid. */
3.95 -#define YY_USE_CONST
3.96 -
3.97 -#else /* ! __cplusplus */
3.98 -
3.99 -#if __STDC__
3.100 -
3.101 -#define YY_USE_CONST
3.102 -
3.103 -#endif /* __STDC__ */
3.104 -#endif /* ! __cplusplus */
3.105 -
3.106 -#ifdef YY_USE_CONST
3.107 -#define yyconst const
3.108 -#else
3.109 -#define yyconst
3.110 -#endif
3.111 -
3.112 -/* Returned upon end-of-file. */
3.113 -#define YY_NULL 0
3.114 -
3.115 -/* Promotes a possibly negative, possibly signed char to an unsigned
3.116 - * integer for use as an array index. If the signed char is negative,
3.117 - * we want to instead treat it as an 8-bit unsigned char, hence the
3.118 - * double cast.
3.119 - */
3.120 -#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
3.121 -
3.122 -/* Enter a start condition. This macro really ought to take a parameter,
3.123 - * but we do it the disgusting crufty way forced on us by the ()-less
3.124 - * definition of BEGIN.
3.125 - */
3.126 -#define BEGIN (yy_start) = 1 + 2 *
3.127 -
3.128 -/* Translate the current start state into a value that can be later handed
3.129 - * to BEGIN to return to the state. The YYSTATE alias is for lex
3.130 - * compatibility.
3.131 - */
3.132 -#define YY_START (((yy_start) - 1) / 2)
3.133 -#define YYSTATE YY_START
3.134 -
3.135 -/* Action number for EOF rule of a given start state. */
3.136 -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
3.137 -
3.138 -/* Special action meaning "start processing a new file". */
3.139 -#define YY_NEW_FILE zconfrestart(zconfin )
3.140 -
3.141 -#define YY_END_OF_BUFFER_CHAR 0
3.142 -
3.143 -/* Size of default input buffer. */
3.144 -#ifndef YY_BUF_SIZE
3.145 -#define YY_BUF_SIZE 16384
3.146 -#endif
3.147 -
3.148 -/* The state buf must be large enough to hold one state per character in the main buffer.
3.149 - */
3.150 -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
3.151 -
3.152 -#ifndef YY_TYPEDEF_YY_BUFFER_STATE
3.153 -#define YY_TYPEDEF_YY_BUFFER_STATE
3.154 -typedef struct yy_buffer_state *YY_BUFFER_STATE;
3.155 -#endif
3.156 -
3.157 -extern int zconfleng;
3.158 -
3.159 -extern FILE *zconfin, *zconfout;
3.160 -
3.161 -#define EOB_ACT_CONTINUE_SCAN 0
3.162 -#define EOB_ACT_END_OF_FILE 1
3.163 -#define EOB_ACT_LAST_MATCH 2
3.164 -
3.165 - #define YY_LESS_LINENO(n)
3.166 -
3.167 -/* Return all but the first "n" matched characters back to the input stream. */
3.168 -#define yyless(n) \
3.169 - do \
3.170 - { \
3.171 - /* Undo effects of setting up zconftext. */ \
3.172 - int yyless_macro_arg = (n); \
3.173 - YY_LESS_LINENO(yyless_macro_arg);\
3.174 - *yy_cp = (yy_hold_char); \
3.175 - YY_RESTORE_YY_MORE_OFFSET \
3.176 - (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
3.177 - YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
3.178 - } \
3.179 - while ( 0 )
3.180 -
3.181 -#define unput(c) yyunput( c, (yytext_ptr) )
3.182 -
3.183 -/* The following is because we cannot portably get our hands on size_t
3.184 - * (without autoconf's help, which isn't available because we want
3.185 - * flex-generated scanners to compile on their own).
3.186 - */
3.187 -
3.188 -#ifndef YY_TYPEDEF_YY_SIZE_T
3.189 -#define YY_TYPEDEF_YY_SIZE_T
3.190 -typedef unsigned int yy_size_t;
3.191 -#endif
3.192 -
3.193 -#ifndef YY_STRUCT_YY_BUFFER_STATE
3.194 -#define YY_STRUCT_YY_BUFFER_STATE
3.195 -struct yy_buffer_state
3.196 - {
3.197 - FILE *yy_input_file;
3.198 -
3.199 - char *yy_ch_buf; /* input buffer */
3.200 - char *yy_buf_pos; /* current position in input buffer */
3.201 -
3.202 - /* Size of input buffer in bytes, not including room for EOB
3.203 - * characters.
3.204 - */
3.205 - yy_size_t yy_buf_size;
3.206 -
3.207 - /* Number of characters read into yy_ch_buf, not including EOB
3.208 - * characters.
3.209 - */
3.210 - int yy_n_chars;
3.211 -
3.212 - /* Whether we "own" the buffer - i.e., we know we created it,
3.213 - * and can realloc() it to grow it, and should free() it to
3.214 - * delete it.
3.215 - */
3.216 - int yy_is_our_buffer;
3.217 -
3.218 - /* Whether this is an "interactive" input source; if so, and
3.219 - * if we're using stdio for input, then we want to use getc()
3.220 - * instead of fread(), to make sure we stop fetching input after
3.221 - * each newline.
3.222 - */
3.223 - int yy_is_interactive;
3.224 -
3.225 - /* Whether we're considered to be at the beginning of a line.
3.226 - * If so, '^' rules will be active on the next match, otherwise
3.227 - * not.
3.228 - */
3.229 - int yy_at_bol;
3.230 -
3.231 - int yy_bs_lineno; /**< The line count. */
3.232 - int yy_bs_column; /**< The column count. */
3.233 -
3.234 - /* Whether to try to fill the input buffer when we reach the
3.235 - * end of it.
3.236 - */
3.237 - int yy_fill_buffer;
3.238 -
3.239 - int yy_buffer_status;
3.240 -
3.241 -#define YY_BUFFER_NEW 0
3.242 -#define YY_BUFFER_NORMAL 1
3.243 - /* When an EOF's been seen but there's still some text to process
3.244 - * then we mark the buffer as YY_EOF_PENDING, to indicate that we
3.245 - * shouldn't try reading from the input source any more. We might
3.246 - * still have a bunch of tokens to match, though, because of
3.247 - * possible backing-up.
3.248 - *
3.249 - * When we actually see the EOF, we change the status to "new"
3.250 - * (via zconfrestart()), so that the user can continue scanning by
3.251 - * just pointing zconfin at a new input file.
3.252 - */
3.253 -#define YY_BUFFER_EOF_PENDING 2
3.254 -
3.255 - };
3.256 -#endif /* !YY_STRUCT_YY_BUFFER_STATE */
3.257 -
3.258 -/* Stack of input buffers. */
3.259 -static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
3.260 -static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
3.261 -static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
3.262 -
3.263 -/* We provide macros for accessing buffer states in case in the
3.264 - * future we want to put the buffer states in a more general
3.265 - * "scanner state".
3.266 - *
3.267 - * Returns the top of the stack, or NULL.
3.268 - */
3.269 -#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
3.270 - ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
3.271 - : NULL)
3.272 -
3.273 -/* Same as previous macro, but useful when we know that the buffer stack is not
3.274 - * NULL or when we need an lvalue. For internal use only.
3.275 - */
3.276 -#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
3.277 -
3.278 -/* yy_hold_char holds the character lost when zconftext is formed. */
3.279 -static char yy_hold_char;
3.280 -static int yy_n_chars; /* number of characters read into yy_ch_buf */
3.281 -int zconfleng;
3.282 -
3.283 -/* Points to current character in buffer. */
3.284 -static char *yy_c_buf_p = (char *) 0;
3.285 -static int yy_init = 0; /* whether we need to initialize */
3.286 -static int yy_start = 0; /* start state number */
3.287 -
3.288 -/* Flag which is used to allow zconfwrap()'s to do buffer switches
3.289 - * instead of setting up a fresh zconfin. A bit of a hack ...
3.290 - */
3.291 -static int yy_did_buffer_switch_on_eof;
3.292 -
3.293 -void zconfrestart (FILE *input_file );
3.294 -void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer );
3.295 -YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size );
3.296 -void zconf_delete_buffer (YY_BUFFER_STATE b );
3.297 -void zconf_flush_buffer (YY_BUFFER_STATE b );
3.298 -void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer );
3.299 -void zconfpop_buffer_state (void );
3.300 -
3.301 -static void zconfensure_buffer_stack (void );
3.302 -static void zconf_load_buffer_state (void );
3.303 -static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file );
3.304 -
3.305 -#define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
3.306 -
3.307 -YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size );
3.308 -YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str );
3.309 -YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len );
3.310 -
3.311 -void *zconfalloc (yy_size_t );
3.312 -void *zconfrealloc (void *,yy_size_t );
3.313 -void zconffree (void * );
3.314 -
3.315 -#define yy_new_buffer zconf_create_buffer
3.316 -
3.317 -#define yy_set_interactive(is_interactive) \
3.318 - { \
3.319 - if ( ! YY_CURRENT_BUFFER ){ \
3.320 - zconfensure_buffer_stack (); \
3.321 - YY_CURRENT_BUFFER_LVALUE = \
3.322 - zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
3.323 - } \
3.324 - YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
3.325 - }
3.326 -
3.327 -#define yy_set_bol(at_bol) \
3.328 - { \
3.329 - if ( ! YY_CURRENT_BUFFER ){\
3.330 - zconfensure_buffer_stack (); \
3.331 - YY_CURRENT_BUFFER_LVALUE = \
3.332 - zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
3.333 - } \
3.334 - YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
3.335 - }
3.336 -
3.337 -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
3.338 -
3.339 -/* Begin user sect3 */
3.340 -
3.341 -#define zconfwrap() 1
3.342 -#define YY_SKIP_YYWRAP
3.343 -
3.344 -typedef unsigned char YY_CHAR;
3.345 -
3.346 -FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
3.347 -
3.348 -typedef int yy_state_type;
3.349 -
3.350 -extern int zconflineno;
3.351 -
3.352 -int zconflineno = 1;
3.353 -
3.354 -extern char *zconftext;
3.355 -#define yytext_ptr zconftext
3.356 -static yyconst flex_int16_t yy_nxt[][17] =
3.357 - {
3.358 - {
3.359 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3.360 - 0, 0, 0, 0, 0, 0, 0
3.361 - },
3.362 -
3.363 - {
3.364 - 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
3.365 - 12, 12, 12, 12, 12, 12, 12
3.366 - },
3.367 -
3.368 - {
3.369 - 11, 12, 13, 14, 12, 12, 15, 12, 12, 12,
3.370 - 12, 12, 12, 12, 12, 12, 12
3.371 - },
3.372 -
3.373 - {
3.374 - 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
3.375 - 16, 16, 16, 18, 16, 16, 16
3.376 - },
3.377 -
3.378 - {
3.379 - 11, 16, 16, 17, 16, 16, 16, 16, 16, 16,
3.380 - 16, 16, 16, 18, 16, 16, 16
3.381 -
3.382 - },
3.383 -
3.384 - {
3.385 - 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
3.386 - 19, 19, 19, 19, 19, 19, 19
3.387 - },
3.388 -
3.389 - {
3.390 - 11, 19, 20, 21, 19, 19, 19, 19, 19, 19,
3.391 - 19, 19, 19, 19, 19, 19, 19
3.392 - },
3.393 -
3.394 - {
3.395 - 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
3.396 - 22, 22, 22, 22, 22, 25, 22
3.397 - },
3.398 -
3.399 - {
3.400 - 11, 22, 22, 23, 22, 24, 22, 22, 24, 22,
3.401 - 22, 22, 22, 22, 22, 25, 22
3.402 - },
3.403 -
3.404 - {
3.405 - 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
3.406 - 33, 34, 35, 35, 36, 37, 38
3.407 -
3.408 - },
3.409 -
3.410 - {
3.411 - 11, 26, 26, 27, 28, 29, 30, 31, 29, 32,
3.412 - 33, 34, 35, 35, 36, 37, 38
3.413 - },
3.414 -
3.415 - {
3.416 - -11, -11, -11, -11, -11, -11, -11, -11, -11, -11,
3.417 - -11, -11, -11, -11, -11, -11, -11
3.418 - },
3.419 -
3.420 - {
3.421 - 11, -12, -12, -12, -12, -12, -12, -12, -12, -12,
3.422 - -12, -12, -12, -12, -12, -12, -12
3.423 - },
3.424 -
3.425 - {
3.426 - 11, -13, 39, 40, -13, -13, 41, -13, -13, -13,
3.427 - -13, -13, -13, -13, -13, -13, -13
3.428 - },
3.429 -
3.430 - {
3.431 - 11, -14, -14, -14, -14, -14, -14, -14, -14, -14,
3.432 - -14, -14, -14, -14, -14, -14, -14
3.433 -
3.434 - },
3.435 -
3.436 - {
3.437 - 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
3.438 - 42, 42, 42, 42, 42, 42, 42
3.439 - },
3.440 -
3.441 - {
3.442 - 11, -16, -16, -16, -16, -16, -16, -16, -16, -16,
3.443 - -16, -16, -16, -16, -16, -16, -16
3.444 - },
3.445 -
3.446 - {
3.447 - 11, -17, -17, -17, -17, -17, -17, -17, -17, -17,
3.448 - -17, -17, -17, -17, -17, -17, -17
3.449 - },
3.450 -
3.451 - {
3.452 - 11, -18, -18, -18, -18, -18, -18, -18, -18, -18,
3.453 - -18, -18, -18, 44, -18, -18, -18
3.454 - },
3.455 -
3.456 - {
3.457 - 11, 45, 45, -19, 45, 45, 45, 45, 45, 45,
3.458 - 45, 45, 45, 45, 45, 45, 45
3.459 -
3.460 - },
3.461 -
3.462 - {
3.463 - 11, -20, 46, 47, -20, -20, -20, -20, -20, -20,
3.464 - -20, -20, -20, -20, -20, -20, -20
3.465 - },
3.466 -
3.467 - {
3.468 - 11, 48, -21, -21, 48, 48, 48, 48, 48, 48,
3.469 - 48, 48, 48, 48, 48, 48, 48
3.470 - },
3.471 -
3.472 - {
3.473 - 11, 49, 49, 50, 49, -22, 49, 49, -22, 49,
3.474 - 49, 49, 49, 49, 49, -22, 49
3.475 - },
3.476 -
3.477 - {
3.478 - 11, -23, -23, -23, -23, -23, -23, -23, -23, -23,
3.479 - -23, -23, -23, -23, -23, -23, -23
3.480 - },
3.481 -
3.482 - {
3.483 - 11, -24, -24, -24, -24, -24, -24, -24, -24, -24,
3.484 - -24, -24, -24, -24, -24, -24, -24
3.485 -
3.486 - },
3.487 -
3.488 - {
3.489 - 11, 51, 51, 52, 51, 51, 51, 51, 51, 51,
3.490 - 51, 51, 51, 51, 51, 51, 51
3.491 - },
3.492 -
3.493 - {
3.494 - 11, -26, -26, -26, -26, -26, -26, -26, -26, -26,
3.495 - -26, -26, -26, -26, -26, -26, -26
3.496 - },
3.497 -
3.498 - {
3.499 - 11, -27, -27, -27, -27, -27, -27, -27, -27, -27,
3.500 - -27, -27, -27, -27, -27, -27, -27
3.501 - },
3.502 -
3.503 - {
3.504 - 11, -28, -28, -28, -28, -28, -28, -28, -28, -28,
3.505 - -28, -28, -28, -28, 53, -28, -28
3.506 - },
3.507 -
3.508 - {
3.509 - 11, -29, -29, -29, -29, -29, -29, -29, -29, -29,
3.510 - -29, -29, -29, -29, -29, -29, -29
3.511 -
3.512 - },
3.513 -
3.514 - {
3.515 - 11, 54, 54, -30, 54, 54, 54, 54, 54, 54,
3.516 - 54, 54, 54, 54, 54, 54, 54
3.517 - },
3.518 -
3.519 - {
3.520 - 11, -31, -31, -31, -31, -31, -31, 55, -31, -31,
3.521 - -31, -31, -31, -31, -31, -31, -31
3.522 - },
3.523 -
3.524 - {
3.525 - 11, -32, -32, -32, -32, -32, -32, -32, -32, -32,
3.526 - -32, -32, -32, -32, -32, -32, -32
3.527 - },
3.528 -
3.529 - {
3.530 - 11, -33, -33, -33, -33, -33, -33, -33, -33, -33,
3.531 - -33, -33, -33, -33, -33, -33, -33
3.532 - },
3.533 -
3.534 - {
3.535 - 11, -34, -34, -34, -34, -34, -34, -34, -34, -34,
3.536 - -34, 56, 57, 57, -34, -34, -34
3.537 -
3.538 - },
3.539 -
3.540 - {
3.541 - 11, -35, -35, -35, -35, -35, -35, -35, -35, -35,
3.542 - -35, 57, 57, 57, -35, -35, -35
3.543 - },
3.544 -
3.545 - {
3.546 - 11, -36, -36, -36, -36, -36, -36, -36, -36, -36,
3.547 - -36, -36, -36, -36, -36, -36, -36
3.548 - },
3.549 -
3.550 - {
3.551 - 11, -37, -37, 58, -37, -37, -37, -37, -37, -37,
3.552 - -37, -37, -37, -37, -37, -37, -37
3.553 - },
3.554 -
3.555 - {
3.556 - 11, -38, -38, -38, -38, -38, -38, -38, -38, -38,
3.557 - -38, -38, -38, -38, -38, -38, 59
3.558 - },
3.559 -
3.560 - {
3.561 - 11, -39, 39, 40, -39, -39, 41, -39, -39, -39,
3.562 - -39, -39, -39, -39, -39, -39, -39
3.563 -
3.564 - },
3.565 -
3.566 - {
3.567 - 11, -40, -40, -40, -40, -40, -40, -40, -40, -40,
3.568 - -40, -40, -40, -40, -40, -40, -40
3.569 - },
3.570 -
3.571 - {
3.572 - 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
3.573 - 42, 42, 42, 42, 42, 42, 42
3.574 - },
3.575 -
3.576 - {
3.577 - 11, 42, 42, 43, 42, 42, 42, 42, 42, 42,
3.578 - 42, 42, 42, 42, 42, 42, 42
3.579 - },
3.580 -
3.581 - {
3.582 - 11, -43, -43, -43, -43, -43, -43, -43, -43, -43,
3.583 - -43, -43, -43, -43, -43, -43, -43
3.584 - },
3.585 -
3.586 - {
3.587 - 11, -44, -44, -44, -44, -44, -44, -44, -44, -44,
3.588 - -44, -44, -44, 44, -44, -44, -44
3.589 -
3.590 - },
3.591 -
3.592 - {
3.593 - 11, 45, 45, -45, 45, 45, 45, 45, 45, 45,
3.594 - 45, 45, 45, 45, 45, 45, 45
3.595 - },
3.596 -
3.597 - {
3.598 - 11, -46, 46, 47, -46, -46, -46, -46, -46, -46,
3.599 - -46, -46, -46, -46, -46, -46, -46
3.600 - },
3.601 -
3.602 - {
3.603 - 11, 48, -47, -47, 48, 48, 48, 48, 48, 48,
3.604 - 48, 48, 48, 48, 48, 48, 48
3.605 - },
3.606 -
3.607 - {
3.608 - 11, -48, -48, -48, -48, -48, -48, -48, -48, -48,
3.609 - -48, -48, -48, -48, -48, -48, -48
3.610 - },
3.611 -
3.612 - {
3.613 - 11, 49, 49, 50, 49, -49, 49, 49, -49, 49,
3.614 - 49, 49, 49, 49, 49, -49, 49
3.615 -
3.616 - },
3.617 -
3.618 - {
3.619 - 11, -50, -50, -50, -50, -50, -50, -50, -50, -50,
3.620 - -50, -50, -50, -50, -50, -50, -50
3.621 - },
3.622 -
3.623 - {
3.624 - 11, -51, -51, 52, -51, -51, -51, -51, -51, -51,
3.625 - -51, -51, -51, -51, -51, -51, -51
3.626 - },
3.627 -
3.628 - {
3.629 - 11, -52, -52, -52, -52, -52, -52, -52, -52, -52,
3.630 - -52, -52, -52, -52, -52, -52, -52
3.631 - },
3.632 -
3.633 - {
3.634 - 11, -53, -53, -53, -53, -53, -53, -53, -53, -53,
3.635 - -53, -53, -53, -53, -53, -53, -53
3.636 - },
3.637 -
3.638 - {
3.639 - 11, 54, 54, -54, 54, 54, 54, 54, 54, 54,
3.640 - 54, 54, 54, 54, 54, 54, 54
3.641 -
3.642 - },
3.643 -
3.644 - {
3.645 - 11, -55, -55, -55, -55, -55, -55, -55, -55, -55,
3.646 - -55, -55, -55, -55, -55, -55, -55
3.647 - },
3.648 -
3.649 - {
3.650 - 11, -56, -56, -56, -56, -56, -56, -56, -56, -56,
3.651 - -56, 60, 57, 57, -56, -56, -56
3.652 - },
3.653 -
3.654 - {
3.655 - 11, -57, -57, -57, -57, -57, -57, -57, -57, -57,
3.656 - -57, 57, 57, 57, -57, -57, -57
3.657 - },
3.658 -
3.659 - {
3.660 - 11, -58, -58, -58, -58, -58, -58, -58, -58, -58,
3.661 - -58, -58, -58, -58, -58, -58, -58
3.662 - },
3.663 -
3.664 - {
3.665 - 11, -59, -59, -59, -59, -59, -59, -59, -59, -59,
3.666 - -59, -59, -59, -59, -59, -59, -59
3.667 -
3.668 - },
3.669 -
3.670 - {
3.671 - 11, -60, -60, -60, -60, -60, -60, -60, -60, -60,
3.672 - -60, 57, 57, 57, -60, -60, -60
3.673 - },
3.674 -
3.675 - } ;
3.676 -
3.677 -static yy_state_type yy_get_previous_state (void );
3.678 -static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
3.679 -static int yy_get_next_buffer (void );
3.680 -static void yy_fatal_error (yyconst char msg[] );
3.681 -
3.682 -/* Done after the current pattern has been matched and before the
3.683 - * corresponding action - sets up zconftext.
3.684 - */
3.685 -#define YY_DO_BEFORE_ACTION \
3.686 - (yytext_ptr) = yy_bp; \
3.687 - zconfleng = (size_t) (yy_cp - yy_bp); \
3.688 - (yy_hold_char) = *yy_cp; \
3.689 - *yy_cp = '\0'; \
3.690 - (yy_c_buf_p) = yy_cp;
3.691 -
3.692 -#define YY_NUM_RULES 33
3.693 -#define YY_END_OF_BUFFER 34
3.694 -/* This struct is not used in this scanner,
3.695 - but its presence is necessary. */
3.696 -struct yy_trans_info
3.697 - {
3.698 - flex_int32_t yy_verify;
3.699 - flex_int32_t yy_nxt;
3.700 - };
3.701 -static yyconst flex_int16_t yy_accept[61] =
3.702 - { 0,
3.703 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3.704 - 34, 5, 4, 2, 3, 7, 8, 6, 32, 29,
3.705 - 31, 24, 28, 27, 26, 22, 17, 13, 16, 20,
3.706 - 22, 11, 12, 19, 19, 14, 22, 22, 4, 2,
3.707 - 3, 3, 1, 6, 32, 29, 31, 30, 24, 23,
3.708 - 26, 25, 15, 20, 9, 19, 19, 21, 10, 18
3.709 - } ;
3.710 -
3.711 -static yyconst flex_int32_t yy_ec[256] =
3.712 - { 0,
3.713 - 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
3.714 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.715 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.716 - 1, 2, 4, 5, 6, 1, 1, 7, 8, 9,
3.717 - 10, 1, 1, 1, 11, 12, 12, 13, 13, 13,
3.718 - 13, 13, 13, 13, 13, 13, 13, 1, 1, 1,
3.719 - 14, 1, 1, 1, 13, 13, 13, 13, 13, 13,
3.720 - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
3.721 - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
3.722 - 1, 15, 1, 1, 13, 1, 13, 13, 13, 13,
3.723 -
3.724 - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
3.725 - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
3.726 - 13, 13, 1, 16, 1, 1, 1, 1, 1, 1,
3.727 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.728 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.729 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.730 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.731 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.732 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.733 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.734 -
3.735 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.736 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.737 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.738 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.739 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3.740 - 1, 1, 1, 1, 1
3.741 - } ;
3.742 -
3.743 -extern int zconf_flex_debug;
3.744 -int zconf_flex_debug = 0;
3.745 -
3.746 -/* The intent behind this definition is that it'll catch
3.747 - * any uses of REJECT which flex missed.
3.748 - */
3.749 -#define REJECT reject_used_but_not_detected
3.750 -#define yymore() yymore_used_but_not_detected
3.751 -#define YY_MORE_ADJ 0
3.752 -#define YY_RESTORE_YY_MORE_OFFSET
3.753 -char *zconftext;
3.754 -
3.755 -/*
3.756 - * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3.757 - * Released under the terms of the GNU GPL v2.0.
3.758 - */
3.759 -
3.760 -#include <limits.h>
3.761 -#include <stdio.h>
3.762 -#include <stdlib.h>
3.763 -#include <string.h>
3.764 -#include <unistd.h>
3.765 -
3.766 -#define LKC_DIRECT_LINK
3.767 -#include "lkc.h"
3.768 -
3.769 -#define START_STRSIZE 16
3.770 -
3.771 -static struct {
3.772 - struct file *file;
3.773 - int lineno;
3.774 -} current_pos;
3.775 -
3.776 -static char *text;
3.777 -static int text_size, text_asize;
3.778 -
3.779 -struct buffer {
3.780 - struct buffer *parent;
3.781 - YY_BUFFER_STATE state;
3.782 -};
3.783 -
3.784 -struct buffer *current_buf;
3.785 -
3.786 -static int last_ts, first_ts;
3.787 -
3.788 -static void zconf_endhelp(void);
3.789 -static void zconf_endfile(void);
3.790 -
3.791 -void new_string(void)
3.792 -{
3.793 - text = malloc(START_STRSIZE);
3.794 - text_asize = START_STRSIZE;
3.795 - text_size = 0;
3.796 - *text = 0;
3.797 -}
3.798 -
3.799 -void append_string(const char *str, int size)
3.800 -{
3.801 - int new_size = text_size + size + 1;
3.802 - if (new_size > text_asize) {
3.803 - new_size += START_STRSIZE - 1;
3.804 - new_size &= -START_STRSIZE;
3.805 - text = realloc(text, new_size);
3.806 - text_asize = new_size;
3.807 - }
3.808 - memcpy(text + text_size, str, size);
3.809 - text_size += size;
3.810 - text[text_size] = 0;
3.811 -}
3.812 -
3.813 -void alloc_string(const char *str, int size)
3.814 -{
3.815 - text = malloc(size + 1);
3.816 - memcpy(text, str, size);
3.817 - text[size] = 0;
3.818 -}
3.819 -
3.820 -#define INITIAL 0
3.821 -#define COMMAND 1
3.822 -#define HELP 2
3.823 -#define STRING 3
3.824 -#define PARAM 4
3.825 -
3.826 -#ifndef YY_NO_UNISTD_H
3.827 -/* Special case for "unistd.h", since it is non-ANSI. We include it way
3.828 - * down here because we want the user's section 1 to have been scanned first.
3.829 - * The user has a chance to override it with an option.
3.830 - */
3.831 -#include <unistd.h>
3.832 -#endif
3.833 -
3.834 -#ifndef YY_EXTRA_TYPE
3.835 -#define YY_EXTRA_TYPE void *
3.836 -#endif
3.837 -
3.838 -static int yy_init_globals (void );
3.839 -
3.840 -/* Macros after this point can all be overridden by user definitions in
3.841 - * section 1.
3.842 - */
3.843 -
3.844 -#ifndef YY_SKIP_YYWRAP
3.845 -#ifdef __cplusplus
3.846 -extern "C" int zconfwrap (void );
3.847 -#else
3.848 -extern int zconfwrap (void );
3.849 -#endif
3.850 -#endif
3.851 -
3.852 - static void yyunput (int c,char *buf_ptr );
3.853 -
3.854 -#ifndef yytext_ptr
3.855 -static void yy_flex_strncpy (char *,yyconst char *,int );
3.856 -#endif
3.857 -
3.858 -#ifdef YY_NEED_STRLEN
3.859 -static int yy_flex_strlen (yyconst char * );
3.860 -#endif
3.861 -
3.862 -#ifndef YY_NO_INPUT
3.863 -
3.864 -#ifdef __cplusplus
3.865 -static int yyinput (void );
3.866 -#else
3.867 -static int input (void );
3.868 -#endif
3.869 -
3.870 -#endif
3.871 -
3.872 -/* Amount of stuff to slurp up with each read. */
3.873 -#ifndef YY_READ_BUF_SIZE
3.874 -#define YY_READ_BUF_SIZE 8192
3.875 -#endif
3.876 -
3.877 -/* Copy whatever the last rule matched to the standard output. */
3.878 -#ifndef ECHO
3.879 -/* This used to be an fputs(), but since the string might contain NUL's,
3.880 - * we now use fwrite().
3.881 - */
3.882 -#define ECHO (void) fwrite( zconftext, zconfleng, 1, zconfout )
3.883 -#endif
3.884 -
3.885 -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
3.886 - * is returned in "result".
3.887 - */
3.888 -#ifndef YY_INPUT
3.889 -#define YY_INPUT(buf,result,max_size) \
3.890 - errno=0; \
3.891 - while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
3.892 - { \
3.893 - if( errno != EINTR) \
3.894 - { \
3.895 - YY_FATAL_ERROR( "input in flex scanner failed" ); \
3.896 - break; \
3.897 - } \
3.898 - errno=0; \
3.899 - clearerr(zconfin); \
3.900 - }\
3.901 -\
3.902 -
3.903 -#endif
3.904 -
3.905 -/* No semi-colon after return; correct usage is to write "yyterminate();" -
3.906 - * we don't want an extra ';' after the "return" because that will cause
3.907 - * some compilers to complain about unreachable statements.
3.908 - */
3.909 -#ifndef yyterminate
3.910 -#define yyterminate() return YY_NULL
3.911 -#endif
3.912 -
3.913 -/* Number of entries by which start-condition stack grows. */
3.914 -#ifndef YY_START_STACK_INCR
3.915 -#define YY_START_STACK_INCR 25
3.916 -#endif
3.917 -
3.918 -/* Report a fatal error. */
3.919 -#ifndef YY_FATAL_ERROR
3.920 -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
3.921 -#endif
3.922 -
3.923 -/* end tables serialization structures and prototypes */
3.924 -
3.925 -/* Default declaration of generated scanner - a define so the user can
3.926 - * easily add parameters.
3.927 - */
3.928 -#ifndef YY_DECL
3.929 -#define YY_DECL_IS_OURS 1
3.930 -
3.931 -extern int zconflex (void);
3.932 -
3.933 -#define YY_DECL int zconflex (void)
3.934 -#endif /* !YY_DECL */
3.935 -
3.936 -/* Code executed at the beginning of each rule, after zconftext and zconfleng
3.937 - * have been set up.
3.938 - */
3.939 -#ifndef YY_USER_ACTION
3.940 -#define YY_USER_ACTION
3.941 -#endif
3.942 -
3.943 -/* Code executed at the end of each rule. */
3.944 -#ifndef YY_BREAK
3.945 -#define YY_BREAK break;
3.946 -#endif
3.947 -
3.948 -#define YY_RULE_SETUP \
3.949 - YY_USER_ACTION
3.950 -
3.951 -/** The main scanner function which does all the work.
3.952 - */
3.953 -YY_DECL
3.954 -{
3.955 - register yy_state_type yy_current_state;
3.956 - register char *yy_cp, *yy_bp;
3.957 - register int yy_act;
3.958 -
3.959 - int str = 0;
3.960 - int ts, i;
3.961 -
3.962 - if ( !(yy_init) )
3.963 - {
3.964 - (yy_init) = 1;
3.965 -
3.966 -#ifdef YY_USER_INIT
3.967 - YY_USER_INIT;
3.968 -#endif
3.969 -
3.970 - if ( ! (yy_start) )
3.971 - (yy_start) = 1; /* first start state */
3.972 -
3.973 - if ( ! zconfin )
3.974 - zconfin = stdin;
3.975 -
3.976 - if ( ! zconfout )
3.977 - zconfout = stdout;
3.978 -
3.979 - if ( ! YY_CURRENT_BUFFER ) {
3.980 - zconfensure_buffer_stack ();
3.981 - YY_CURRENT_BUFFER_LVALUE =
3.982 - zconf_create_buffer(zconfin,YY_BUF_SIZE );
3.983 - }
3.984 -
3.985 - zconf_load_buffer_state( );
3.986 - }
3.987 -
3.988 - while ( 1 ) /* loops until end-of-file is reached */
3.989 - {
3.990 - yy_cp = (yy_c_buf_p);
3.991 -
3.992 - /* Support of zconftext. */
3.993 - *yy_cp = (yy_hold_char);
3.994 -
3.995 - /* yy_bp points to the position in yy_ch_buf of the start of
3.996 - * the current run.
3.997 - */
3.998 - yy_bp = yy_cp;
3.999 -
3.1000 - yy_current_state = (yy_start);
3.1001 -yy_match:
3.1002 - while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)] ]) > 0 )
3.1003 - ++yy_cp;
3.1004 -
3.1005 - yy_current_state = -yy_current_state;
3.1006 -
3.1007 -yy_find_action:
3.1008 - yy_act = yy_accept[yy_current_state];
3.1009 -
3.1010 - YY_DO_BEFORE_ACTION;
3.1011 -
3.1012 -do_action: /* This label is used only to access EOF actions. */
3.1013 -
3.1014 - switch ( yy_act )
3.1015 - { /* beginning of action switch */
3.1016 -case 1:
3.1017 -/* rule 1 can match eol */
3.1018 -case 2:
3.1019 -/* rule 2 can match eol */
3.1020 -YY_RULE_SETUP
3.1021 -{
3.1022 - current_file->lineno++;
3.1023 - return T_EOL;
3.1024 -}
3.1025 - YY_BREAK
3.1026 -case 3:
3.1027 -YY_RULE_SETUP
3.1028 -
3.1029 - YY_BREAK
3.1030 -case 4:
3.1031 -YY_RULE_SETUP
3.1032 -{
3.1033 - BEGIN(COMMAND);
3.1034 -}
3.1035 - YY_BREAK
3.1036 -case 5:
3.1037 -YY_RULE_SETUP
3.1038 -{
3.1039 - unput(zconftext[0]);
3.1040 - BEGIN(COMMAND);
3.1041 -}
3.1042 - YY_BREAK
3.1043 -
3.1044 -case 6:
3.1045 -YY_RULE_SETUP
3.1046 -{
3.1047 - struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
3.1048 - BEGIN(PARAM);
3.1049 - current_pos.file = current_file;
3.1050 - current_pos.lineno = current_file->lineno;
3.1051 - if (id && id->flags & TF_COMMAND) {
3.1052 - zconflval.id = id;
3.1053 - return id->token;
3.1054 - }
3.1055 - alloc_string(zconftext, zconfleng);
3.1056 - zconflval.string = text;
3.1057 - return T_WORD;
3.1058 - }
3.1059 - YY_BREAK
3.1060 -case 7:
3.1061 -YY_RULE_SETUP
3.1062 -
3.1063 - YY_BREAK
3.1064 -case 8:
3.1065 -/* rule 8 can match eol */
3.1066 -YY_RULE_SETUP
3.1067 -{
3.1068 - BEGIN(INITIAL);
3.1069 - current_file->lineno++;
3.1070 - return T_EOL;
3.1071 - }
3.1072 - YY_BREAK
3.1073 -
3.1074 -case 9:
3.1075 -YY_RULE_SETUP
3.1076 -return T_AND;
3.1077 - YY_BREAK
3.1078 -case 10:
3.1079 -YY_RULE_SETUP
3.1080 -return T_OR;
3.1081 - YY_BREAK
3.1082 -case 11:
3.1083 -YY_RULE_SETUP
3.1084 -return T_OPEN_PAREN;
3.1085 - YY_BREAK
3.1086 -case 12:
3.1087 -YY_RULE_SETUP
3.1088 -return T_CLOSE_PAREN;
3.1089 - YY_BREAK
3.1090 -case 13:
3.1091 -YY_RULE_SETUP
3.1092 -return T_NOT;
3.1093 - YY_BREAK
3.1094 -case 14:
3.1095 -YY_RULE_SETUP
3.1096 -return T_EQUAL;
3.1097 - YY_BREAK
3.1098 -case 15:
3.1099 -YY_RULE_SETUP
3.1100 -return T_UNEQUAL;
3.1101 - YY_BREAK
3.1102 -case 16:
3.1103 -YY_RULE_SETUP
3.1104 -{
3.1105 - str = zconftext[0];
3.1106 - new_string();
3.1107 - BEGIN(STRING);
3.1108 - }
3.1109 - YY_BREAK
3.1110 -case 17:
3.1111 -/* rule 17 can match eol */
3.1112 -YY_RULE_SETUP
3.1113 -BEGIN(INITIAL); current_file->lineno++; return T_EOL;
3.1114 - YY_BREAK
3.1115 -case 18:
3.1116 -YY_RULE_SETUP
3.1117 -/* ignore */
3.1118 - YY_BREAK
3.1119 -case 19:
3.1120 -YY_RULE_SETUP
3.1121 -{
3.1122 - struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
3.1123 - if (id && id->flags & TF_PARAM) {
3.1124 - zconflval.id = id;
3.1125 - return id->token;
3.1126 - }
3.1127 - alloc_string(zconftext, zconfleng);
3.1128 - zconflval.string = text;
3.1129 - return T_WORD;
3.1130 - }
3.1131 - YY_BREAK
3.1132 -case 20:
3.1133 -YY_RULE_SETUP
3.1134 -/* comment */
3.1135 - YY_BREAK
3.1136 -case 21:
3.1137 -/* rule 21 can match eol */
3.1138 -YY_RULE_SETUP
3.1139 -current_file->lineno++;
3.1140 - YY_BREAK
3.1141 -case 22:
3.1142 -YY_RULE_SETUP
3.1143 -
3.1144 - YY_BREAK
3.1145 -case YY_STATE_EOF(PARAM):
3.1146 -{
3.1147 - BEGIN(INITIAL);
3.1148 - }
3.1149 - YY_BREAK
3.1150 -
3.1151 -case 23:
3.1152 -/* rule 23 can match eol */
3.1153 -*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
3.1154 -(yy_c_buf_p) = yy_cp -= 1;
3.1155 -YY_DO_BEFORE_ACTION; /* set up zconftext again */
3.1156 -YY_RULE_SETUP
3.1157 -{
3.1158 - append_string(zconftext, zconfleng);
3.1159 - zconflval.string = text;
3.1160 - return T_WORD_QUOTE;
3.1161 - }
3.1162 - YY_BREAK
3.1163 -case 24:
3.1164 -YY_RULE_SETUP
3.1165 -{
3.1166 - append_string(zconftext, zconfleng);
3.1167 - }
3.1168 - YY_BREAK
3.1169 -case 25:
3.1170 -/* rule 25 can match eol */
3.1171 -*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
3.1172 -(yy_c_buf_p) = yy_cp -= 1;
3.1173 -YY_DO_BEFORE_ACTION; /* set up zconftext again */
3.1174 -YY_RULE_SETUP
3.1175 -{
3.1176 - append_string(zconftext + 1, zconfleng - 1);
3.1177 - zconflval.string = text;
3.1178 - return T_WORD_QUOTE;
3.1179 - }
3.1180 - YY_BREAK
3.1181 -case 26:
3.1182 -YY_RULE_SETUP
3.1183 -{
3.1184 - append_string(zconftext + 1, zconfleng - 1);
3.1185 - }
3.1186 - YY_BREAK
3.1187 -case 27:
3.1188 -YY_RULE_SETUP
3.1189 -{
3.1190 - if (str == zconftext[0]) {
3.1191 - BEGIN(PARAM);
3.1192 - zconflval.string = text;
3.1193 - return T_WORD_QUOTE;
3.1194 - } else
3.1195 - append_string(zconftext, 1);
3.1196 - }
3.1197 - YY_BREAK
3.1198 -case 28:
3.1199 -/* rule 28 can match eol */
3.1200 -YY_RULE_SETUP
3.1201 -{
3.1202 - printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
3.1203 - current_file->lineno++;
3.1204 - BEGIN(INITIAL);
3.1205 - return T_EOL;
3.1206 - }
3.1207 - YY_BREAK
3.1208 -case YY_STATE_EOF(STRING):
3.1209 -{
3.1210 - BEGIN(INITIAL);
3.1211 - }
3.1212 - YY_BREAK
3.1213 -
3.1214 -case 29:
3.1215 -YY_RULE_SETUP
3.1216 -{
3.1217 - ts = 0;
3.1218 - for (i = 0; i < zconfleng; i++) {
3.1219 - if (zconftext[i] == '\t')
3.1220 - ts = (ts & ~7) + 8;
3.1221 - else
3.1222 - ts++;
3.1223 - }
3.1224 - last_ts = ts;
3.1225 - if (first_ts) {
3.1226 - if (ts < first_ts) {
3.1227 - zconf_endhelp();
3.1228 - return T_HELPTEXT;
3.1229 - }
3.1230 - ts -= first_ts;
3.1231 - while (ts > 8) {
3.1232 - append_string(" ", 8);
3.1233 - ts -= 8;
3.1234 - }
3.1235 - append_string(" ", ts);
3.1236 - }
3.1237 - }
3.1238 - YY_BREAK
3.1239 -case 30:
3.1240 -/* rule 30 can match eol */
3.1241 -*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
3.1242 -(yy_c_buf_p) = yy_cp -= 1;
3.1243 -YY_DO_BEFORE_ACTION; /* set up zconftext again */
3.1244 -YY_RULE_SETUP
3.1245 -{
3.1246 - current_file->lineno++;
3.1247 - zconf_endhelp();
3.1248 - return T_HELPTEXT;
3.1249 - }
3.1250 - YY_BREAK
3.1251 -case 31:
3.1252 -/* rule 31 can match eol */
3.1253 -YY_RULE_SETUP
3.1254 -{
3.1255 - current_file->lineno++;
3.1256 - append_string("\n", 1);
3.1257 - }
3.1258 - YY_BREAK
3.1259 -case 32:
3.1260 -YY_RULE_SETUP
3.1261 -{
3.1262 - append_string(zconftext, zconfleng);
3.1263 - if (!first_ts)
3.1264 - first_ts = last_ts;
3.1265 - }
3.1266 - YY_BREAK
3.1267 -case YY_STATE_EOF(HELP):
3.1268 -{
3.1269 - zconf_endhelp();
3.1270 - return T_HELPTEXT;
3.1271 - }
3.1272 - YY_BREAK
3.1273 -
3.1274 -case YY_STATE_EOF(INITIAL):
3.1275 -case YY_STATE_EOF(COMMAND):
3.1276 -{
3.1277 - if (current_file) {
3.1278 - zconf_endfile();
3.1279 - return T_EOL;
3.1280 - }
3.1281 - fclose(zconfin);
3.1282 - yyterminate();
3.1283 -}
3.1284 - YY_BREAK
3.1285 -case 33:
3.1286 -YY_RULE_SETUP
3.1287 -YY_FATAL_ERROR( "flex scanner jammed" );
3.1288 - YY_BREAK
3.1289 -
3.1290 - case YY_END_OF_BUFFER:
3.1291 - {
3.1292 - /* Amount of text matched not including the EOB char. */
3.1293 - int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
3.1294 -
3.1295 - /* Undo the effects of YY_DO_BEFORE_ACTION. */
3.1296 - *yy_cp = (yy_hold_char);
3.1297 - YY_RESTORE_YY_MORE_OFFSET
3.1298 -
3.1299 - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
3.1300 - {
3.1301 - /* We're scanning a new file or input source. It's
3.1302 - * possible that this happened because the user
3.1303 - * just pointed zconfin at a new source and called
3.1304 - * zconflex(). If so, then we have to assure
3.1305 - * consistency between YY_CURRENT_BUFFER and our
3.1306 - * globals. Here is the right place to do so, because
3.1307 - * this is the first action (other than possibly a
3.1308 - * back-up) that will match for the new input source.
3.1309 - */
3.1310 - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3.1311 - YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
3.1312 - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
3.1313 - }
3.1314 -
3.1315 - /* Note that here we test for yy_c_buf_p "<=" to the position
3.1316 - * of the first EOB in the buffer, since yy_c_buf_p will
3.1317 - * already have been incremented past the NUL character
3.1318 - * (since all states make transitions on EOB to the
3.1319 - * end-of-buffer state). Contrast this with the test
3.1320 - * in input().
3.1321 - */
3.1322 - if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3.1323 - { /* This was really a NUL. */
3.1324 - yy_state_type yy_next_state;
3.1325 -
3.1326 - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
3.1327 -
3.1328 - yy_current_state = yy_get_previous_state( );
3.1329 -
3.1330 - /* Okay, we're now positioned to make the NUL
3.1331 - * transition. We couldn't have
3.1332 - * yy_get_previous_state() go ahead and do it
3.1333 - * for us because it doesn't know how to deal
3.1334 - * with the possibility of jamming (and we don't
3.1335 - * want to build jamming into it because then it
3.1336 - * will run more slowly).
3.1337 - */
3.1338 -
3.1339 - yy_next_state = yy_try_NUL_trans( yy_current_state );
3.1340 -
3.1341 - yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3.1342 -
3.1343 - if ( yy_next_state )
3.1344 - {
3.1345 - /* Consume the NUL. */
3.1346 - yy_cp = ++(yy_c_buf_p);
3.1347 - yy_current_state = yy_next_state;
3.1348 - goto yy_match;
3.1349 - }
3.1350 -
3.1351 - else
3.1352 - {
3.1353 - yy_cp = (yy_c_buf_p);
3.1354 - goto yy_find_action;
3.1355 - }
3.1356 - }
3.1357 -
3.1358 - else switch ( yy_get_next_buffer( ) )
3.1359 - {
3.1360 - case EOB_ACT_END_OF_FILE:
3.1361 - {
3.1362 - (yy_did_buffer_switch_on_eof) = 0;
3.1363 -
3.1364 - if ( zconfwrap( ) )
3.1365 - {
3.1366 - /* Note: because we've taken care in
3.1367 - * yy_get_next_buffer() to have set up
3.1368 - * zconftext, we can now set up
3.1369 - * yy_c_buf_p so that if some total
3.1370 - * hoser (like flex itself) wants to
3.1371 - * call the scanner after we return the
3.1372 - * YY_NULL, it'll still work - another
3.1373 - * YY_NULL will get returned.
3.1374 - */
3.1375 - (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
3.1376 -
3.1377 - yy_act = YY_STATE_EOF(YY_START);
3.1378 - goto do_action;
3.1379 - }
3.1380 -
3.1381 - else
3.1382 - {
3.1383 - if ( ! (yy_did_buffer_switch_on_eof) )
3.1384 - YY_NEW_FILE;
3.1385 - }
3.1386 - break;
3.1387 - }
3.1388 -
3.1389 - case EOB_ACT_CONTINUE_SCAN:
3.1390 - (yy_c_buf_p) =
3.1391 - (yytext_ptr) + yy_amount_of_matched_text;
3.1392 -
3.1393 - yy_current_state = yy_get_previous_state( );
3.1394 -
3.1395 - yy_cp = (yy_c_buf_p);
3.1396 - yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3.1397 - goto yy_match;
3.1398 -
3.1399 - case EOB_ACT_LAST_MATCH:
3.1400 - (yy_c_buf_p) =
3.1401 - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
3.1402 -
3.1403 - yy_current_state = yy_get_previous_state( );
3.1404 -
3.1405 - yy_cp = (yy_c_buf_p);
3.1406 - yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3.1407 - goto yy_find_action;
3.1408 - }
3.1409 - break;
3.1410 - }
3.1411 -
3.1412 - default:
3.1413 - YY_FATAL_ERROR(
3.1414 - "fatal flex scanner internal error--no action found" );
3.1415 - } /* end of action switch */
3.1416 - } /* end of scanning one token */
3.1417 -} /* end of zconflex */
3.1418 -
3.1419 -/* yy_get_next_buffer - try to read in a new buffer
3.1420 - *
3.1421 - * Returns a code representing an action:
3.1422 - * EOB_ACT_LAST_MATCH -
3.1423 - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
3.1424 - * EOB_ACT_END_OF_FILE - end of file
3.1425 - */
3.1426 -static int yy_get_next_buffer (void)
3.1427 -{
3.1428 - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
3.1429 - register char *source = (yytext_ptr);
3.1430 - register int number_to_move, i;
3.1431 - int ret_val;
3.1432 -
3.1433 - if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
3.1434 - YY_FATAL_ERROR(
3.1435 - "fatal flex scanner internal error--end of buffer missed" );
3.1436 -
3.1437 - if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
3.1438 - { /* Don't try to fill the buffer, so this is an EOF. */
3.1439 - if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
3.1440 - {
3.1441 - /* We matched a single character, the EOB, so
3.1442 - * treat this as a final EOF.
3.1443 - */
3.1444 - return EOB_ACT_END_OF_FILE;
3.1445 - }
3.1446 -
3.1447 - else
3.1448 - {
3.1449 - /* We matched some text prior to the EOB, first
3.1450 - * process it.
3.1451 - */
3.1452 - return EOB_ACT_LAST_MATCH;
3.1453 - }
3.1454 - }
3.1455 -
3.1456 - /* Try to read more data. */
3.1457 -
3.1458 - /* First move last chars to start of buffer. */
3.1459 - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
3.1460 -
3.1461 - for ( i = 0; i < number_to_move; ++i )
3.1462 - *(dest++) = *(source++);
3.1463 -
3.1464 - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
3.1465 - /* don't do the read, it's not guaranteed to return an EOF,
3.1466 - * just force an EOF
3.1467 - */
3.1468 - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
3.1469 -
3.1470 - else
3.1471 - {
3.1472 - int num_to_read =
3.1473 - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
3.1474 -
3.1475 - while ( num_to_read <= 0 )
3.1476 - { /* Not enough room in the buffer - grow it. */
3.1477 -
3.1478 - /* just a shorter name for the current buffer */
3.1479 - YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
3.1480 -
3.1481 - int yy_c_buf_p_offset =
3.1482 - (int) ((yy_c_buf_p) - b->yy_ch_buf);
3.1483 -
3.1484 - if ( b->yy_is_our_buffer )
3.1485 - {
3.1486 - int new_size = b->yy_buf_size * 2;
3.1487 -
3.1488 - if ( new_size <= 0 )
3.1489 - b->yy_buf_size += b->yy_buf_size / 8;
3.1490 - else
3.1491 - b->yy_buf_size *= 2;
3.1492 -
3.1493 - b->yy_ch_buf = (char *)
3.1494 - /* Include room in for 2 EOB chars. */
3.1495 - zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
3.1496 - }
3.1497 - else
3.1498 - /* Can't grow it, we don't own it. */
3.1499 - b->yy_ch_buf = 0;
3.1500 -
3.1501 - if ( ! b->yy_ch_buf )
3.1502 - YY_FATAL_ERROR(
3.1503 - "fatal error - scanner input buffer overflow" );
3.1504 -
3.1505 - (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
3.1506 -
3.1507 - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
3.1508 - number_to_move - 1;
3.1509 -
3.1510 - }
3.1511 -
3.1512 - if ( num_to_read > YY_READ_BUF_SIZE )
3.1513 - num_to_read = YY_READ_BUF_SIZE;
3.1514 -
3.1515 - /* Read in more data. */
3.1516 - YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
3.1517 - (yy_n_chars), num_to_read );
3.1518 -
3.1519 - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3.1520 - }
3.1521 -
3.1522 - if ( (yy_n_chars) == 0 )
3.1523 - {
3.1524 - if ( number_to_move == YY_MORE_ADJ )
3.1525 - {
3.1526 - ret_val = EOB_ACT_END_OF_FILE;
3.1527 - zconfrestart(zconfin );
3.1528 - }
3.1529 -
3.1530 - else
3.1531 - {
3.1532 - ret_val = EOB_ACT_LAST_MATCH;
3.1533 - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3.1534 - YY_BUFFER_EOF_PENDING;
3.1535 - }
3.1536 - }
3.1537 -
3.1538 - else
3.1539 - ret_val = EOB_ACT_CONTINUE_SCAN;
3.1540 -
3.1541 - (yy_n_chars) += number_to_move;
3.1542 - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
3.1543 - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
3.1544 -
3.1545 - (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3.1546 -
3.1547 - return ret_val;
3.1548 -}
3.1549 -
3.1550 -/* yy_get_previous_state - get the state just before the EOB char was reached */
3.1551 -
3.1552 - static yy_state_type yy_get_previous_state (void)
3.1553 -{
3.1554 - register yy_state_type yy_current_state;
3.1555 - register char *yy_cp;
3.1556 -
3.1557 - yy_current_state = (yy_start);
3.1558 -
3.1559 - for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3.1560 - {
3.1561 - yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
3.1562 - }
3.1563 -
3.1564 - return yy_current_state;
3.1565 -}
3.1566 -
3.1567 -/* yy_try_NUL_trans - try to make a transition on the NUL character
3.1568 - *
3.1569 - * synopsis
3.1570 - * next_state = yy_try_NUL_trans( current_state );
3.1571 - */
3.1572 - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
3.1573 -{
3.1574 - register int yy_is_jam;
3.1575 -
3.1576 - yy_current_state = yy_nxt[yy_current_state][1];
3.1577 - yy_is_jam = (yy_current_state <= 0);
3.1578 -
3.1579 - return yy_is_jam ? 0 : yy_current_state;
3.1580 -}
3.1581 -
3.1582 - static void yyunput (int c, register char * yy_bp )
3.1583 -{
3.1584 - register char *yy_cp;
3.1585 -
3.1586 - yy_cp = (yy_c_buf_p);
3.1587 -
3.1588 - /* undo effects of setting up zconftext */
3.1589 - *yy_cp = (yy_hold_char);
3.1590 -
3.1591 - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
3.1592 - { /* need to shift things up to make room */
3.1593 - /* +2 for EOB chars. */
3.1594 - register int number_to_move = (yy_n_chars) + 2;
3.1595 - register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
3.1596 - YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
3.1597 - register char *source =
3.1598 - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
3.1599 -
3.1600 - while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3.1601 - *--dest = *--source;
3.1602 -
3.1603 - yy_cp += (int) (dest - source);
3.1604 - yy_bp += (int) (dest - source);
3.1605 - YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
3.1606 - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
3.1607 -
3.1608 - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
3.1609 - YY_FATAL_ERROR( "flex scanner push-back overflow" );
3.1610 - }
3.1611 -
3.1612 - *--yy_cp = (char) c;
3.1613 -
3.1614 - (yytext_ptr) = yy_bp;
3.1615 - (yy_hold_char) = *yy_cp;
3.1616 - (yy_c_buf_p) = yy_cp;
3.1617 -}
3.1618 -
3.1619 -#ifndef YY_NO_INPUT
3.1620 -#ifdef __cplusplus
3.1621 - static int yyinput (void)
3.1622 -#else
3.1623 - static int input (void)
3.1624 -#endif
3.1625 -
3.1626 -{
3.1627 - int c;
3.1628 -
3.1629 - *(yy_c_buf_p) = (yy_hold_char);
3.1630 -
3.1631 - if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
3.1632 - {
3.1633 - /* yy_c_buf_p now points to the character we want to return.
3.1634 - * If this occurs *before* the EOB characters, then it's a
3.1635 - * valid NUL; if not, then we've hit the end of the buffer.
3.1636 - */
3.1637 - if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3.1638 - /* This was really a NUL. */
3.1639 - *(yy_c_buf_p) = '\0';
3.1640 -
3.1641 - else
3.1642 - { /* need more input */
3.1643 - int offset = (yy_c_buf_p) - (yytext_ptr);
3.1644 - ++(yy_c_buf_p);
3.1645 -
3.1646 - switch ( yy_get_next_buffer( ) )
3.1647 - {
3.1648 - case EOB_ACT_LAST_MATCH:
3.1649 - /* This happens because yy_g_n_b()
3.1650 - * sees that we've accumulated a
3.1651 - * token and flags that we need to
3.1652 - * try matching the token before
3.1653 - * proceeding. But for input(),
3.1654 - * there's no matching to consider.
3.1655 - * So convert the EOB_ACT_LAST_MATCH
3.1656 - * to EOB_ACT_END_OF_FILE.
3.1657 - */
3.1658 -
3.1659 - /* Reset buffer status. */
3.1660 - zconfrestart(zconfin );
3.1661 -
3.1662 - /*FALLTHROUGH*/
3.1663 -
3.1664 - case EOB_ACT_END_OF_FILE:
3.1665 - {
3.1666 - if ( zconfwrap( ) )
3.1667 - return EOF;
3.1668 -
3.1669 - if ( ! (yy_did_buffer_switch_on_eof) )
3.1670 - YY_NEW_FILE;
3.1671 -#ifdef __cplusplus
3.1672 - return yyinput();
3.1673 -#else
3.1674 - return input();
3.1675 -#endif
3.1676 - }
3.1677 -
3.1678 - case EOB_ACT_CONTINUE_SCAN:
3.1679 - (yy_c_buf_p) = (yytext_ptr) + offset;
3.1680 - break;
3.1681 - }
3.1682 - }
3.1683 - }
3.1684 -
3.1685 - c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
3.1686 - *(yy_c_buf_p) = '\0'; /* preserve zconftext */
3.1687 - (yy_hold_char) = *++(yy_c_buf_p);
3.1688 -
3.1689 - return c;
3.1690 -}
3.1691 -#endif /* ifndef YY_NO_INPUT */
3.1692 -
3.1693 -/** Immediately switch to a different input stream.
3.1694 - * @param input_file A readable stream.
3.1695 - *
3.1696 - * @note This function does not reset the start condition to @c INITIAL .
3.1697 - */
3.1698 - void zconfrestart (FILE * input_file )
3.1699 -{
3.1700 -
3.1701 - if ( ! YY_CURRENT_BUFFER ){
3.1702 - zconfensure_buffer_stack ();
3.1703 - YY_CURRENT_BUFFER_LVALUE =
3.1704 - zconf_create_buffer(zconfin,YY_BUF_SIZE );
3.1705 - }
3.1706 -
3.1707 - zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
3.1708 - zconf_load_buffer_state( );
3.1709 -}
3.1710 -
3.1711 -/** Switch to a different input buffer.
3.1712 - * @param new_buffer The new input buffer.
3.1713 - *
3.1714 - */
3.1715 - void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer )
3.1716 -{
3.1717 -
3.1718 - /* TODO. We should be able to replace this entire function body
3.1719 - * with
3.1720 - * zconfpop_buffer_state();
3.1721 - * zconfpush_buffer_state(new_buffer);
3.1722 - */
3.1723 - zconfensure_buffer_stack ();
3.1724 - if ( YY_CURRENT_BUFFER == new_buffer )
3.1725 - return;
3.1726 -
3.1727 - if ( YY_CURRENT_BUFFER )
3.1728 - {
3.1729 - /* Flush out information for old buffer. */
3.1730 - *(yy_c_buf_p) = (yy_hold_char);
3.1731 - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3.1732 - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3.1733 - }
3.1734 -
3.1735 - YY_CURRENT_BUFFER_LVALUE = new_buffer;
3.1736 - zconf_load_buffer_state( );
3.1737 -
3.1738 - /* We don't actually know whether we did this switch during
3.1739 - * EOF (zconfwrap()) processing, but the only time this flag
3.1740 - * is looked at is after zconfwrap() is called, so it's safe
3.1741 - * to go ahead and always set it.
3.1742 - */
3.1743 - (yy_did_buffer_switch_on_eof) = 1;
3.1744 -}
3.1745 -
3.1746 -static void zconf_load_buffer_state (void)
3.1747 -{
3.1748 - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3.1749 - (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
3.1750 - zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
3.1751 - (yy_hold_char) = *(yy_c_buf_p);
3.1752 -}
3.1753 -
3.1754 -/** Allocate and initialize an input buffer state.
3.1755 - * @param file A readable stream.
3.1756 - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
3.1757 - *
3.1758 - * @return the allocated buffer state.
3.1759 - */
3.1760 - YY_BUFFER_STATE zconf_create_buffer (FILE * file, int size )
3.1761 -{
3.1762 - YY_BUFFER_STATE b;
3.1763 -
3.1764 - b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
3.1765 - if ( ! b )
3.1766 - YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
3.1767 -
3.1768 - b->yy_buf_size = size;
3.1769 -
3.1770 - /* yy_ch_buf has to be 2 characters longer than the size given because
3.1771 - * we need to put in 2 end-of-buffer characters.
3.1772 - */
3.1773 - b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2 );
3.1774 - if ( ! b->yy_ch_buf )
3.1775 - YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
3.1776 -
3.1777 - b->yy_is_our_buffer = 1;
3.1778 -
3.1779 - zconf_init_buffer(b,file );
3.1780 -
3.1781 - return b;
3.1782 -}
3.1783 -
3.1784 -/** Destroy the buffer.
3.1785 - * @param b a buffer created with zconf_create_buffer()
3.1786 - *
3.1787 - */
3.1788 - void zconf_delete_buffer (YY_BUFFER_STATE b )
3.1789 -{
3.1790 -
3.1791 - if ( ! b )
3.1792 - return;
3.1793 -
3.1794 - if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3.1795 - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3.1796 -
3.1797 - if ( b->yy_is_our_buffer )
3.1798 - zconffree((void *) b->yy_ch_buf );
3.1799 -
3.1800 - zconffree((void *) b );
3.1801 -}
3.1802 -
3.1803 -/* Initializes or reinitializes a buffer.
3.1804 - * This function is sometimes called more than once on the same buffer,
3.1805 - * such as during a zconfrestart() or at EOF.
3.1806 - */
3.1807 - static void zconf_init_buffer (YY_BUFFER_STATE b, FILE * file )
3.1808 -
3.1809 -{
3.1810 - int oerrno = errno;
3.1811 -
3.1812 - zconf_flush_buffer(b );
3.1813 -
3.1814 - b->yy_input_file = file;
3.1815 - b->yy_fill_buffer = 1;
3.1816 -
3.1817 - /* If b is the current buffer, then zconf_init_buffer was _probably_
3.1818 - * called from zconfrestart() or through yy_get_next_buffer.
3.1819 - * In that case, we don't want to reset the lineno or column.
3.1820 - */
3.1821 - if (b != YY_CURRENT_BUFFER){
3.1822 - b->yy_bs_lineno = 1;
3.1823 - b->yy_bs_column = 0;
3.1824 - }
3.1825 -
3.1826 - b->yy_is_interactive = 0;
3.1827 -
3.1828 - errno = oerrno;
3.1829 -}
3.1830 -
3.1831 -/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
3.1832 - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
3.1833 - *
3.1834 - */
3.1835 - void zconf_flush_buffer (YY_BUFFER_STATE b )
3.1836 -{
3.1837 - if ( ! b )
3.1838 - return;
3.1839 -
3.1840 - b->yy_n_chars = 0;
3.1841 -
3.1842 - /* We always need two end-of-buffer characters. The first causes
3.1843 - * a transition to the end-of-buffer state. The second causes
3.1844 - * a jam in that state.
3.1845 - */
3.1846 - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3.1847 - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3.1848 -
3.1849 - b->yy_buf_pos = &b->yy_ch_buf[0];
3.1850 -
3.1851 - b->yy_at_bol = 1;
3.1852 - b->yy_buffer_status = YY_BUFFER_NEW;
3.1853 -
3.1854 - if ( b == YY_CURRENT_BUFFER )
3.1855 - zconf_load_buffer_state( );
3.1856 -}
3.1857 -
3.1858 -/** Pushes the new state onto the stack. The new state becomes
3.1859 - * the current state. This function will allocate the stack
3.1860 - * if necessary.
3.1861 - * @param new_buffer The new state.
3.1862 - *
3.1863 - */
3.1864 -void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
3.1865 -{
3.1866 - if (new_buffer == NULL)
3.1867 - return;
3.1868 -
3.1869 - zconfensure_buffer_stack();
3.1870 -
3.1871 - /* This block is copied from zconf_switch_to_buffer. */
3.1872 - if ( YY_CURRENT_BUFFER )
3.1873 - {
3.1874 - /* Flush out information for old buffer. */
3.1875 - *(yy_c_buf_p) = (yy_hold_char);
3.1876 - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3.1877 - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3.1878 - }
3.1879 -
3.1880 - /* Only push if top exists. Otherwise, replace top. */
3.1881 - if (YY_CURRENT_BUFFER)
3.1882 - (yy_buffer_stack_top)++;
3.1883 - YY_CURRENT_BUFFER_LVALUE = new_buffer;
3.1884 -
3.1885 - /* copied from zconf_switch_to_buffer. */
3.1886 - zconf_load_buffer_state( );
3.1887 - (yy_did_buffer_switch_on_eof) = 1;
3.1888 -}
3.1889 -
3.1890 -/** Removes and deletes the top of the stack, if present.
3.1891 - * The next element becomes the new top.
3.1892 - *
3.1893 - */
3.1894 -void zconfpop_buffer_state (void)
3.1895 -{
3.1896 - if (!YY_CURRENT_BUFFER)
3.1897 - return;
3.1898 -
3.1899 - zconf_delete_buffer(YY_CURRENT_BUFFER );
3.1900 - YY_CURRENT_BUFFER_LVALUE = NULL;
3.1901 - if ((yy_buffer_stack_top) > 0)
3.1902 - --(yy_buffer_stack_top);
3.1903 -
3.1904 - if (YY_CURRENT_BUFFER) {
3.1905 - zconf_load_buffer_state( );
3.1906 - (yy_did_buffer_switch_on_eof) = 1;
3.1907 - }
3.1908 -}
3.1909 -
3.1910 -/* Allocates the stack if it does not exist.
3.1911 - * Guarantees space for at least one push.
3.1912 - */
3.1913 -static void zconfensure_buffer_stack (void)
3.1914 -{
3.1915 - int num_to_alloc;
3.1916 -
3.1917 - if (!(yy_buffer_stack)) {
3.1918 -
3.1919 - /* First allocation is just for 2 elements, since we don't know if this
3.1920 - * scanner will even need a stack. We use 2 instead of 1 to avoid an
3.1921 - * immediate realloc on the next call.
3.1922 - */
3.1923 - num_to_alloc = 1;
3.1924 - (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
3.1925 - (num_to_alloc * sizeof(struct yy_buffer_state*)
3.1926 - );
3.1927 -
3.1928 - memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3.1929 -
3.1930 - (yy_buffer_stack_max) = num_to_alloc;
3.1931 - (yy_buffer_stack_top) = 0;
3.1932 - return;
3.1933 - }
3.1934 -
3.1935 - if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3.1936 -
3.1937 - /* Increase the buffer to prepare for a possible push. */
3.1938 - int grow_size = 8 /* arbitrary grow size */;
3.1939 -
3.1940 - num_to_alloc = (yy_buffer_stack_max) + grow_size;
3.1941 - (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
3.1942 - ((yy_buffer_stack),
3.1943 - num_to_alloc * sizeof(struct yy_buffer_state*)
3.1944 - );
3.1945 -
3.1946 - /* zero only the new slots.*/
3.1947 - memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3.1948 - (yy_buffer_stack_max) = num_to_alloc;
3.1949 - }
3.1950 -}
3.1951 -
3.1952 -/** Setup the input buffer state to scan directly from a user-specified character buffer.
3.1953 - * @param base the character buffer
3.1954 - * @param size the size in bytes of the character buffer
3.1955 - *
3.1956 - * @return the newly allocated buffer state object.
3.1957 - */
3.1958 -YY_BUFFER_STATE zconf_scan_buffer (char * base, yy_size_t size )
3.1959 -{
3.1960 - YY_BUFFER_STATE b;
3.1961 -
3.1962 - if ( size < 2 ||
3.1963 - base[size-2] != YY_END_OF_BUFFER_CHAR ||
3.1964 - base[size-1] != YY_END_OF_BUFFER_CHAR )
3.1965 - /* They forgot to leave room for the EOB's. */
3.1966 - return 0;
3.1967 -
3.1968 - b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
3.1969 - if ( ! b )
3.1970 - YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
3.1971 -
3.1972 - b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3.1973 - b->yy_buf_pos = b->yy_ch_buf = base;
3.1974 - b->yy_is_our_buffer = 0;
3.1975 - b->yy_input_file = 0;
3.1976 - b->yy_n_chars = b->yy_buf_size;
3.1977 - b->yy_is_interactive = 0;
3.1978 - b->yy_at_bol = 1;
3.1979 - b->yy_fill_buffer = 0;
3.1980 - b->yy_buffer_status = YY_BUFFER_NEW;
3.1981 -
3.1982 - zconf_switch_to_buffer(b );
3.1983 -
3.1984 - return b;
3.1985 -}
3.1986 -
3.1987 -/** Setup the input buffer state to scan a string. The next call to zconflex() will
3.1988 - * scan from a @e copy of @a str.
3.1989 - * @param yystr a NUL-terminated string to scan
3.1990 - *
3.1991 - * @return the newly allocated buffer state object.
3.1992 - * @note If you want to scan bytes that may contain NUL values, then use
3.1993 - * zconf_scan_bytes() instead.
3.1994 - */
3.1995 -YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
3.1996 -{
3.1997 -
3.1998 - return zconf_scan_bytes(yystr,strlen(yystr) );
3.1999 -}
3.2000 -
3.2001 -/** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
3.2002 - * scan from a @e copy of @a bytes.
3.2003 - * @param bytes the byte buffer to scan
3.2004 - * @param len the number of bytes in the buffer pointed to by @a bytes.
3.2005 - *
3.2006 - * @return the newly allocated buffer state object.
3.2007 - */
3.2008 -YY_BUFFER_STATE zconf_scan_bytes (yyconst char * yybytes, int _yybytes_len )
3.2009 -{
3.2010 - YY_BUFFER_STATE b;
3.2011 - char *buf;
3.2012 - yy_size_t n;
3.2013 - int i;
3.2014 -
3.2015 - /* Get memory for full buffer, including space for trailing EOB's. */
3.2016 - n = _yybytes_len + 2;
3.2017 - buf = (char *) zconfalloc(n );
3.2018 - if ( ! buf )
3.2019 - YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
3.2020 -
3.2021 - for ( i = 0; i < _yybytes_len; ++i )
3.2022 - buf[i] = yybytes[i];
3.2023 -
3.2024 - buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3.2025 -
3.2026 - b = zconf_scan_buffer(buf,n );
3.2027 - if ( ! b )
3.2028 - YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
3.2029 -
3.2030 - /* It's okay to grow etc. this buffer, and we should throw it
3.2031 - * away when we're done.
3.2032 - */
3.2033 - b->yy_is_our_buffer = 1;
3.2034 -
3.2035 - return b;
3.2036 -}
3.2037 -
3.2038 -#ifndef YY_EXIT_FAILURE
3.2039 -#define YY_EXIT_FAILURE 2
3.2040 -#endif
3.2041 -
3.2042 -static void yy_fatal_error (yyconst char* msg )
3.2043 -{
3.2044 - (void) fprintf( stderr, "%s\n", msg );
3.2045 - exit( YY_EXIT_FAILURE );
3.2046 -}
3.2047 -
3.2048 -/* Redefine yyless() so it works in section 3 code. */
3.2049 -
3.2050 -#undef yyless
3.2051 -#define yyless(n) \
3.2052 - do \
3.2053 - { \
3.2054 - /* Undo effects of setting up zconftext. */ \
3.2055 - int yyless_macro_arg = (n); \
3.2056 - YY_LESS_LINENO(yyless_macro_arg);\
3.2057 - zconftext[zconfleng] = (yy_hold_char); \
3.2058 - (yy_c_buf_p) = zconftext + yyless_macro_arg; \
3.2059 - (yy_hold_char) = *(yy_c_buf_p); \
3.2060 - *(yy_c_buf_p) = '\0'; \
3.2061 - zconfleng = yyless_macro_arg; \
3.2062 - } \
3.2063 - while ( 0 )
3.2064 -
3.2065 -/* Accessor methods (get/set functions) to struct members. */
3.2066 -
3.2067 -/** Get the current line number.
3.2068 - *
3.2069 - */
3.2070 -int zconfget_lineno (void)
3.2071 -{
3.2072 -
3.2073 - return zconflineno;
3.2074 -}
3.2075 -
3.2076 -/** Get the input stream.
3.2077 - *
3.2078 - */
3.2079 -FILE *zconfget_in (void)
3.2080 -{
3.2081 - return zconfin;
3.2082 -}
3.2083 -
3.2084 -/** Get the output stream.
3.2085 - *
3.2086 - */
3.2087 -FILE *zconfget_out (void)
3.2088 -{
3.2089 - return zconfout;
3.2090 -}
3.2091 -
3.2092 -/** Get the length of the current token.
3.2093 - *
3.2094 - */
3.2095 -int zconfget_leng (void)
3.2096 -{
3.2097 - return zconfleng;
3.2098 -}
3.2099 -
3.2100 -/** Get the current token.
3.2101 - *
3.2102 - */
3.2103 -
3.2104 -char *zconfget_text (void)
3.2105 -{
3.2106 - return zconftext;
3.2107 -}
3.2108 -
3.2109 -/** Set the current line number.
3.2110 - * @param line_number
3.2111 - *
3.2112 - */
3.2113 -void zconfset_lineno (int line_number )
3.2114 -{
3.2115 -
3.2116 - zconflineno = line_number;
3.2117 -}
3.2118 -
3.2119 -/** Set the input stream. This does not discard the current
3.2120 - * input buffer.
3.2121 - * @param in_str A readable stream.
3.2122 - *
3.2123 - * @see zconf_switch_to_buffer
3.2124 - */
3.2125 -void zconfset_in (FILE * in_str )
3.2126 -{
3.2127 - zconfin = in_str ;
3.2128 -}
3.2129 -
3.2130 -void zconfset_out (FILE * out_str )
3.2131 -{
3.2132 - zconfout = out_str ;
3.2133 -}
3.2134 -
3.2135 -int zconfget_debug (void)
3.2136 -{
3.2137 - return zconf_flex_debug;
3.2138 -}
3.2139 -
3.2140 -void zconfset_debug (int bdebug )
3.2141 -{
3.2142 - zconf_flex_debug = bdebug ;
3.2143 -}
3.2144 -
3.2145 -static int yy_init_globals (void)
3.2146 -{
3.2147 - /* Initialization is the same as for the non-reentrant scanner.
3.2148 - * This function is called from zconflex_destroy(), so don't allocate here.
3.2149 - */
3.2150 -
3.2151 - (yy_buffer_stack) = 0;
3.2152 - (yy_buffer_stack_top) = 0;
3.2153 - (yy_buffer_stack_max) = 0;
3.2154 - (yy_c_buf_p) = (char *) 0;
3.2155 - (yy_init) = 0;
3.2156 - (yy_start) = 0;
3.2157 -
3.2158 -/* Defined in main.c */
3.2159 -#ifdef YY_STDINIT
3.2160 - zconfin = stdin;
3.2161 - zconfout = stdout;
3.2162 -#else
3.2163 - zconfin = (FILE *) 0;
3.2164 - zconfout = (FILE *) 0;
3.2165 -#endif
3.2166 -
3.2167 - /* For future reference: Set errno on error, since we are called by
3.2168 - * zconflex_init()
3.2169 - */
3.2170 - return 0;
3.2171 -}
3.2172 -
3.2173 -/* zconflex_destroy is for both reentrant and non-reentrant scanners. */
3.2174 -int zconflex_destroy (void)
3.2175 -{
3.2176 -
3.2177 - /* Pop the buffer stack, destroying each element. */
3.2178 - while(YY_CURRENT_BUFFER){
3.2179 - zconf_delete_buffer(YY_CURRENT_BUFFER );
3.2180 - YY_CURRENT_BUFFER_LVALUE = NULL;
3.2181 - zconfpop_buffer_state();
3.2182 - }
3.2183 -
3.2184 - /* Destroy the stack itself. */
3.2185 - zconffree((yy_buffer_stack) );
3.2186 - (yy_buffer_stack) = NULL;
3.2187 -
3.2188 - /* Reset the globals. This is important in a non-reentrant scanner so the next time
3.2189 - * zconflex() is called, initialization will occur. */
3.2190 - yy_init_globals( );
3.2191 -
3.2192 - return 0;
3.2193 -}
3.2194 -
3.2195 -/*
3.2196 - * Internal utility routines.
3.2197 - */
3.2198 -
3.2199 -#ifndef yytext_ptr
3.2200 -static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
3.2201 -{
3.2202 - register int i;
3.2203 - for ( i = 0; i < n; ++i )
3.2204 - s1[i] = s2[i];
3.2205 -}
3.2206 -#endif
3.2207 -
3.2208 -#ifdef YY_NEED_STRLEN
3.2209 -static int yy_flex_strlen (yyconst char * s )
3.2210 -{
3.2211 - register int n;
3.2212 - for ( n = 0; s[n]; ++n )
3.2213 - ;
3.2214 -
3.2215 - return n;
3.2216 -}
3.2217 -#endif
3.2218 -
3.2219 -void *zconfalloc (yy_size_t size )
3.2220 -{
3.2221 - return (void *) malloc( size );
3.2222 -}
3.2223 -
3.2224 -void *zconfrealloc (void * ptr, yy_size_t size )
3.2225 -{
3.2226 - /* The cast to (char *) in the following accommodates both
3.2227 - * implementations that use char* generic pointers, and those
3.2228 - * that use void* generic pointers. It works with the latter
3.2229 - * because both ANSI C and C++ allow castless assignment from
3.2230 - * any pointer type to void*, and deal with argument conversions
3.2231 - * as though doing an assignment.
3.2232 - */
3.2233 - return (void *) realloc( (char *) ptr, size );
3.2234 -}
3.2235 -
3.2236 -void zconffree (void * ptr )
3.2237 -{
3.2238 - free( (char *) ptr ); /* see zconfrealloc() for (char *) cast */
3.2239 -}
3.2240 -
3.2241 -#define YYTABLES_NAME "yytables"
3.2242 -
3.2243 -void zconf_starthelp(void)
3.2244 -{
3.2245 - new_string();
3.2246 - last_ts = first_ts = 0;
3.2247 - BEGIN(HELP);
3.2248 -}
3.2249 -
3.2250 -static void zconf_endhelp(void)
3.2251 -{
3.2252 - zconflval.string = text;
3.2253 - BEGIN(INITIAL);
3.2254 -}
3.2255 -
3.2256 -/*
3.2257 - * Try to open specified file with following names:
3.2258 - * ./name
3.2259 - * $(srctree)/name
3.2260 - * The latter is used when srctree is separate from objtree
3.2261 - * when compiling the kernel.
3.2262 - * Return NULL if file is not found.
3.2263 - */
3.2264 -FILE *zconf_fopen(const char *name)
3.2265 -{
3.2266 - char *env, fullname[PATH_MAX+1];
3.2267 - FILE *f;
3.2268 -
3.2269 - f = fopen(name, "r");
3.2270 - if (!f && name[0] != '/') {
3.2271 - env = getenv(SRCTREE);
3.2272 - if (env) {
3.2273 - sprintf(fullname, "%s/%s", env, name);
3.2274 - f = fopen(fullname, "r");
3.2275 - }
3.2276 - }
3.2277 - return f;
3.2278 -}
3.2279 -
3.2280 -void zconf_initscan(const char *name)
3.2281 -{
3.2282 - zconfin = zconf_fopen(name);
3.2283 - if (!zconfin) {
3.2284 - printf("can't find file %s\n", name);
3.2285 - exit(1);
3.2286 - }
3.2287 -
3.2288 - current_buf = malloc(sizeof(*current_buf));
3.2289 - memset(current_buf, 0, sizeof(*current_buf));
3.2290 -
3.2291 - current_file = file_lookup(name);
3.2292 - current_file->lineno = 1;
3.2293 - current_file->flags = FILE_BUSY;
3.2294 -}
3.2295 -
3.2296 -void zconf_nextfile(const char *name)
3.2297 -{
3.2298 - struct file *file = file_lookup(name);
3.2299 - struct buffer *buf = malloc(sizeof(*buf));
3.2300 - memset(buf, 0, sizeof(*buf));
3.2301 -
3.2302 - current_buf->state = YY_CURRENT_BUFFER;
3.2303 - zconfin = zconf_fopen(name);
3.2304 - if (!zconfin) {
3.2305 - printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
3.2306 - exit(1);
3.2307 - }
3.2308 - zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
3.2309 - buf->parent = current_buf;
3.2310 - current_buf = buf;
3.2311 -
3.2312 - if (file->flags & FILE_BUSY) {
3.2313 - printf("recursive scan (%s)?\n", name);
3.2314 - exit(1);
3.2315 - }
3.2316 - if (file->flags & FILE_SCANNED) {
3.2317 - printf("file %s already scanned?\n", name);
3.2318 - exit(1);
3.2319 - }
3.2320 - file->flags |= FILE_BUSY;
3.2321 - file->lineno = 1;
3.2322 - file->parent = current_file;
3.2323 - current_file = file;
3.2324 -}
3.2325 -
3.2326 -static void zconf_endfile(void)
3.2327 -{
3.2328 - struct buffer *parent;
3.2329 -
3.2330 - current_file->flags |= FILE_SCANNED;
3.2331 - current_file->flags &= ~FILE_BUSY;
3.2332 - current_file = current_file->parent;
3.2333 -
3.2334 - parent = current_buf->parent;
3.2335 - if (parent) {
3.2336 - fclose(zconfin);
3.2337 - zconf_delete_buffer(YY_CURRENT_BUFFER);
3.2338 - zconf_switch_to_buffer(parent->state);
3.2339 - }
3.2340 - free(current_buf);
3.2341 - current_buf = parent;
3.2342 -}
3.2343 -
3.2344 -int zconf_lineno(void)
3.2345 -{
3.2346 - return current_pos.lineno;
3.2347 -}
3.2348 -
3.2349 -char *zconf_curname(void)
3.2350 -{
3.2351 - return current_pos.file ? current_pos.file->name : "<none>";
3.2352 -}
3.2353 -
4.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
4.2 +++ b/kconfig/zconf.hash.c Sun Sep 28 10:33:30 2008 +0000
4.3 @@ -0,0 +1,242 @@
4.4 +/* ANSI-C code produced by gperf version 3.0.1 */
4.5 +/* Command-line: gperf */
4.6 +/* Computed positions: -k'1,3' */
4.7 +
4.8 +#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
4.9 + && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
4.10 + && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
4.11 + && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
4.12 + && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
4.13 + && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
4.14 + && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
4.15 + && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
4.16 + && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
4.17 + && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
4.18 + && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
4.19 + && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
4.20 + && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
4.21 + && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
4.22 + && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
4.23 + && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
4.24 + && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
4.25 + && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
4.26 + && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
4.27 + && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
4.28 + && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
4.29 + && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
4.30 + && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
4.31 +/* The character set is not based on ISO-646. */
4.32 +#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
4.33 +#endif
4.34 +
4.35 +struct kconf_id;
4.36 +/* maximum key range = 45, duplicates = 0 */
4.37 +
4.38 +#ifdef __GNUC__
4.39 +__inline
4.40 +#else
4.41 +#ifdef __cplusplus
4.42 +inline
4.43 +#endif
4.44 +#endif
4.45 +static unsigned int
4.46 +kconf_id_hash (register const char *str, register unsigned int len)
4.47 +{
4.48 + static unsigned char asso_values[] =
4.49 + {
4.50 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.51 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.52 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.53 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.54 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.55 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.56 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.57 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.58 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.59 + 47, 47, 47, 47, 47, 47, 47, 25, 30, 15,
4.60 + 0, 15, 0, 47, 5, 15, 47, 47, 30, 20,
4.61 + 5, 0, 25, 15, 0, 0, 10, 35, 47, 47,
4.62 + 5, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.63 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.64 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.65 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.66 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.67 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.68 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.69 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.70 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.71 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.72 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.73 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.74 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
4.75 + 47, 47, 47, 47, 47, 47
4.76 + };
4.77 + register int hval = len;
4.78 +
4.79 + switch (hval)
4.80 + {
4.81 + default:
4.82 + hval += asso_values[(unsigned char)str[2]];
4.83 + /*FALLTHROUGH*/
4.84 + case 2:
4.85 + case 1:
4.86 + hval += asso_values[(unsigned char)str[0]];
4.87 + break;
4.88 + }
4.89 + return hval;
4.90 +}
4.91 +
4.92 +struct kconf_id_strings_t
4.93 + {
4.94 + char kconf_id_strings_str2[sizeof("on")];
4.95 + char kconf_id_strings_str6[sizeof("string")];
4.96 + char kconf_id_strings_str7[sizeof("default")];
4.97 + char kconf_id_strings_str8[sizeof("def_bool")];
4.98 + char kconf_id_strings_str10[sizeof("range")];
4.99 + char kconf_id_strings_str11[sizeof("def_boolean")];
4.100 + char kconf_id_strings_str12[sizeof("def_tristate")];
4.101 + char kconf_id_strings_str13[sizeof("hex")];
4.102 + char kconf_id_strings_str14[sizeof("defconfig_list")];
4.103 + char kconf_id_strings_str16[sizeof("option")];
4.104 + char kconf_id_strings_str17[sizeof("if")];
4.105 + char kconf_id_strings_str18[sizeof("optional")];
4.106 + char kconf_id_strings_str20[sizeof("endif")];
4.107 + char kconf_id_strings_str21[sizeof("choice")];
4.108 + char kconf_id_strings_str22[sizeof("endmenu")];
4.109 + char kconf_id_strings_str23[sizeof("requires")];
4.110 + char kconf_id_strings_str24[sizeof("endchoice")];
4.111 + char kconf_id_strings_str26[sizeof("config")];
4.112 + char kconf_id_strings_str27[sizeof("modules")];
4.113 + char kconf_id_strings_str28[sizeof("int")];
4.114 + char kconf_id_strings_str29[sizeof("menu")];
4.115 + char kconf_id_strings_str31[sizeof("prompt")];
4.116 + char kconf_id_strings_str32[sizeof("depends")];
4.117 + char kconf_id_strings_str33[sizeof("tristate")];
4.118 + char kconf_id_strings_str34[sizeof("bool")];
4.119 + char kconf_id_strings_str35[sizeof("menuconfig")];
4.120 + char kconf_id_strings_str36[sizeof("select")];
4.121 + char kconf_id_strings_str37[sizeof("boolean")];
4.122 + char kconf_id_strings_str39[sizeof("help")];
4.123 + char kconf_id_strings_str41[sizeof("source")];
4.124 + char kconf_id_strings_str42[sizeof("comment")];
4.125 + char kconf_id_strings_str43[sizeof("mainmenu")];
4.126 + char kconf_id_strings_str46[sizeof("enable")];
4.127 + };
4.128 +static struct kconf_id_strings_t kconf_id_strings_contents =
4.129 + {
4.130 + "on",
4.131 + "string",
4.132 + "default",
4.133 + "def_bool",
4.134 + "range",
4.135 + "def_boolean",
4.136 + "def_tristate",
4.137 + "hex",
4.138 + "defconfig_list",
4.139 + "option",
4.140 + "if",
4.141 + "optional",
4.142 + "endif",
4.143 + "choice",
4.144 + "endmenu",
4.145 + "requires",
4.146 + "endchoice",
4.147 + "config",
4.148 + "modules",
4.149 + "int",
4.150 + "menu",
4.151 + "prompt",
4.152 + "depends",
4.153 + "tristate",
4.154 + "bool",
4.155 + "menuconfig",
4.156 + "select",
4.157 + "boolean",
4.158 + "help",
4.159 + "source",
4.160 + "comment",
4.161 + "mainmenu",
4.162 + "enable"
4.163 + };
4.164 +#define kconf_id_strings ((const char *) &kconf_id_strings_contents)
4.165 +#ifdef __GNUC__
4.166 +__inline
4.167 +#endif
4.168 +struct kconf_id *
4.169 +kconf_id_lookup (register const char *str, register unsigned int len)
4.170 +{
4.171 + enum
4.172 + {
4.173 + TOTAL_KEYWORDS = 33,
4.174 + MIN_WORD_LENGTH = 2,
4.175 + MAX_WORD_LENGTH = 14,
4.176 + MIN_HASH_VALUE = 2,
4.177 + MAX_HASH_VALUE = 46
4.178 + };
4.179 +
4.180 + static struct kconf_id wordlist[] =
4.181 + {
4.182 + {-1}, {-1},
4.183 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str2, T_ON, TF_PARAM},
4.184 + {-1}, {-1}, {-1},
4.185 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str6, T_TYPE, TF_COMMAND, S_STRING},
4.186 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str7, T_DEFAULT, TF_COMMAND, S_UNKNOWN},
4.187 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str8, T_DEFAULT, TF_COMMAND, S_BOOLEAN},
4.188 + {-1},
4.189 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str10, T_RANGE, TF_COMMAND},
4.190 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str11, T_DEFAULT, TF_COMMAND, S_BOOLEAN},
4.191 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str12, T_DEFAULT, TF_COMMAND, S_TRISTATE},
4.192 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str13, T_TYPE, TF_COMMAND, S_HEX},
4.193 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str14, T_OPT_DEFCONFIG_LIST,TF_OPTION},
4.194 + {-1},
4.195 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str16, T_OPTION, TF_COMMAND},
4.196 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str17, T_IF, TF_COMMAND|TF_PARAM},
4.197 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str18, T_OPTIONAL, TF_COMMAND},
4.198 + {-1},
4.199 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str20, T_ENDIF, TF_COMMAND},
4.200 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str21, T_CHOICE, TF_COMMAND},
4.201 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str22, T_ENDMENU, TF_COMMAND},
4.202 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str23, T_REQUIRES, TF_COMMAND},
4.203 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str24, T_ENDCHOICE, TF_COMMAND},
4.204 + {-1},
4.205 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str26, T_CONFIG, TF_COMMAND},
4.206 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str27, T_OPT_MODULES, TF_OPTION},
4.207 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str28, T_TYPE, TF_COMMAND, S_INT},
4.208 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str29, T_MENU, TF_COMMAND},
4.209 + {-1},
4.210 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str31, T_PROMPT, TF_COMMAND},
4.211 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str32, T_DEPENDS, TF_COMMAND},
4.212 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str33, T_TYPE, TF_COMMAND, S_TRISTATE},
4.213 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str34, T_TYPE, TF_COMMAND, S_BOOLEAN},
4.214 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str35, T_MENUCONFIG, TF_COMMAND},
4.215 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str36, T_SELECT, TF_COMMAND},
4.216 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str37, T_TYPE, TF_COMMAND, S_BOOLEAN},
4.217 + {-1},
4.218 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str39, T_HELP, TF_COMMAND},
4.219 + {-1},
4.220 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str41, T_SOURCE, TF_COMMAND},
4.221 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str42, T_COMMENT, TF_COMMAND},
4.222 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str43, T_MAINMENU, TF_COMMAND},
4.223 + {-1}, {-1},
4.224 + {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str46, T_SELECT, TF_COMMAND}
4.225 + };
4.226 +
4.227 + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
4.228 + {
4.229 + register int key = kconf_id_hash (str, len);
4.230 +
4.231 + if (key <= MAX_HASH_VALUE && key >= 0)
4.232 + {
4.233 + register int o = wordlist[key].name;
4.234 + if (o >= 0)
4.235 + {
4.236 + register const char *s = o + kconf_id_strings;
4.237 +
4.238 + if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
4.239 + return &wordlist[key];
4.240 + }
4.241 + }
4.242 + }
4.243 + return 0;
4.244 +}
4.245 +
5.1 --- a/kconfig/zconf.hash.c_shipped Sun Sep 28 08:14:33 2008 +0000
5.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
5.3 @@ -1,242 +0,0 @@
5.4 -/* ANSI-C code produced by gperf version 3.0.1 */
5.5 -/* Command-line: gperf */
5.6 -/* Computed positions: -k'1,3' */
5.7 -
5.8 -#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
5.9 - && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
5.10 - && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
5.11 - && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
5.12 - && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
5.13 - && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
5.14 - && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
5.15 - && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
5.16 - && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
5.17 - && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
5.18 - && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
5.19 - && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
5.20 - && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
5.21 - && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
5.22 - && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
5.23 - && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
5.24 - && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
5.25 - && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
5.26 - && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
5.27 - && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
5.28 - && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
5.29 - && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
5.30 - && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
5.31 -/* The character set is not based on ISO-646. */
5.32 -#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
5.33 -#endif
5.34 -
5.35 -struct kconf_id;
5.36 -/* maximum key range = 45, duplicates = 0 */
5.37 -
5.38 -#ifdef __GNUC__
5.39 -__inline
5.40 -#else
5.41 -#ifdef __cplusplus
5.42 -inline
5.43 -#endif
5.44 -#endif
5.45 -static unsigned int
5.46 -kconf_id_hash (register const char *str, register unsigned int len)
5.47 -{
5.48 - static unsigned char asso_values[] =
5.49 - {
5.50 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.51 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.52 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.53 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.54 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.55 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.56 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.57 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.58 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.59 - 47, 47, 47, 47, 47, 47, 47, 25, 30, 15,
5.60 - 0, 15, 0, 47, 5, 15, 47, 47, 30, 20,
5.61 - 5, 0, 25, 15, 0, 0, 10, 35, 47, 47,
5.62 - 5, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.63 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.64 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.65 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.66 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.67 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.68 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.69 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.70 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.71 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.72 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.73 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.74 - 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
5.75 - 47, 47, 47, 47, 47, 47
5.76 - };
5.77 - register int hval = len;
5.78 -
5.79 - switch (hval)
5.80 - {
5.81 - default:
5.82 - hval += asso_values[(unsigned char)str[2]];
5.83 - /*FALLTHROUGH*/
5.84 - case 2:
5.85 - case 1:
5.86 - hval += asso_values[(unsigned char)str[0]];
5.87 - break;
5.88 - }
5.89 - return hval;
5.90 -}
5.91 -
5.92 -struct kconf_id_strings_t
5.93 - {
5.94 - char kconf_id_strings_str2[sizeof("on")];
5.95 - char kconf_id_strings_str6[sizeof("string")];
5.96 - char kconf_id_strings_str7[sizeof("default")];
5.97 - char kconf_id_strings_str8[sizeof("def_bool")];
5.98 - char kconf_id_strings_str10[sizeof("range")];
5.99 - char kconf_id_strings_str11[sizeof("def_boolean")];
5.100 - char kconf_id_strings_str12[sizeof("def_tristate")];
5.101 - char kconf_id_strings_str13[sizeof("hex")];
5.102 - char kconf_id_strings_str14[sizeof("defconfig_list")];
5.103 - char kconf_id_strings_str16[sizeof("option")];
5.104 - char kconf_id_strings_str17[sizeof("if")];
5.105 - char kconf_id_strings_str18[sizeof("optional")];
5.106 - char kconf_id_strings_str20[sizeof("endif")];
5.107 - char kconf_id_strings_str21[sizeof("choice")];
5.108 - char kconf_id_strings_str22[sizeof("endmenu")];
5.109 - char kconf_id_strings_str23[sizeof("requires")];
5.110 - char kconf_id_strings_str24[sizeof("endchoice")];
5.111 - char kconf_id_strings_str26[sizeof("config")];
5.112 - char kconf_id_strings_str27[sizeof("modules")];
5.113 - char kconf_id_strings_str28[sizeof("int")];
5.114 - char kconf_id_strings_str29[sizeof("menu")];
5.115 - char kconf_id_strings_str31[sizeof("prompt")];
5.116 - char kconf_id_strings_str32[sizeof("depends")];
5.117 - char kconf_id_strings_str33[sizeof("tristate")];
5.118 - char kconf_id_strings_str34[sizeof("bool")];
5.119 - char kconf_id_strings_str35[sizeof("menuconfig")];
5.120 - char kconf_id_strings_str36[sizeof("select")];
5.121 - char kconf_id_strings_str37[sizeof("boolean")];
5.122 - char kconf_id_strings_str39[sizeof("help")];
5.123 - char kconf_id_strings_str41[sizeof("source")];
5.124 - char kconf_id_strings_str42[sizeof("comment")];
5.125 - char kconf_id_strings_str43[sizeof("mainmenu")];
5.126 - char kconf_id_strings_str46[sizeof("enable")];
5.127 - };
5.128 -static struct kconf_id_strings_t kconf_id_strings_contents =
5.129 - {
5.130 - "on",
5.131 - "string",
5.132 - "default",
5.133 - "def_bool",
5.134 - "range",
5.135 - "def_boolean",
5.136 - "def_tristate",
5.137 - "hex",
5.138 - "defconfig_list",
5.139 - "option",
5.140 - "if",
5.141 - "optional",
5.142 - "endif",
5.143 - "choice",
5.144 - "endmenu",
5.145 - "requires",
5.146 - "endchoice",
5.147 - "config",
5.148 - "modules",
5.149 - "int",
5.150 - "menu",
5.151 - "prompt",
5.152 - "depends",
5.153 - "tristate",
5.154 - "bool",
5.155 - "menuconfig",
5.156 - "select",
5.157 - "boolean",
5.158 - "help",
5.159 - "source",
5.160 - "comment",
5.161 - "mainmenu",
5.162 - "enable"
5.163 - };
5.164 -#define kconf_id_strings ((const char *) &kconf_id_strings_contents)
5.165 -#ifdef __GNUC__
5.166 -__inline
5.167 -#endif
5.168 -struct kconf_id *
5.169 -kconf_id_lookup (register const char *str, register unsigned int len)
5.170 -{
5.171 - enum
5.172 - {
5.173 - TOTAL_KEYWORDS = 33,
5.174 - MIN_WORD_LENGTH = 2,
5.175 - MAX_WORD_LENGTH = 14,
5.176 - MIN_HASH_VALUE = 2,
5.177 - MAX_HASH_VALUE = 46
5.178 - };
5.179 -
5.180 - static struct kconf_id wordlist[] =
5.181 - {
5.182 - {-1}, {-1},
5.183 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str2, T_ON, TF_PARAM},
5.184 - {-1}, {-1}, {-1},
5.185 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str6, T_TYPE, TF_COMMAND, S_STRING},
5.186 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str7, T_DEFAULT, TF_COMMAND, S_UNKNOWN},
5.187 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str8, T_DEFAULT, TF_COMMAND, S_BOOLEAN},
5.188 - {-1},
5.189 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str10, T_RANGE, TF_COMMAND},
5.190 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str11, T_DEFAULT, TF_COMMAND, S_BOOLEAN},
5.191 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str12, T_DEFAULT, TF_COMMAND, S_TRISTATE},
5.192 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str13, T_TYPE, TF_COMMAND, S_HEX},
5.193 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str14, T_OPT_DEFCONFIG_LIST,TF_OPTION},
5.194 - {-1},
5.195 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str16, T_OPTION, TF_COMMAND},
5.196 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str17, T_IF, TF_COMMAND|TF_PARAM},
5.197 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str18, T_OPTIONAL, TF_COMMAND},
5.198 - {-1},
5.199 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str20, T_ENDIF, TF_COMMAND},
5.200 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str21, T_CHOICE, TF_COMMAND},
5.201 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str22, T_ENDMENU, TF_COMMAND},
5.202 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str23, T_REQUIRES, TF_COMMAND},
5.203 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str24, T_ENDCHOICE, TF_COMMAND},
5.204 - {-1},
5.205 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str26, T_CONFIG, TF_COMMAND},
5.206 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str27, T_OPT_MODULES, TF_OPTION},
5.207 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str28, T_TYPE, TF_COMMAND, S_INT},
5.208 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str29, T_MENU, TF_COMMAND},
5.209 - {-1},
5.210 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str31, T_PROMPT, TF_COMMAND},
5.211 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str32, T_DEPENDS, TF_COMMAND},
5.212 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str33, T_TYPE, TF_COMMAND, S_TRISTATE},
5.213 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str34, T_TYPE, TF_COMMAND, S_BOOLEAN},
5.214 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str35, T_MENUCONFIG, TF_COMMAND},
5.215 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str36, T_SELECT, TF_COMMAND},
5.216 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str37, T_TYPE, TF_COMMAND, S_BOOLEAN},
5.217 - {-1},
5.218 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str39, T_HELP, TF_COMMAND},
5.219 - {-1},
5.220 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str41, T_SOURCE, TF_COMMAND},
5.221 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str42, T_COMMENT, TF_COMMAND},
5.222 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str43, T_MAINMENU, TF_COMMAND},
5.223 - {-1}, {-1},
5.224 - {(int)(long)&((struct kconf_id_strings_t *)0)->kconf_id_strings_str46, T_SELECT, TF_COMMAND}
5.225 - };
5.226 -
5.227 - if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
5.228 - {
5.229 - register int key = kconf_id_hash (str, len);
5.230 -
5.231 - if (key <= MAX_HASH_VALUE && key >= 0)
5.232 - {
5.233 - register int o = wordlist[key].name;
5.234 - if (o >= 0)
5.235 - {
5.236 - register const char *s = o + kconf_id_strings;
5.237 -
5.238 - if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
5.239 - return &wordlist[key];
5.240 - }
5.241 - }
5.242 - }
5.243 - return 0;
5.244 -}
5.245 -
6.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
6.2 +++ b/kconfig/zconf.tab.c Sun Sep 28 10:33:30 2008 +0000
6.3 @@ -0,0 +1,2345 @@
6.4 +/* A Bison parser, made by GNU Bison 2.1. */
6.5 +
6.6 +/* Skeleton parser for Yacc-like parsing with Bison,
6.7 + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
6.8 +
6.9 + This program is free software; you can redistribute it and/or modify
6.10 + it under the terms of the GNU General Public License as published by
6.11 + the Free Software Foundation; either version 2, or (at your option)
6.12 + any later version.
6.13 +
6.14 + This program is distributed in the hope that it will be useful,
6.15 + but WITHOUT ANY WARRANTY; without even the implied warranty of
6.16 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
6.17 + GNU General Public License for more details.
6.18 +
6.19 + You should have received a copy of the GNU General Public License
6.20 + along with this program; if not, write to the Free Software
6.21 + Foundation, Inc., 51 Franklin Street, Fifth Floor,
6.22 + Boston, MA 02110-1301, USA. */
6.23 +
6.24 +/* As a special exception, when this file is copied by Bison into a
6.25 + Bison output file, you may use that output file without restriction.
6.26 + This special exception was added by the Free Software Foundation
6.27 + in version 1.24 of Bison. */
6.28 +
6.29 +/* Written by Richard Stallman by simplifying the original so called
6.30 + ``semantic'' parser. */
6.31 +
6.32 +/* All symbols defined below should begin with yy or YY, to avoid
6.33 + infringing on user name space. This should be done even for local
6.34 + variables, as they might otherwise be expanded by user macros.
6.35 + There are some unavoidable exceptions within include files to
6.36 + define necessary library symbols; they are noted "INFRINGES ON
6.37 + USER NAME SPACE" below. */
6.38 +
6.39 +/* Identify Bison output. */
6.40 +#define YYBISON 1
6.41 +
6.42 +/* Bison version. */
6.43 +#define YYBISON_VERSION "2.1"
6.44 +
6.45 +/* Skeleton name. */
6.46 +#define YYSKELETON_NAME "yacc.c"
6.47 +
6.48 +/* Pure parsers. */
6.49 +#define YYPURE 0
6.50 +
6.51 +/* Using locations. */
6.52 +#define YYLSP_NEEDED 0
6.53 +
6.54 +/* Substitute the variable and function names. */
6.55 +#define yyparse zconfparse
6.56 +#define yylex zconflex
6.57 +#define yyerror zconferror
6.58 +#define yylval zconflval
6.59 +#define yychar zconfchar
6.60 +#define yydebug zconfdebug
6.61 +#define yynerrs zconfnerrs
6.62 +
6.63 +
6.64 +/* Tokens. */
6.65 +#ifndef YYTOKENTYPE
6.66 +# define YYTOKENTYPE
6.67 + /* Put the tokens into the symbol table, so that GDB and other debuggers
6.68 + know about them. */
6.69 + enum yytokentype {
6.70 + T_MAINMENU = 258,
6.71 + T_MENU = 259,
6.72 + T_ENDMENU = 260,
6.73 + T_SOURCE = 261,
6.74 + T_CHOICE = 262,
6.75 + T_ENDCHOICE = 263,
6.76 + T_COMMENT = 264,
6.77 + T_CONFIG = 265,
6.78 + T_MENUCONFIG = 266,
6.79 + T_HELP = 267,
6.80 + T_HELPTEXT = 268,
6.81 + T_IF = 269,
6.82 + T_ENDIF = 270,
6.83 + T_DEPENDS = 271,
6.84 + T_REQUIRES = 272,
6.85 + T_OPTIONAL = 273,
6.86 + T_PROMPT = 274,
6.87 + T_TYPE = 275,
6.88 + T_DEFAULT = 276,
6.89 + T_SELECT = 277,
6.90 + T_RANGE = 278,
6.91 + T_OPTION = 279,
6.92 + T_ON = 280,
6.93 + T_WORD = 281,
6.94 + T_WORD_QUOTE = 282,
6.95 + T_UNEQUAL = 283,
6.96 + T_CLOSE_PAREN = 284,
6.97 + T_OPEN_PAREN = 285,
6.98 + T_EOL = 286,
6.99 + T_OR = 287,
6.100 + T_AND = 288,
6.101 + T_EQUAL = 289,
6.102 + T_NOT = 290
6.103 + };
6.104 +#endif
6.105 +/* Tokens. */
6.106 +#define T_MAINMENU 258
6.107 +#define T_MENU 259
6.108 +#define T_ENDMENU 260
6.109 +#define T_SOURCE 261
6.110 +#define T_CHOICE 262
6.111 +#define T_ENDCHOICE 263
6.112 +#define T_COMMENT 264
6.113 +#define T_CONFIG 265
6.114 +#define T_MENUCONFIG 266
6.115 +#define T_HELP 267
6.116 +#define T_HELPTEXT 268
6.117 +#define T_IF 269
6.118 +#define T_ENDIF 270
6.119 +#define T_DEPENDS 271
6.120 +#define T_REQUIRES 272
6.121 +#define T_OPTIONAL 273
6.122 +#define T_PROMPT 274
6.123 +#define T_TYPE 275
6.124 +#define T_DEFAULT 276
6.125 +#define T_SELECT 277
6.126 +#define T_RANGE 278
6.127 +#define T_OPTION 279
6.128 +#define T_ON 280
6.129 +#define T_WORD 281
6.130 +#define T_WORD_QUOTE 282
6.131 +#define T_UNEQUAL 283
6.132 +#define T_CLOSE_PAREN 284
6.133 +#define T_OPEN_PAREN 285
6.134 +#define T_EOL 286
6.135 +#define T_OR 287
6.136 +#define T_AND 288
6.137 +#define T_EQUAL 289
6.138 +#define T_NOT 290
6.139 +
6.140 +
6.141 +
6.142 +
6.143 +/* Copy the first part of user declarations. */
6.144 +
6.145 +
6.146 +/*
6.147 + * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
6.148 + * Released under the terms of the GNU GPL v2.0.
6.149 + */
6.150 +
6.151 +#include <ctype.h>
6.152 +#include <stdarg.h>
6.153 +#include <stdio.h>
6.154 +#include <stdlib.h>
6.155 +#include <string.h>
6.156 +#include <stdbool.h>
6.157 +
6.158 +#define LKC_DIRECT_LINK
6.159 +#include "lkc.h"
6.160 +
6.161 +#include "zconf.hash.c"
6.162 +
6.163 +#define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
6.164 +
6.165 +#define PRINTD 0x0001
6.166 +#define DEBUG_PARSE 0x0002
6.167 +
6.168 +int cdebug = PRINTD;
6.169 +
6.170 +extern int zconflex(void);
6.171 +static void zconfprint(const char *err, ...);
6.172 +static void zconf_error(const char *err, ...);
6.173 +static void zconferror(const char *err);
6.174 +static bool zconf_endtoken(struct kconf_id *id, int starttoken, int endtoken);
6.175 +
6.176 +struct symbol *symbol_hash[257];
6.177 +
6.178 +static struct menu *current_menu, *current_entry;
6.179 +
6.180 +#define YYDEBUG 0
6.181 +#if YYDEBUG
6.182 +#define YYERROR_VERBOSE
6.183 +#endif
6.184 +
6.185 +
6.186 +/* Enabling traces. */
6.187 +#ifndef YYDEBUG
6.188 +# define YYDEBUG 0
6.189 +#endif
6.190 +
6.191 +/* Enabling verbose error messages. */
6.192 +#ifdef YYERROR_VERBOSE
6.193 +# undef YYERROR_VERBOSE
6.194 +# define YYERROR_VERBOSE 1
6.195 +#else
6.196 +# define YYERROR_VERBOSE 0
6.197 +#endif
6.198 +
6.199 +/* Enabling the token table. */
6.200 +#ifndef YYTOKEN_TABLE
6.201 +# define YYTOKEN_TABLE 0
6.202 +#endif
6.203 +
6.204 +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
6.205 +
6.206 +typedef union YYSTYPE {
6.207 + char *string;
6.208 + struct file *file;
6.209 + struct symbol *symbol;
6.210 + struct expr *expr;
6.211 + struct menu *menu;
6.212 + struct kconf_id *id;
6.213 +} YYSTYPE;
6.214 +/* Line 196 of yacc.c. */
6.215 +
6.216 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */
6.217 +# define YYSTYPE_IS_DECLARED 1
6.218 +# define YYSTYPE_IS_TRIVIAL 1
6.219 +#endif
6.220 +
6.221 +
6.222 +
6.223 +/* Copy the second part of user declarations. */
6.224 +
6.225 +
6.226 +/* Line 219 of yacc.c. */
6.227 +
6.228 +
6.229 +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
6.230 +# define YYSIZE_T __SIZE_TYPE__
6.231 +#endif
6.232 +#if ! defined (YYSIZE_T) && defined (size_t)
6.233 +# define YYSIZE_T size_t
6.234 +#endif
6.235 +#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
6.236 +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
6.237 +# define YYSIZE_T size_t
6.238 +#endif
6.239 +#if ! defined (YYSIZE_T)
6.240 +# define YYSIZE_T unsigned int
6.241 +#endif
6.242 +
6.243 +#ifndef YY_
6.244 +# if YYENABLE_NLS
6.245 +# if ENABLE_NLS
6.246 +# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
6.247 +# define YY_(msgid) dgettext ("bison-runtime", msgid)
6.248 +# endif
6.249 +# endif
6.250 +# ifndef YY_
6.251 +# define YY_(msgid) msgid
6.252 +# endif
6.253 +#endif
6.254 +
6.255 +#if ! defined (yyoverflow) || YYERROR_VERBOSE
6.256 +
6.257 +/* The parser invokes alloca or malloc; define the necessary symbols. */
6.258 +
6.259 +# ifdef YYSTACK_USE_ALLOCA
6.260 +# if YYSTACK_USE_ALLOCA
6.261 +# ifdef __GNUC__
6.262 +# define YYSTACK_ALLOC __builtin_alloca
6.263 +# else
6.264 +# define YYSTACK_ALLOC alloca
6.265 +# if defined (__STDC__) || defined (__cplusplus)
6.266 +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
6.267 +# define YYINCLUDED_STDLIB_H
6.268 +# endif
6.269 +# endif
6.270 +# endif
6.271 +# endif
6.272 +
6.273 +# ifdef YYSTACK_ALLOC
6.274 + /* Pacify GCC's `empty if-body' warning. */
6.275 +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
6.276 +# ifndef YYSTACK_ALLOC_MAXIMUM
6.277 + /* The OS might guarantee only one guard page at the bottom of the stack,
6.278 + and a page size can be as small as 4096 bytes. So we cannot safely
6.279 + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
6.280 + to allow for a few compiler-allocated temporary stack slots. */
6.281 +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
6.282 +# endif
6.283 +# else
6.284 +# define YYSTACK_ALLOC YYMALLOC
6.285 +# define YYSTACK_FREE YYFREE
6.286 +# ifndef YYSTACK_ALLOC_MAXIMUM
6.287 +# define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
6.288 +# endif
6.289 +# ifdef __cplusplus
6.290 +extern "C" {
6.291 +# endif
6.292 +# ifndef YYMALLOC
6.293 +# define YYMALLOC malloc
6.294 +# if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
6.295 + && (defined (__STDC__) || defined (__cplusplus)))
6.296 +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
6.297 +# endif
6.298 +# endif
6.299 +# ifndef YYFREE
6.300 +# define YYFREE free
6.301 +# if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
6.302 + && (defined (__STDC__) || defined (__cplusplus)))
6.303 +void free (void *); /* INFRINGES ON USER NAME SPACE */
6.304 +# endif
6.305 +# endif
6.306 +# ifdef __cplusplus
6.307 +}
6.308 +# endif
6.309 +# endif
6.310 +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
6.311 +
6.312 +
6.313 +#if (! defined (yyoverflow) \
6.314 + && (! defined (__cplusplus) \
6.315 + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
6.316 +
6.317 +/* A type that is properly aligned for any stack member. */
6.318 +union yyalloc
6.319 +{
6.320 + short int yyss;
6.321 + YYSTYPE yyvs;
6.322 + };
6.323 +
6.324 +/* The size of the maximum gap between one aligned stack and the next. */
6.325 +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
6.326 +
6.327 +/* The size of an array large to enough to hold all stacks, each with
6.328 + N elements. */
6.329 +# define YYSTACK_BYTES(N) \
6.330 + ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
6.331 + + YYSTACK_GAP_MAXIMUM)
6.332 +
6.333 +/* Copy COUNT objects from FROM to TO. The source and destination do
6.334 + not overlap. */
6.335 +# ifndef YYCOPY
6.336 +# if defined (__GNUC__) && 1 < __GNUC__
6.337 +# define YYCOPY(To, From, Count) \
6.338 + __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
6.339 +# else
6.340 +# define YYCOPY(To, From, Count) \
6.341 + do \
6.342 + { \
6.343 + YYSIZE_T yyi; \
6.344 + for (yyi = 0; yyi < (Count); yyi++) \
6.345 + (To)[yyi] = (From)[yyi]; \
6.346 + } \
6.347 + while (0)
6.348 +# endif
6.349 +# endif
6.350 +
6.351 +/* Relocate STACK from its old location to the new one. The
6.352 + local variables YYSIZE and YYSTACKSIZE give the old and new number of
6.353 + elements in the stack, and YYPTR gives the new location of the
6.354 + stack. Advance YYPTR to a properly aligned location for the next
6.355 + stack. */
6.356 +# define YYSTACK_RELOCATE(Stack) \
6.357 + do \
6.358 + { \
6.359 + YYSIZE_T yynewbytes; \
6.360 + YYCOPY (&yyptr->Stack, Stack, yysize); \
6.361 + Stack = &yyptr->Stack; \
6.362 + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
6.363 + yyptr += yynewbytes / sizeof (*yyptr); \
6.364 + } \
6.365 + while (0)
6.366 +
6.367 +#endif
6.368 +
6.369 +#if defined (__STDC__) || defined (__cplusplus)
6.370 + typedef signed char yysigned_char;
6.371 +#else
6.372 + typedef short int yysigned_char;
6.373 +#endif
6.374 +
6.375 +/* YYFINAL -- State number of the termination state. */
6.376 +#define YYFINAL 3
6.377 +/* YYLAST -- Last index in YYTABLE. */
6.378 +#define YYLAST 275
6.379 +
6.380 +/* YYNTOKENS -- Number of terminals. */
6.381 +#define YYNTOKENS 36
6.382 +/* YYNNTS -- Number of nonterminals. */
6.383 +#define YYNNTS 45
6.384 +/* YYNRULES -- Number of rules. */
6.385 +#define YYNRULES 110
6.386 +/* YYNRULES -- Number of states. */
6.387 +#define YYNSTATES 183
6.388 +
6.389 +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
6.390 +#define YYUNDEFTOK 2
6.391 +#define YYMAXUTOK 290
6.392 +
6.393 +#define YYTRANSLATE(YYX) \
6.394 + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
6.395 +
6.396 +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
6.397 +static const unsigned char yytranslate[] =
6.398 +{
6.399 + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.400 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.401 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.402 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.403 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.404 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.405 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.406 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.407 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.408 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.409 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.410 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.411 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.412 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.413 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.414 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.415 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.416 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.417 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.418 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.419 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.420 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.421 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.422 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.423 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6.424 + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
6.425 + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
6.426 + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
6.427 + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
6.428 + 35
6.429 +};
6.430 +
6.431 +#if YYDEBUG
6.432 +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
6.433 + YYRHS. */
6.434 +static const unsigned short int yyprhs[] =
6.435 +{
6.436 + 0, 0, 3, 5, 6, 9, 12, 15, 20, 23,
6.437 + 28, 33, 37, 39, 41, 43, 45, 47, 49, 51,
6.438 + 53, 55, 57, 59, 61, 63, 67, 70, 74, 77,
6.439 + 81, 84, 85, 88, 91, 94, 97, 100, 103, 107,
6.440 + 112, 117, 122, 128, 132, 133, 137, 138, 141, 144,
6.441 + 147, 149, 153, 154, 157, 160, 163, 166, 169, 174,
6.442 + 178, 181, 186, 187, 190, 194, 196, 200, 201, 204,
6.443 + 207, 210, 214, 217, 219, 223, 224, 227, 230, 233,
6.444 + 237, 241, 244, 247, 250, 251, 254, 257, 260, 265,
6.445 + 269, 273, 274, 277, 279, 281, 284, 287, 290, 292,
6.446 + 295, 296, 299, 301, 305, 309, 313, 316, 320, 324,
6.447 + 326
6.448 +};
6.449 +
6.450 +/* YYRHS -- A `-1'-separated list of the rules' RHS. */
6.451 +static const yysigned_char yyrhs[] =
6.452 +{
6.453 + 37, 0, -1, 38, -1, -1, 38, 40, -1, 38,
6.454 + 54, -1, 38, 65, -1, 38, 3, 75, 77, -1,
6.455 + 38, 76, -1, 38, 26, 1, 31, -1, 38, 39,
6.456 + 1, 31, -1, 38, 1, 31, -1, 16, -1, 19,
6.457 + -1, 20, -1, 22, -1, 18, -1, 23, -1, 21,
6.458 + -1, 31, -1, 60, -1, 69, -1, 43, -1, 45,
6.459 + -1, 67, -1, 26, 1, 31, -1, 1, 31, -1,
6.460 + 10, 26, 31, -1, 42, 46, -1, 11, 26, 31,
6.461 + -1, 44, 46, -1, -1, 46, 47, -1, 46, 48,
6.462 + -1, 46, 73, -1, 46, 71, -1, 46, 41, -1,
6.463 + 46, 31, -1, 20, 74, 31, -1, 19, 75, 78,
6.464 + 31, -1, 21, 79, 78, 31, -1, 22, 26, 78,
6.465 + 31, -1, 23, 80, 80, 78, 31, -1, 24, 49,
6.466 + 31, -1, -1, 49, 26, 50, -1, -1, 34, 75,
6.467 + -1, 7, 31, -1, 51, 55, -1, 76, -1, 52,
6.468 + 57, 53, -1, -1, 55, 56, -1, 55, 73, -1,
6.469 + 55, 71, -1, 55, 31, -1, 55, 41, -1, 19,
6.470 + 75, 78, 31, -1, 20, 74, 31, -1, 18, 31,
6.471 + -1, 21, 26, 78, 31, -1, -1, 57, 40, -1,
6.472 + 14, 79, 77, -1, 76, -1, 58, 61, 59, -1,
6.473 + -1, 61, 40, -1, 61, 65, -1, 61, 54, -1,
6.474 + 4, 75, 31, -1, 62, 72, -1, 76, -1, 63,
6.475 + 66, 64, -1, -1, 66, 40, -1, 66, 65, -1,
6.476 + 66, 54, -1, 6, 75, 31, -1, 9, 75, 31,
6.477 + -1, 68, 72, -1, 12, 31, -1, 70, 13, -1,
6.478 + -1, 72, 73, -1, 72, 31, -1, 72, 41, -1,
6.479 + 16, 25, 79, 31, -1, 16, 79, 31, -1, 17,
6.480 + 79, 31, -1, -1, 75, 78, -1, 26, -1, 27,
6.481 + -1, 5, 31, -1, 8, 31, -1, 15, 31, -1,
6.482 + 31, -1, 77, 31, -1, -1, 14, 79, -1, 80,
6.483 + -1, 80, 34, 80, -1, 80, 28, 80, -1, 30,
6.484 + 79, 29, -1, 35, 79, -1, 79, 32, 79, -1,
6.485 + 79, 33, 79, -1, 26, -1, 27, -1
6.486 +};
6.487 +
6.488 +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
6.489 +static const unsigned short int yyrline[] =
6.490 +{
6.491 + 0, 105, 105, 107, 109, 110, 111, 112, 113, 114,
6.492 + 115, 119, 123, 123, 123, 123, 123, 123, 123, 127,
6.493 + 128, 129, 130, 131, 132, 136, 137, 143, 151, 157,
6.494 + 165, 175, 177, 178, 179, 180, 181, 182, 185, 193,
6.495 + 199, 209, 215, 221, 224, 226, 237, 238, 243, 252,
6.496 + 257, 265, 268, 270, 271, 272, 273, 274, 277, 283,
6.497 + 294, 300, 310, 312, 317, 325, 333, 336, 338, 339,
6.498 + 340, 345, 352, 357, 365, 368, 370, 371, 372, 375,
6.499 + 383, 390, 397, 403, 410, 412, 413, 414, 417, 422,
6.500 + 427, 435, 437, 442, 443, 446, 447, 448, 452, 453,
6.501 + 456, 457, 460, 461, 462, 463, 464, 465, 466, 469,
6.502 + 470
6.503 +};
6.504 +#endif
6.505 +
6.506 +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
6.507 +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
6.508 + First, the terminals, then, starting at YYNTOKENS, nonterminals. */
6.509 +static const char *const yytname[] =
6.510 +{
6.511 + "$end", "error", "$undefined", "T_MAINMENU", "T_MENU", "T_ENDMENU",
6.512 + "T_SOURCE", "T_CHOICE", "T_ENDCHOICE", "T_COMMENT", "T_CONFIG",
6.513 + "T_MENUCONFIG", "T_HELP", "T_HELPTEXT", "T_IF", "T_ENDIF", "T_DEPENDS",
6.514 + "T_REQUIRES", "T_OPTIONAL", "T_PROMPT", "T_TYPE", "T_DEFAULT",
6.515 + "T_SELECT", "T_RANGE", "T_OPTION", "T_ON", "T_WORD", "T_WORD_QUOTE",
6.516 + "T_UNEQUAL", "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_EOL", "T_OR", "T_AND",
6.517 + "T_EQUAL", "T_NOT", "$accept", "input", "stmt_list", "option_name",
6.518 + "common_stmt", "option_error", "config_entry_start", "config_stmt",
6.519 + "menuconfig_entry_start", "menuconfig_stmt", "config_option_list",
6.520 + "config_option", "symbol_option", "symbol_option_list",
6.521 + "symbol_option_arg", "choice", "choice_entry", "choice_end",
6.522 + "choice_stmt", "choice_option_list", "choice_option", "choice_block",
6.523 + "if_entry", "if_end", "if_stmt", "if_block", "menu", "menu_entry",
6.524 + "menu_end", "menu_stmt", "menu_block", "source_stmt", "comment",
6.525 + "comment_stmt", "help_start", "help", "depends_list", "depends",
6.526 + "prompt_stmt_opt", "prompt", "end", "nl", "if_expr", "expr", "symbol", 0
6.527 +};
6.528 +#endif
6.529 +
6.530 +# ifdef YYPRINT
6.531 +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
6.532 + token YYLEX-NUM. */
6.533 +static const unsigned short int yytoknum[] =
6.534 +{
6.535 + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
6.536 + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
6.537 + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
6.538 + 285, 286, 287, 288, 289, 290
6.539 +};
6.540 +# endif
6.541 +
6.542 +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
6.543 +static const unsigned char yyr1[] =
6.544 +{
6.545 + 0, 36, 37, 38, 38, 38, 38, 38, 38, 38,
6.546 + 38, 38, 39, 39, 39, 39, 39, 39, 39, 40,
6.547 + 40, 40, 40, 40, 40, 41, 41, 42, 43, 44,
6.548 + 45, 46, 46, 46, 46, 46, 46, 46, 47, 47,
6.549 + 47, 47, 47, 48, 49, 49, 50, 50, 51, 52,
6.550 + 53, 54, 55, 55, 55, 55, 55, 55, 56, 56,
6.551 + 56, 56, 57, 57, 58, 59, 60, 61, 61, 61,
6.552 + 61, 62, 63, 64, 65, 66, 66, 66, 66, 67,
6.553 + 68, 69, 70, 71, 72, 72, 72, 72, 73, 73,
6.554 + 73, 74, 74, 75, 75, 76, 76, 76, 77, 77,
6.555 + 78, 78, 79, 79, 79, 79, 79, 79, 79, 80,
6.556 + 80
6.557 +};
6.558 +
6.559 +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
6.560 +static const unsigned char yyr2[] =
6.561 +{
6.562 + 0, 2, 1, 0, 2, 2, 2, 4, 2, 4,
6.563 + 4, 3, 1, 1, 1, 1, 1, 1, 1, 1,
6.564 + 1, 1, 1, 1, 1, 3, 2, 3, 2, 3,
6.565 + 2, 0, 2, 2, 2, 2, 2, 2, 3, 4,
6.566 + 4, 4, 5, 3, 0, 3, 0, 2, 2, 2,
6.567 + 1, 3, 0, 2, 2, 2, 2, 2, 4, 3,
6.568 + 2, 4, 0, 2, 3, 1, 3, 0, 2, 2,
6.569 + 2, 3, 2, 1, 3, 0, 2, 2, 2, 3,
6.570 + 3, 2, 2, 2, 0, 2, 2, 2, 4, 3,
6.571 + 3, 0, 2, 1, 1, 2, 2, 2, 1, 2,
6.572 + 0, 2, 1, 3, 3, 3, 2, 3, 3, 1,
6.573 + 1
6.574 +};
6.575 +
6.576 +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
6.577 + STATE-NUM when YYTABLE doesn't specify something else to do. Zero
6.578 + means the default is an error. */
6.579 +static const unsigned char yydefact[] =
6.580 +{
6.581 + 3, 0, 0, 1, 0, 0, 0, 0, 0, 0,
6.582 + 0, 0, 0, 0, 0, 0, 12, 16, 13, 14,
6.583 + 18, 15, 17, 0, 19, 0, 4, 31, 22, 31,
6.584 + 23, 52, 62, 5, 67, 20, 84, 75, 6, 24,
6.585 + 84, 21, 8, 11, 93, 94, 0, 0, 95, 0,
6.586 + 48, 96, 0, 0, 0, 109, 110, 0, 0, 0,
6.587 + 102, 97, 0, 0, 0, 0, 0, 0, 0, 0,
6.588 + 0, 0, 98, 7, 71, 79, 80, 27, 29, 0,
6.589 + 106, 0, 0, 64, 0, 0, 9, 10, 0, 0,
6.590 + 0, 0, 0, 91, 0, 0, 0, 44, 0, 37,
6.591 + 36, 32, 33, 0, 35, 34, 0, 0, 91, 0,
6.592 + 56, 57, 53, 55, 54, 63, 51, 50, 68, 70,
6.593 + 66, 69, 65, 86, 87, 85, 76, 78, 74, 77,
6.594 + 73, 99, 105, 107, 108, 104, 103, 26, 82, 0,
6.595 + 0, 0, 100, 0, 100, 100, 100, 0, 0, 0,
6.596 + 83, 60, 100, 0, 100, 0, 89, 90, 0, 0,
6.597 + 38, 92, 0, 0, 100, 46, 43, 25, 0, 59,
6.598 + 0, 88, 101, 39, 40, 41, 0, 0, 45, 58,
6.599 + 61, 42, 47
6.600 +};
6.601 +
6.602 +/* YYDEFGOTO[NTERM-NUM]. */
6.603 +static const short int yydefgoto[] =
6.604 +{
6.605 + -1, 1, 2, 25, 26, 100, 27, 28, 29, 30,
6.606 + 64, 101, 102, 148, 178, 31, 32, 116, 33, 66,
6.607 + 112, 67, 34, 120, 35, 68, 36, 37, 128, 38,
6.608 + 70, 39, 40, 41, 103, 104, 69, 105, 143, 144,
6.609 + 42, 73, 159, 59, 60
6.610 +};
6.611 +
6.612 +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
6.613 + STATE-NUM. */
6.614 +#define YYPACT_NINF -135
6.615 +static const short int yypact[] =
6.616 +{
6.617 + -135, 2, 170, -135, -14, 56, 56, -8, 56, 24,
6.618 + 67, 56, 7, 14, 62, 97, -135, -135, -135, -135,
6.619 + -135, -135, -135, 156, -135, 166, -135, -135, -135, -135,
6.620 + -135, -135, -135, -135, -135, -135, -135, -135, -135, -135,
6.621 + -135, -135, -135, -135, -135, -135, 138, 151, -135, 152,
6.622 + -135, -135, 163, 167, 176, -135, -135, 62, 62, 185,
6.623 + -19, -135, 188, 190, 42, 103, 194, 85, 70, 222,
6.624 + 70, 132, -135, 191, -135, -135, -135, -135, -135, 127,
6.625 + -135, 62, 62, 191, 104, 104, -135, -135, 193, 203,
6.626 + 9, 62, 56, 56, 62, 161, 104, -135, 196, -135,
6.627 + -135, -135, -135, 233, -135, -135, 204, 56, 56, 221,
6.628 + -135, -135, -135, -135, -135, -135, -135, -135, -135, -135,
6.629 + -135, -135, -135, -135, -135, -135, -135, -135, -135, -135,
6.630 + -135, -135, -135, 219, -135, -135, -135, -135, -135, 62,
6.631 + 209, 212, 240, 224, 240, -1, 240, 104, 41, 225,
6.632 + -135, -135, 240, 226, 240, 218, -135, -135, 62, 227,
6.633 + -135, -135, 228, 229, 240, 230, -135, -135, 231, -135,
6.634 + 232, -135, 112, -135, -135, -135, 234, 56, -135, -135,
6.635 + -135, -135, -135
6.636 +};
6.637 +
6.638 +/* YYPGOTO[NTERM-NUM]. */
6.639 +static const short int yypgoto[] =
6.640 +{
6.641 + -135, -135, -135, -135, 94, -45, -135, -135, -135, -135,
6.642 + 237, -135, -135, -135, -135, -135, -135, -135, -54, -135,
6.643 + -135, -135, -135, -135, -135, -135, -135, -135, -135, 1,
6.644 + -135, -135, -135, -135, -135, 195, 235, -44, 159, -5,
6.645 + 98, 210, -134, -53, -77
6.646 +};
6.647 +
6.648 +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
6.649 + positive, shift that token. If negative, reduce the rule which
6.650 + number is the opposite. If zero, do what YYDEFACT says.
6.651 + If YYTABLE_NINF, syntax error. */
6.652 +#define YYTABLE_NINF -82
6.653 +static const short int yytable[] =
6.654 +{
6.655 + 46, 47, 3, 49, 79, 80, 52, 135, 136, 84,
6.656 + 161, 162, 163, 158, 119, 85, 127, 43, 168, 147,
6.657 + 170, 111, 114, 48, 124, 125, 124, 125, 133, 134,
6.658 + 176, 81, 82, 53, 139, 55, 56, 140, 141, 57,
6.659 + 54, 145, -28, 88, 58, -28, -28, -28, -28, -28,
6.660 + -28, -28, -28, -28, 89, 50, -28, -28, 90, 91,
6.661 + -28, 92, 93, 94, 95, 96, 97, 165, 98, 121,
6.662 + 164, 129, 166, 99, 6, 7, 8, 9, 10, 11,
6.663 + 12, 13, 44, 45, 14, 15, 155, 142, 55, 56,
6.664 + 7, 8, 57, 10, 11, 12, 13, 58, 51, 14,
6.665 + 15, 24, 152, -30, 88, 172, -30, -30, -30, -30,
6.666 + -30, -30, -30, -30, -30, 89, 24, -30, -30, 90,
6.667 + 91, -30, 92, 93, 94, 95, 96, 97, 61, 98,
6.668 + 55, 56, -81, 88, 99, -81, -81, -81, -81, -81,
6.669 + -81, -81, -81, -81, 81, 82, -81, -81, 90, 91,
6.670 + -81, -81, -81, -81, -81, -81, 132, 62, 98, 81,
6.671 + 82, 115, 118, 123, 126, 117, 122, 63, 130, 72,
6.672 + -2, 4, 182, 5, 6, 7, 8, 9, 10, 11,
6.673 + 12, 13, 74, 75, 14, 15, 16, 146, 17, 18,
6.674 + 19, 20, 21, 22, 76, 88, 23, 149, 77, -49,
6.675 + -49, 24, -49, -49, -49, -49, 89, 78, -49, -49,
6.676 + 90, 91, 106, 107, 108, 109, 72, 81, 82, 86,
6.677 + 98, 87, 131, 88, 137, 110, -72, -72, -72, -72,
6.678 + -72, -72, -72, -72, 138, 151, -72, -72, 90, 91,
6.679 + 156, 81, 82, 157, 81, 82, 150, 154, 98, 171,
6.680 + 81, 82, 82, 123, 158, 160, 167, 169, 173, 174,
6.681 + 175, 113, 179, 180, 177, 181, 65, 153, 0, 83,
6.682 + 0, 0, 0, 0, 0, 71
6.683 +};
6.684 +
6.685 +static const short int yycheck[] =
6.686 +{
6.687 + 5, 6, 0, 8, 57, 58, 11, 84, 85, 28,
6.688 + 144, 145, 146, 14, 68, 34, 70, 31, 152, 96,
6.689 + 154, 66, 66, 31, 69, 69, 71, 71, 81, 82,
6.690 + 164, 32, 33, 26, 25, 26, 27, 90, 91, 30,
6.691 + 26, 94, 0, 1, 35, 3, 4, 5, 6, 7,
6.692 + 8, 9, 10, 11, 12, 31, 14, 15, 16, 17,
6.693 + 18, 19, 20, 21, 22, 23, 24, 26, 26, 68,
6.694 + 147, 70, 31, 31, 4, 5, 6, 7, 8, 9,
6.695 + 10, 11, 26, 27, 14, 15, 139, 92, 26, 27,
6.696 + 5, 6, 30, 8, 9, 10, 11, 35, 31, 14,
6.697 + 15, 31, 107, 0, 1, 158, 3, 4, 5, 6,
6.698 + 7, 8, 9, 10, 11, 12, 31, 14, 15, 16,
6.699 + 17, 18, 19, 20, 21, 22, 23, 24, 31, 26,
6.700 + 26, 27, 0, 1, 31, 3, 4, 5, 6, 7,
6.701 + 8, 9, 10, 11, 32, 33, 14, 15, 16, 17,
6.702 + 18, 19, 20, 21, 22, 23, 29, 1, 26, 32,
6.703 + 33, 67, 68, 31, 70, 67, 68, 1, 70, 31,
6.704 + 0, 1, 177, 3, 4, 5, 6, 7, 8, 9,
6.705 + 10, 11, 31, 31, 14, 15, 16, 26, 18, 19,
6.706 + 20, 21, 22, 23, 31, 1, 26, 1, 31, 5,
6.707 + 6, 31, 8, 9, 10, 11, 12, 31, 14, 15,
6.708 + 16, 17, 18, 19, 20, 21, 31, 32, 33, 31,
6.709 + 26, 31, 31, 1, 31, 31, 4, 5, 6, 7,
6.710 + 8, 9, 10, 11, 31, 31, 14, 15, 16, 17,
6.711 + 31, 32, 33, 31, 32, 33, 13, 26, 26, 31,
6.712 + 32, 33, 33, 31, 14, 31, 31, 31, 31, 31,
6.713 + 31, 66, 31, 31, 34, 31, 29, 108, -1, 59,
6.714 + -1, -1, -1, -1, -1, 40
6.715 +};
6.716 +
6.717 +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
6.718 + symbol of state STATE-NUM. */
6.719 +static const unsigned char yystos[] =
6.720 +{
6.721 + 0, 37, 38, 0, 1, 3, 4, 5, 6, 7,
6.722 + 8, 9, 10, 11, 14, 15, 16, 18, 19, 20,
6.723 + 21, 22, 23, 26, 31, 39, 40, 42, 43, 44,
6.724 + 45, 51, 52, 54, 58, 60, 62, 63, 65, 67,
6.725 + 68, 69, 76, 31, 26, 27, 75, 75, 31, 75,
6.726 + 31, 31, 75, 26, 26, 26, 27, 30, 35, 79,
6.727 + 80, 31, 1, 1, 46, 46, 55, 57, 61, 72,
6.728 + 66, 72, 31, 77, 31, 31, 31, 31, 31, 79,
6.729 + 79, 32, 33, 77, 28, 34, 31, 31, 1, 12,
6.730 + 16, 17, 19, 20, 21, 22, 23, 24, 26, 31,
6.731 + 41, 47, 48, 70, 71, 73, 18, 19, 20, 21,
6.732 + 31, 41, 56, 71, 73, 40, 53, 76, 40, 54,
6.733 + 59, 65, 76, 31, 41, 73, 40, 54, 64, 65,
6.734 + 76, 31, 29, 79, 79, 80, 80, 31, 31, 25,
6.735 + 79, 79, 75, 74, 75, 79, 26, 80, 49, 1,
6.736 + 13, 31, 75, 74, 26, 79, 31, 31, 14, 78,
6.737 + 31, 78, 78, 78, 80, 26, 31, 31, 78, 31,
6.738 + 78, 31, 79, 31, 31, 31, 78, 34, 50, 31,
6.739 + 31, 31, 75
6.740 +};
6.741 +
6.742 +#define yyerrok (yyerrstatus = 0)
6.743 +#define yyclearin (yychar = YYEMPTY)
6.744 +#define YYEMPTY (-2)
6.745 +#define YYEOF 0
6.746 +
6.747 +#define YYACCEPT goto yyacceptlab
6.748 +#define YYABORT goto yyabortlab
6.749 +#define YYERROR goto yyerrorlab
6.750 +
6.751 +
6.752 +/* Like YYERROR except do call yyerror. This remains here temporarily
6.753 + to ease the transition to the new meaning of YYERROR, for GCC.
6.754 + Once GCC version 2 has supplanted version 1, this can go. */
6.755 +
6.756 +#define YYFAIL goto yyerrlab
6.757 +
6.758 +#define YYRECOVERING() (!!yyerrstatus)
6.759 +
6.760 +#define YYBACKUP(Token, Value) \
6.761 +do \
6.762 + if (yychar == YYEMPTY && yylen == 1) \
6.763 + { \
6.764 + yychar = (Token); \
6.765 + yylval = (Value); \
6.766 + yytoken = YYTRANSLATE (yychar); \
6.767 + YYPOPSTACK; \
6.768 + goto yybackup; \
6.769 + } \
6.770 + else \
6.771 + { \
6.772 + yyerror (YY_("syntax error: cannot back up")); \
6.773 + YYERROR; \
6.774 + } \
6.775 +while (0)
6.776 +
6.777 +
6.778 +#define YYTERROR 1
6.779 +#define YYERRCODE 256
6.780 +
6.781 +
6.782 +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
6.783 + If N is 0, then set CURRENT to the empty location which ends
6.784 + the previous symbol: RHS[0] (always defined). */
6.785 +
6.786 +#define YYRHSLOC(Rhs, K) ((Rhs)[K])
6.787 +#ifndef YYLLOC_DEFAULT
6.788 +# define YYLLOC_DEFAULT(Current, Rhs, N) \
6.789 + do \
6.790 + if (N) \
6.791 + { \
6.792 + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
6.793 + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
6.794 + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
6.795 + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
6.796 + } \
6.797 + else \
6.798 + { \
6.799 + (Current).first_line = (Current).last_line = \
6.800 + YYRHSLOC (Rhs, 0).last_line; \
6.801 + (Current).first_column = (Current).last_column = \
6.802 + YYRHSLOC (Rhs, 0).last_column; \
6.803 + } \
6.804 + while (0)
6.805 +#endif
6.806 +
6.807 +
6.808 +/* YY_LOCATION_PRINT -- Print the location on the stream.
6.809 + This macro was not mandated originally: define only if we know
6.810 + we won't break user code: when these are the locations we know. */
6.811 +
6.812 +#ifndef YY_LOCATION_PRINT
6.813 +# if YYLTYPE_IS_TRIVIAL
6.814 +# define YY_LOCATION_PRINT(File, Loc) \
6.815 + fprintf (File, "%d.%d-%d.%d", \
6.816 + (Loc).first_line, (Loc).first_column, \
6.817 + (Loc).last_line, (Loc).last_column)
6.818 +# else
6.819 +# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
6.820 +# endif
6.821 +#endif
6.822 +
6.823 +
6.824 +/* YYLEX -- calling `yylex' with the right arguments. */
6.825 +
6.826 +#ifdef YYLEX_PARAM
6.827 +# define YYLEX yylex (YYLEX_PARAM)
6.828 +#else
6.829 +# define YYLEX yylex ()
6.830 +#endif
6.831 +
6.832 +/* Enable debugging if requested. */
6.833 +#if YYDEBUG
6.834 +
6.835 +# ifndef YYFPRINTF
6.836 +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
6.837 +# define YYFPRINTF fprintf
6.838 +# endif
6.839 +
6.840 +# define YYDPRINTF(Args) \
6.841 +do { \
6.842 + if (yydebug) \
6.843 + YYFPRINTF Args; \
6.844 +} while (0)
6.845 +
6.846 +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
6.847 +do { \
6.848 + if (yydebug) \
6.849 + { \
6.850 + YYFPRINTF (stderr, "%s ", Title); \
6.851 + yysymprint (stderr, \
6.852 + Type, Value); \
6.853 + YYFPRINTF (stderr, "\n"); \
6.854 + } \
6.855 +} while (0)
6.856 +
6.857 +/*------------------------------------------------------------------.
6.858 +| yy_stack_print -- Print the state stack from its BOTTOM up to its |
6.859 +| TOP (included). |
6.860 +`------------------------------------------------------------------*/
6.861 +
6.862 +#if defined (__STDC__) || defined (__cplusplus)
6.863 +static void
6.864 +yy_stack_print (short int *bottom, short int *top)
6.865 +#else
6.866 +static void
6.867 +yy_stack_print (bottom, top)
6.868 + short int *bottom;
6.869 + short int *top;
6.870 +#endif
6.871 +{
6.872 + YYFPRINTF (stderr, "Stack now");
6.873 + for (/* Nothing. */; bottom <= top; ++bottom)
6.874 + YYFPRINTF (stderr, " %d", *bottom);
6.875 + YYFPRINTF (stderr, "\n");
6.876 +}
6.877 +
6.878 +# define YY_STACK_PRINT(Bottom, Top) \
6.879 +do { \
6.880 + if (yydebug) \
6.881 + yy_stack_print ((Bottom), (Top)); \
6.882 +} while (0)
6.883 +
6.884 +
6.885 +/*------------------------------------------------.
6.886 +| Report that the YYRULE is going to be reduced. |
6.887 +`------------------------------------------------*/
6.888 +
6.889 +#if defined (__STDC__) || defined (__cplusplus)
6.890 +static void
6.891 +yy_reduce_print (int yyrule)
6.892 +#else
6.893 +static void
6.894 +yy_reduce_print (yyrule)
6.895 + int yyrule;
6.896 +#endif
6.897 +{
6.898 + int yyi;
6.899 + unsigned long int yylno = yyrline[yyrule];
6.900 + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
6.901 + yyrule - 1, yylno);
6.902 + /* Print the symbols being reduced, and their result. */
6.903 + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
6.904 + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
6.905 + YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
6.906 +}
6.907 +
6.908 +# define YY_REDUCE_PRINT(Rule) \
6.909 +do { \
6.910 + if (yydebug) \
6.911 + yy_reduce_print (Rule); \
6.912 +} while (0)
6.913 +
6.914 +/* Nonzero means print parse trace. It is left uninitialized so that
6.915 + multiple parsers can coexist. */
6.916 +int yydebug;
6.917 +#else /* !YYDEBUG */
6.918 +# define YYDPRINTF(Args)
6.919 +# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
6.920 +# define YY_STACK_PRINT(Bottom, Top)
6.921 +# define YY_REDUCE_PRINT(Rule)
6.922 +#endif /* !YYDEBUG */
6.923 +
6.924 +
6.925 +/* YYINITDEPTH -- initial size of the parser's stacks. */
6.926 +#ifndef YYINITDEPTH
6.927 +# define YYINITDEPTH 200
6.928 +#endif
6.929 +
6.930 +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
6.931 + if the built-in stack extension method is used).
6.932 +
6.933 + Do not make this value too large; the results are undefined if
6.934 + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
6.935 + evaluated with infinite-precision integer arithmetic. */
6.936 +
6.937 +#ifndef YYMAXDEPTH
6.938 +# define YYMAXDEPTH 10000
6.939 +#endif
6.940 +
6.941 +
6.942 +
6.943 +#if YYERROR_VERBOSE
6.944 +
6.945 +# ifndef yystrlen
6.946 +# if defined (__GLIBC__) && defined (_STRING_H)
6.947 +# define yystrlen strlen
6.948 +# else
6.949 +/* Return the length of YYSTR. */
6.950 +static YYSIZE_T
6.951 +# if defined (__STDC__) || defined (__cplusplus)
6.952 +yystrlen (const char *yystr)
6.953 +# else
6.954 +yystrlen (yystr)
6.955 + const char *yystr;
6.956 +# endif
6.957 +{
6.958 + const char *yys = yystr;
6.959 +
6.960 + while (*yys++ != '\0')
6.961 + continue;
6.962 +
6.963 + return yys - yystr - 1;
6.964 +}
6.965 +# endif
6.966 +# endif
6.967 +
6.968 +# ifndef yystpcpy
6.969 +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
6.970 +# define yystpcpy stpcpy
6.971 +# else
6.972 +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
6.973 + YYDEST. */
6.974 +static char *
6.975 +# if defined (__STDC__) || defined (__cplusplus)
6.976 +yystpcpy (char *yydest, const char *yysrc)
6.977 +# else
6.978 +yystpcpy (yydest, yysrc)
6.979 + char *yydest;
6.980 + const char *yysrc;
6.981 +# endif
6.982 +{
6.983 + char *yyd = yydest;
6.984 + const char *yys = yysrc;
6.985 +
6.986 + while ((*yyd++ = *yys++) != '\0')
6.987 + continue;
6.988 +
6.989 + return yyd - 1;
6.990 +}
6.991 +# endif
6.992 +# endif
6.993 +
6.994 +# ifndef yytnamerr
6.995 +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
6.996 + quotes and backslashes, so that it's suitable for yyerror. The
6.997 + heuristic is that double-quoting is unnecessary unless the string
6.998 + contains an apostrophe, a comma, or backslash (other than
6.999 + backslash-backslash). YYSTR is taken from yytname. If YYRES is
6.1000 + null, do not copy; instead, return the length of what the result
6.1001 + would have been. */
6.1002 +static YYSIZE_T
6.1003 +yytnamerr (char *yyres, const char *yystr)
6.1004 +{
6.1005 + if (*yystr == '"')
6.1006 + {
6.1007 + size_t yyn = 0;
6.1008 + char const *yyp = yystr;
6.1009 +
6.1010 + for (;;)
6.1011 + switch (*++yyp)
6.1012 + {
6.1013 + case '\'':
6.1014 + case ',':
6.1015 + goto do_not_strip_quotes;
6.1016 +
6.1017 + case '\\':
6.1018 + if (*++yyp != '\\')
6.1019 + goto do_not_strip_quotes;
6.1020 + /* Fall through. */
6.1021 + default:
6.1022 + if (yyres)
6.1023 + yyres[yyn] = *yyp;
6.1024 + yyn++;
6.1025 + break;
6.1026 +
6.1027 + case '"':
6.1028 + if (yyres)
6.1029 + yyres[yyn] = '\0';
6.1030 + return yyn;
6.1031 + }
6.1032 + do_not_strip_quotes: ;
6.1033 + }
6.1034 +
6.1035 + if (! yyres)
6.1036 + return yystrlen (yystr);
6.1037 +
6.1038 + return yystpcpy (yyres, yystr) - yyres;
6.1039 +}
6.1040 +# endif
6.1041 +
6.1042 +#endif /* YYERROR_VERBOSE */
6.1043 +
6.1044 +
6.1045 +
6.1046 +#if YYDEBUG
6.1047 +/*--------------------------------.
6.1048 +| Print this symbol on YYOUTPUT. |
6.1049 +`--------------------------------*/
6.1050 +
6.1051 +#if defined (__STDC__) || defined (__cplusplus)
6.1052 +static void
6.1053 +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
6.1054 +#else
6.1055 +static void
6.1056 +yysymprint (yyoutput, yytype, yyvaluep)
6.1057 + FILE *yyoutput;
6.1058 + int yytype;
6.1059 + YYSTYPE *yyvaluep;
6.1060 +#endif
6.1061 +{
6.1062 + /* Pacify ``unused variable'' warnings. */
6.1063 + (void) yyvaluep;
6.1064 +
6.1065 + if (yytype < YYNTOKENS)
6.1066 + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
6.1067 + else
6.1068 + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
6.1069 +
6.1070 +
6.1071 +# ifdef YYPRINT
6.1072 + if (yytype < YYNTOKENS)
6.1073 + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
6.1074 +# endif
6.1075 + switch (yytype)
6.1076 + {
6.1077 + default:
6.1078 + break;
6.1079 + }
6.1080 + YYFPRINTF (yyoutput, ")");
6.1081 +}
6.1082 +
6.1083 +#endif /* ! YYDEBUG */
6.1084 +/*-----------------------------------------------.
6.1085 +| Release the memory associated to this symbol. |
6.1086 +`-----------------------------------------------*/
6.1087 +
6.1088 +#if defined (__STDC__) || defined (__cplusplus)
6.1089 +static void
6.1090 +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
6.1091 +#else
6.1092 +static void
6.1093 +yydestruct (yymsg, yytype, yyvaluep)
6.1094 + const char *yymsg;
6.1095 + int yytype;
6.1096 + YYSTYPE *yyvaluep;
6.1097 +#endif
6.1098 +{
6.1099 + /* Pacify ``unused variable'' warnings. */
6.1100 + (void) yyvaluep;
6.1101 +
6.1102 + if (!yymsg)
6.1103 + yymsg = "Deleting";
6.1104 + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
6.1105 +
6.1106 + switch (yytype)
6.1107 + {
6.1108 + case 52: /* "choice_entry" */
6.1109 +
6.1110 + {
6.1111 + fprintf(stderr, "%s:%d: missing end statement for this entry\n",
6.1112 + (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
6.1113 + if (current_menu == (yyvaluep->menu))
6.1114 + menu_end_menu();
6.1115 +};
6.1116 +
6.1117 + break;
6.1118 + case 58: /* "if_entry" */
6.1119 +
6.1120 + {
6.1121 + fprintf(stderr, "%s:%d: missing end statement for this entry\n",
6.1122 + (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
6.1123 + if (current_menu == (yyvaluep->menu))
6.1124 + menu_end_menu();
6.1125 +};
6.1126 +
6.1127 + break;
6.1128 + case 63: /* "menu_entry" */
6.1129 +
6.1130 + {
6.1131 + fprintf(stderr, "%s:%d: missing end statement for this entry\n",
6.1132 + (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
6.1133 + if (current_menu == (yyvaluep->menu))
6.1134 + menu_end_menu();
6.1135 +};
6.1136 +
6.1137 + break;
6.1138 +
6.1139 + default:
6.1140 + break;
6.1141 + }
6.1142 +}
6.1143 +
6.1144 +
6.1145 +/* Prevent warnings from -Wmissing-prototypes. */
6.1146 +
6.1147 +#ifdef YYPARSE_PARAM
6.1148 +# if defined (__STDC__) || defined (__cplusplus)
6.1149 +int yyparse (void *YYPARSE_PARAM);
6.1150 +# else
6.1151 +int yyparse ();
6.1152 +# endif
6.1153 +#else /* ! YYPARSE_PARAM */
6.1154 +#if defined (__STDC__) || defined (__cplusplus)
6.1155 +int yyparse (void);
6.1156 +#else
6.1157 +int yyparse ();
6.1158 +#endif
6.1159 +#endif /* ! YYPARSE_PARAM */
6.1160 +
6.1161 +
6.1162 +
6.1163 +/* The look-ahead symbol. */
6.1164 +int yychar;
6.1165 +
6.1166 +/* The semantic value of the look-ahead symbol. */
6.1167 +YYSTYPE yylval;
6.1168 +
6.1169 +/* Number of syntax errors so far. */
6.1170 +int yynerrs;
6.1171 +
6.1172 +
6.1173 +
6.1174 +/*----------.
6.1175 +| yyparse. |
6.1176 +`----------*/
6.1177 +
6.1178 +#ifdef YYPARSE_PARAM
6.1179 +# if defined (__STDC__) || defined (__cplusplus)
6.1180 +int yyparse (void *YYPARSE_PARAM)
6.1181 +# else
6.1182 +int yyparse (YYPARSE_PARAM)
6.1183 + void *YYPARSE_PARAM;
6.1184 +# endif
6.1185 +#else /* ! YYPARSE_PARAM */
6.1186 +#if defined (__STDC__) || defined (__cplusplus)
6.1187 +int
6.1188 +yyparse (void)
6.1189 +#else
6.1190 +int
6.1191 +yyparse ()
6.1192 + ;
6.1193 +#endif
6.1194 +#endif
6.1195 +{
6.1196 +
6.1197 + int yystate;
6.1198 + int yyn;
6.1199 + int yyresult;
6.1200 + /* Number of tokens to shift before error messages enabled. */
6.1201 + int yyerrstatus;
6.1202 + /* Look-ahead token as an internal (translated) token number. */
6.1203 + int yytoken = 0;
6.1204 +
6.1205 + /* Three stacks and their tools:
6.1206 + `yyss': related to states,
6.1207 + `yyvs': related to semantic values,
6.1208 + `yyls': related to locations.
6.1209 +
6.1210 + Refer to the stacks thru separate pointers, to allow yyoverflow
6.1211 + to reallocate them elsewhere. */
6.1212 +
6.1213 + /* The state stack. */
6.1214 + short int yyssa[YYINITDEPTH];
6.1215 + short int *yyss = yyssa;
6.1216 + short int *yyssp;
6.1217 +
6.1218 + /* The semantic value stack. */
6.1219 + YYSTYPE yyvsa[YYINITDEPTH];
6.1220 + YYSTYPE *yyvs = yyvsa;
6.1221 + YYSTYPE *yyvsp;
6.1222 +
6.1223 +
6.1224 +
6.1225 +#define YYPOPSTACK (yyvsp--, yyssp--)
6.1226 +
6.1227 + YYSIZE_T yystacksize = YYINITDEPTH;
6.1228 +
6.1229 + /* The variables used to return semantic value and location from the
6.1230 + action routines. */
6.1231 + YYSTYPE yyval;
6.1232 +
6.1233 +
6.1234 + /* When reducing, the number of symbols on the RHS of the reduced
6.1235 + rule. */
6.1236 + int yylen;
6.1237 +
6.1238 + YYDPRINTF ((stderr, "Starting parse\n"));
6.1239 +
6.1240 + yystate = 0;
6.1241 + yyerrstatus = 0;
6.1242 + yynerrs = 0;
6.1243 + yychar = YYEMPTY; /* Cause a token to be read. */
6.1244 +
6.1245 + /* Initialize stack pointers.
6.1246 + Waste one element of value and location stack
6.1247 + so that they stay on the same level as the state stack.
6.1248 + The wasted elements are never initialized. */
6.1249 +
6.1250 + yyssp = yyss;
6.1251 + yyvsp = yyvs;
6.1252 +
6.1253 + goto yysetstate;
6.1254 +
6.1255 +/*------------------------------------------------------------.
6.1256 +| yynewstate -- Push a new state, which is found in yystate. |
6.1257 +`------------------------------------------------------------*/
6.1258 + yynewstate:
6.1259 + /* In all cases, when you get here, the value and location stacks
6.1260 + have just been pushed. so pushing a state here evens the stacks.
6.1261 + */
6.1262 + yyssp++;
6.1263 +
6.1264 + yysetstate:
6.1265 + *yyssp = yystate;
6.1266 +
6.1267 + if (yyss + yystacksize - 1 <= yyssp)
6.1268 + {
6.1269 + /* Get the current used size of the three stacks, in elements. */
6.1270 + YYSIZE_T yysize = yyssp - yyss + 1;
6.1271 +
6.1272 +#ifdef yyoverflow
6.1273 + {
6.1274 + /* Give user a chance to reallocate the stack. Use copies of
6.1275 + these so that the &'s don't force the real ones into
6.1276 + memory. */
6.1277 + YYSTYPE *yyvs1 = yyvs;
6.1278 + short int *yyss1 = yyss;
6.1279 +
6.1280 +
6.1281 + /* Each stack pointer address is followed by the size of the
6.1282 + data in use in that stack, in bytes. This used to be a
6.1283 + conditional around just the two extra args, but that might
6.1284 + be undefined if yyoverflow is a macro. */
6.1285 + yyoverflow (YY_("memory exhausted"),
6.1286 + &yyss1, yysize * sizeof (*yyssp),
6.1287 + &yyvs1, yysize * sizeof (*yyvsp),
6.1288 +
6.1289 + &yystacksize);
6.1290 +
6.1291 + yyss = yyss1;
6.1292 + yyvs = yyvs1;
6.1293 + }
6.1294 +#else /* no yyoverflow */
6.1295 +# ifndef YYSTACK_RELOCATE
6.1296 + goto yyexhaustedlab;
6.1297 +# else
6.1298 + /* Extend the stack our own way. */
6.1299 + if (YYMAXDEPTH <= yystacksize)
6.1300 + goto yyexhaustedlab;
6.1301 + yystacksize *= 2;
6.1302 + if (YYMAXDEPTH < yystacksize)
6.1303 + yystacksize = YYMAXDEPTH;
6.1304 +
6.1305 + {
6.1306 + short int *yyss1 = yyss;
6.1307 + union yyalloc *yyptr =
6.1308 + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
6.1309 + if (! yyptr)
6.1310 + goto yyexhaustedlab;
6.1311 + YYSTACK_RELOCATE (yyss);
6.1312 + YYSTACK_RELOCATE (yyvs);
6.1313 +
6.1314 +# undef YYSTACK_RELOCATE
6.1315 + if (yyss1 != yyssa)
6.1316 + YYSTACK_FREE (yyss1);
6.1317 + }
6.1318 +# endif
6.1319 +#endif /* no yyoverflow */
6.1320 +
6.1321 + yyssp = yyss + yysize - 1;
6.1322 + yyvsp = yyvs + yysize - 1;
6.1323 +
6.1324 +
6.1325 + YYDPRINTF ((stderr, "Stack size increased to %lu\n",
6.1326 + (unsigned long int) yystacksize));
6.1327 +
6.1328 + if (yyss + yystacksize - 1 <= yyssp)
6.1329 + YYABORT;
6.1330 + }
6.1331 +
6.1332 + YYDPRINTF ((stderr, "Entering state %d\n", yystate));
6.1333 +
6.1334 + goto yybackup;
6.1335 +
6.1336 +/*-----------.
6.1337 +| yybackup. |
6.1338 +`-----------*/
6.1339 +yybackup:
6.1340 +
6.1341 +/* Do appropriate processing given the current state. */
6.1342 +/* Read a look-ahead token if we need one and don't already have one. */
6.1343 +/* yyresume: */
6.1344 +
6.1345 + /* First try to decide what to do without reference to look-ahead token. */
6.1346 +
6.1347 + yyn = yypact[yystate];
6.1348 + if (yyn == YYPACT_NINF)
6.1349 + goto yydefault;
6.1350 +
6.1351 + /* Not known => get a look-ahead token if don't already have one. */
6.1352 +
6.1353 + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
6.1354 + if (yychar == YYEMPTY)
6.1355 + {
6.1356 + YYDPRINTF ((stderr, "Reading a token: "));
6.1357 + yychar = YYLEX;
6.1358 + }
6.1359 +
6.1360 + if (yychar <= YYEOF)
6.1361 + {
6.1362 + yychar = yytoken = YYEOF;
6.1363 + YYDPRINTF ((stderr, "Now at end of input.\n"));
6.1364 + }
6.1365 + else
6.1366 + {
6.1367 + yytoken = YYTRANSLATE (yychar);
6.1368 + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
6.1369 + }
6.1370 +
6.1371 + /* If the proper action on seeing token YYTOKEN is to reduce or to
6.1372 + detect an error, take that action. */
6.1373 + yyn += yytoken;
6.1374 + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
6.1375 + goto yydefault;
6.1376 + yyn = yytable[yyn];
6.1377 + if (yyn <= 0)
6.1378 + {
6.1379 + if (yyn == 0 || yyn == YYTABLE_NINF)
6.1380 + goto yyerrlab;
6.1381 + yyn = -yyn;
6.1382 + goto yyreduce;
6.1383 + }
6.1384 +
6.1385 + if (yyn == YYFINAL)
6.1386 + YYACCEPT;
6.1387 +
6.1388 + /* Shift the look-ahead token. */
6.1389 + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
6.1390 +
6.1391 + /* Discard the token being shifted unless it is eof. */
6.1392 + if (yychar != YYEOF)
6.1393 + yychar = YYEMPTY;
6.1394 +
6.1395 + *++yyvsp = yylval;
6.1396 +
6.1397 +
6.1398 + /* Count tokens shifted since error; after three, turn off error
6.1399 + status. */
6.1400 + if (yyerrstatus)
6.1401 + yyerrstatus--;
6.1402 +
6.1403 + yystate = yyn;
6.1404 + goto yynewstate;
6.1405 +
6.1406 +
6.1407 +/*-----------------------------------------------------------.
6.1408 +| yydefault -- do the default action for the current state. |
6.1409 +`-----------------------------------------------------------*/
6.1410 +yydefault:
6.1411 + yyn = yydefact[yystate];
6.1412 + if (yyn == 0)
6.1413 + goto yyerrlab;
6.1414 + goto yyreduce;
6.1415 +
6.1416 +
6.1417 +/*-----------------------------.
6.1418 +| yyreduce -- Do a reduction. |
6.1419 +`-----------------------------*/
6.1420 +yyreduce:
6.1421 + /* yyn is the number of a rule to reduce with. */
6.1422 + yylen = yyr2[yyn];
6.1423 +
6.1424 + /* If YYLEN is nonzero, implement the default value of the action:
6.1425 + `$$ = $1'.
6.1426 +
6.1427 + Otherwise, the following line sets YYVAL to garbage.
6.1428 + This behavior is undocumented and Bison
6.1429 + users should not rely upon it. Assigning to YYVAL
6.1430 + unconditionally makes the parser a bit smaller, and it avoids a
6.1431 + GCC warning that YYVAL may be used uninitialized. */
6.1432 + yyval = yyvsp[1-yylen];
6.1433 +
6.1434 +
6.1435 + YY_REDUCE_PRINT (yyn);
6.1436 + switch (yyn)
6.1437 + {
6.1438 + case 8:
6.1439 +
6.1440 + { zconf_error("unexpected end statement"); ;}
6.1441 + break;
6.1442 +
6.1443 + case 9:
6.1444 +
6.1445 + { zconf_error("unknown statement \"%s\"", (yyvsp[-2].string)); ;}
6.1446 + break;
6.1447 +
6.1448 + case 10:
6.1449 +
6.1450 + {
6.1451 + zconf_error("unexpected option \"%s\"", kconf_id_strings + (yyvsp[-2].id)->name);
6.1452 +;}
6.1453 + break;
6.1454 +
6.1455 + case 11:
6.1456 +
6.1457 + { zconf_error("invalid statement"); ;}
6.1458 + break;
6.1459 +
6.1460 + case 25:
6.1461 +
6.1462 + { zconf_error("unknown option \"%s\"", (yyvsp[-2].string)); ;}
6.1463 + break;
6.1464 +
6.1465 + case 26:
6.1466 +
6.1467 + { zconf_error("invalid option"); ;}
6.1468 + break;
6.1469 +
6.1470 + case 27:
6.1471 +
6.1472 + {
6.1473 + struct symbol *sym = sym_lookup((yyvsp[-1].string), 0);
6.1474 + sym->flags |= SYMBOL_OPTIONAL;
6.1475 + menu_add_entry(sym);
6.1476 + printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
6.1477 +;}
6.1478 + break;
6.1479 +
6.1480 + case 28:
6.1481 +
6.1482 + {
6.1483 + menu_end_entry();
6.1484 + printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
6.1485 +;}
6.1486 + break;
6.1487 +
6.1488 + case 29:
6.1489 +
6.1490 + {
6.1491 + struct symbol *sym = sym_lookup((yyvsp[-1].string), 0);
6.1492 + sym->flags |= SYMBOL_OPTIONAL;
6.1493 + menu_add_entry(sym);
6.1494 + printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
6.1495 +;}
6.1496 + break;
6.1497 +
6.1498 + case 30:
6.1499 +
6.1500 + {
6.1501 + if (current_entry->prompt)
6.1502 + current_entry->prompt->type = P_MENU;
6.1503 + else
6.1504 + zconfprint("warning: menuconfig statement without prompt");
6.1505 + menu_end_entry();
6.1506 + printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
6.1507 +;}
6.1508 + break;
6.1509 +
6.1510 + case 38:
6.1511 +
6.1512 + {
6.1513 + menu_set_type((yyvsp[-2].id)->stype);
6.1514 + printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
6.1515 + zconf_curname(), zconf_lineno(),
6.1516 + (yyvsp[-2].id)->stype);
6.1517 +;}
6.1518 + break;
6.1519 +
6.1520 + case 39:
6.1521 +
6.1522 + {
6.1523 + menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
6.1524 + printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
6.1525 +;}
6.1526 + break;
6.1527 +
6.1528 + case 40:
6.1529 +
6.1530 + {
6.1531 + menu_add_expr(P_DEFAULT, (yyvsp[-2].expr), (yyvsp[-1].expr));
6.1532 + if ((yyvsp[-3].id)->stype != S_UNKNOWN)
6.1533 + menu_set_type((yyvsp[-3].id)->stype);
6.1534 + printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
6.1535 + zconf_curname(), zconf_lineno(),
6.1536 + (yyvsp[-3].id)->stype);
6.1537 +;}
6.1538 + break;
6.1539 +
6.1540 + case 41:
6.1541 +
6.1542 + {
6.1543 + menu_add_symbol(P_SELECT, sym_lookup((yyvsp[-2].string), 0), (yyvsp[-1].expr));
6.1544 + printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
6.1545 +;}
6.1546 + break;
6.1547 +
6.1548 + case 42:
6.1549 +
6.1550 + {
6.1551 + menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[-3].symbol), (yyvsp[-2].symbol)), (yyvsp[-1].expr));
6.1552 + printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
6.1553 +;}
6.1554 + break;
6.1555 +
6.1556 + case 45:
6.1557 +
6.1558 + {
6.1559 + struct kconf_id *id = kconf_id_lookup((yyvsp[-1].string), strlen((yyvsp[-1].string)));
6.1560 + if (id && id->flags & TF_OPTION)
6.1561 + menu_add_option(id->token, (yyvsp[0].string));
6.1562 + else
6.1563 + zconfprint("warning: ignoring unknown option %s", (yyvsp[-1].string));
6.1564 + free((yyvsp[-1].string));
6.1565 +;}
6.1566 + break;
6.1567 +
6.1568 + case 46:
6.1569 +
6.1570 + { (yyval.string) = NULL; ;}
6.1571 + break;
6.1572 +
6.1573 + case 47:
6.1574 +
6.1575 + { (yyval.string) = (yyvsp[0].string); ;}
6.1576 + break;
6.1577 +
6.1578 + case 48:
6.1579 +
6.1580 + {
6.1581 + struct symbol *sym = sym_lookup(NULL, 0);
6.1582 + sym->flags |= SYMBOL_CHOICE;
6.1583 + menu_add_entry(sym);
6.1584 + menu_add_expr(P_CHOICE, NULL, NULL);
6.1585 + printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
6.1586 +;}
6.1587 + break;
6.1588 +
6.1589 + case 49:
6.1590 +
6.1591 + {
6.1592 + (yyval.menu) = menu_add_menu();
6.1593 +;}
6.1594 + break;
6.1595 +
6.1596 + case 50:
6.1597 +
6.1598 + {
6.1599 + if (zconf_endtoken((yyvsp[0].id), T_CHOICE, T_ENDCHOICE)) {
6.1600 + menu_end_menu();
6.1601 + printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
6.1602 + }
6.1603 +;}
6.1604 + break;
6.1605 +
6.1606 + case 58:
6.1607 +
6.1608 + {
6.1609 + menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
6.1610 + printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
6.1611 +;}
6.1612 + break;
6.1613 +
6.1614 + case 59:
6.1615 +
6.1616 + {
6.1617 + if ((yyvsp[-2].id)->stype == S_BOOLEAN || (yyvsp[-2].id)->stype == S_TRISTATE) {
6.1618 + menu_set_type((yyvsp[-2].id)->stype);
6.1619 + printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
6.1620 + zconf_curname(), zconf_lineno(),
6.1621 + (yyvsp[-2].id)->stype);
6.1622 + } else
6.1623 + YYERROR;
6.1624 +;}
6.1625 + break;
6.1626 +
6.1627 + case 60:
6.1628 +
6.1629 + {
6.1630 + current_entry->sym->flags |= SYMBOL_OPTIONAL;
6.1631 + printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
6.1632 +;}
6.1633 + break;
6.1634 +
6.1635 + case 61:
6.1636 +
6.1637 + {
6.1638 + if ((yyvsp[-3].id)->stype == S_UNKNOWN) {
6.1639 + menu_add_symbol(P_DEFAULT, sym_lookup((yyvsp[-2].string), 0), (yyvsp[-1].expr));
6.1640 + printd(DEBUG_PARSE, "%s:%d:default\n",
6.1641 + zconf_curname(), zconf_lineno());
6.1642 + } else
6.1643 + YYERROR;
6.1644 +;}
6.1645 + break;
6.1646 +
6.1647 + case 64:
6.1648 +
6.1649 + {
6.1650 + printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
6.1651 + menu_add_entry(NULL);
6.1652 + menu_add_dep((yyvsp[-1].expr));
6.1653 + (yyval.menu) = menu_add_menu();
6.1654 +;}
6.1655 + break;
6.1656 +
6.1657 + case 65:
6.1658 +
6.1659 + {
6.1660 + if (zconf_endtoken((yyvsp[0].id), T_IF, T_ENDIF)) {
6.1661 + menu_end_menu();
6.1662 + printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
6.1663 + }
6.1664 +;}
6.1665 + break;
6.1666 +
6.1667 + case 71:
6.1668 +
6.1669 + {
6.1670 + menu_add_entry(NULL);
6.1671 + menu_add_prompt(P_MENU, (yyvsp[-1].string), NULL);
6.1672 + printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
6.1673 +;}
6.1674 + break;
6.1675 +
6.1676 + case 72:
6.1677 +
6.1678 + {
6.1679 + (yyval.menu) = menu_add_menu();
6.1680 +;}
6.1681 + break;
6.1682 +
6.1683 + case 73:
6.1684 +
6.1685 + {
6.1686 + if (zconf_endtoken((yyvsp[0].id), T_MENU, T_ENDMENU)) {
6.1687 + menu_end_menu();
6.1688 + printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
6.1689 + }
6.1690 +;}
6.1691 + break;
6.1692 +
6.1693 + case 79:
6.1694 +
6.1695 + {
6.1696 + printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
6.1697 + zconf_nextfile((yyvsp[-1].string));
6.1698 +;}
6.1699 + break;
6.1700 +
6.1701 + case 80:
6.1702 +
6.1703 + {
6.1704 + menu_add_entry(NULL);
6.1705 + menu_add_prompt(P_COMMENT, (yyvsp[-1].string), NULL);
6.1706 + printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
6.1707 +;}
6.1708 + break;
6.1709 +
6.1710 + case 81:
6.1711 +
6.1712 + {
6.1713 + menu_end_entry();
6.1714 +;}
6.1715 + break;
6.1716 +
6.1717 + case 82:
6.1718 +
6.1719 + {
6.1720 + printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
6.1721 + zconf_starthelp();
6.1722 +;}
6.1723 + break;
6.1724 +
6.1725 + case 83:
6.1726 +
6.1727 + {
6.1728 + current_entry->sym->help = (yyvsp[0].string);
6.1729 +;}
6.1730 + break;
6.1731 +
6.1732 + case 88:
6.1733 +
6.1734 + {
6.1735 + menu_add_dep((yyvsp[-1].expr));
6.1736 + printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
6.1737 +;}
6.1738 + break;
6.1739 +
6.1740 + case 89:
6.1741 +
6.1742 + {
6.1743 + menu_add_dep((yyvsp[-1].expr));
6.1744 + printd(DEBUG_PARSE, "%s:%d:depends\n", zconf_curname(), zconf_lineno());
6.1745 +;}
6.1746 + break;
6.1747 +
6.1748 + case 90:
6.1749 +
6.1750 + {
6.1751 + menu_add_dep((yyvsp[-1].expr));
6.1752 + printd(DEBUG_PARSE, "%s:%d:requires\n", zconf_curname(), zconf_lineno());
6.1753 +;}
6.1754 + break;
6.1755 +
6.1756 + case 92:
6.1757 +
6.1758 + {
6.1759 + menu_add_prompt(P_PROMPT, (yyvsp[-1].string), (yyvsp[0].expr));
6.1760 +;}
6.1761 + break;
6.1762 +
6.1763 + case 95:
6.1764 +
6.1765 + { (yyval.id) = (yyvsp[-1].id); ;}
6.1766 + break;
6.1767 +
6.1768 + case 96:
6.1769 +
6.1770 + { (yyval.id) = (yyvsp[-1].id); ;}
6.1771 + break;
6.1772 +
6.1773 + case 97:
6.1774 +
6.1775 + { (yyval.id) = (yyvsp[-1].id); ;}
6.1776 + break;
6.1777 +
6.1778 + case 100:
6.1779 +
6.1780 + { (yyval.expr) = NULL; ;}
6.1781 + break;
6.1782 +
6.1783 + case 101:
6.1784 +
6.1785 + { (yyval.expr) = (yyvsp[0].expr); ;}
6.1786 + break;
6.1787 +
6.1788 + case 102:
6.1789 +
6.1790 + { (yyval.expr) = expr_alloc_symbol((yyvsp[0].symbol)); ;}
6.1791 + break;
6.1792 +
6.1793 + case 103:
6.1794 +
6.1795 + { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); ;}
6.1796 + break;
6.1797 +
6.1798 + case 104:
6.1799 +
6.1800 + { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); ;}
6.1801 + break;
6.1802 +
6.1803 + case 105:
6.1804 +
6.1805 + { (yyval.expr) = (yyvsp[-1].expr); ;}
6.1806 + break;
6.1807 +
6.1808 + case 106:
6.1809 +
6.1810 + { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[0].expr)); ;}
6.1811 + break;
6.1812 +
6.1813 + case 107:
6.1814 +
6.1815 + { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
6.1816 + break;
6.1817 +
6.1818 + case 108:
6.1819 +
6.1820 + { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
6.1821 + break;
6.1822 +
6.1823 + case 109:
6.1824 +
6.1825 + { (yyval.symbol) = sym_lookup((yyvsp[0].string), 0); free((yyvsp[0].string)); ;}
6.1826 + break;
6.1827 +
6.1828 + case 110:
6.1829 +
6.1830 + { (yyval.symbol) = sym_lookup((yyvsp[0].string), 1); free((yyvsp[0].string)); ;}
6.1831 + break;
6.1832 +
6.1833 +
6.1834 + default: break;
6.1835 + }
6.1836 +
6.1837 +/* Line 1126 of yacc.c. */
6.1838 +
6.1839 +
6.1840 + yyvsp -= yylen;
6.1841 + yyssp -= yylen;
6.1842 +
6.1843 +
6.1844 + YY_STACK_PRINT (yyss, yyssp);
6.1845 +
6.1846 + *++yyvsp = yyval;
6.1847 +
6.1848 +
6.1849 + /* Now `shift' the result of the reduction. Determine what state
6.1850 + that goes to, based on the state we popped back to and the rule
6.1851 + number reduced by. */
6.1852 +
6.1853 + yyn = yyr1[yyn];
6.1854 +
6.1855 + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6.1856 + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6.1857 + yystate = yytable[yystate];
6.1858 + else
6.1859 + yystate = yydefgoto[yyn - YYNTOKENS];
6.1860 +
6.1861 + goto yynewstate;
6.1862 +
6.1863 +
6.1864 +/*------------------------------------.
6.1865 +| yyerrlab -- here on detecting error |
6.1866 +`------------------------------------*/
6.1867 +yyerrlab:
6.1868 + /* If not already recovering from an error, report this error. */
6.1869 + if (!yyerrstatus)
6.1870 + {
6.1871 + ++yynerrs;
6.1872 +#if YYERROR_VERBOSE
6.1873 + yyn = yypact[yystate];
6.1874 +
6.1875 + if (YYPACT_NINF < yyn && yyn < YYLAST)
6.1876 + {
6.1877 + int yytype = YYTRANSLATE (yychar);
6.1878 + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
6.1879 + YYSIZE_T yysize = yysize0;
6.1880 + YYSIZE_T yysize1;
6.1881 + int yysize_overflow = 0;
6.1882 + char *yymsg = 0;
6.1883 +# define YYERROR_VERBOSE_ARGS_MAXIMUM 5
6.1884 + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
6.1885 + int yyx;
6.1886 +
6.1887 +#if 0
6.1888 + /* This is so xgettext sees the translatable formats that are
6.1889 + constructed on the fly. */
6.1890 + YY_("syntax error, unexpected %s");
6.1891 + YY_("syntax error, unexpected %s, expecting %s");
6.1892 + YY_("syntax error, unexpected %s, expecting %s or %s");
6.1893 + YY_("syntax error, unexpected %s, expecting %s or %s or %s");
6.1894 + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
6.1895 +#endif
6.1896 + char *yyfmt;
6.1897 + char const *yyf;
6.1898 + static char const yyunexpected[] = "syntax error, unexpected %s";
6.1899 + static char const yyexpecting[] = ", expecting %s";
6.1900 + static char const yyor[] = " or %s";
6.1901 + char yyformat[sizeof yyunexpected
6.1902 + + sizeof yyexpecting - 1
6.1903 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
6.1904 + * (sizeof yyor - 1))];
6.1905 + char const *yyprefix = yyexpecting;
6.1906 +
6.1907 + /* Start YYX at -YYN if negative to avoid negative indexes in
6.1908 + YYCHECK. */
6.1909 + int yyxbegin = yyn < 0 ? -yyn : 0;
6.1910 +
6.1911 + /* Stay within bounds of both yycheck and yytname. */
6.1912 + int yychecklim = YYLAST - yyn;
6.1913 + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
6.1914 + int yycount = 1;
6.1915 +
6.1916 + yyarg[0] = yytname[yytype];
6.1917 + yyfmt = yystpcpy (yyformat, yyunexpected);
6.1918 +
6.1919 + for (yyx = yyxbegin; yyx < yyxend; ++yyx)
6.1920 + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6.1921 + {
6.1922 + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
6.1923 + {
6.1924 + yycount = 1;
6.1925 + yysize = yysize0;
6.1926 + yyformat[sizeof yyunexpected - 1] = '\0';
6.1927 + break;
6.1928 + }
6.1929 + yyarg[yycount++] = yytname[yyx];
6.1930 + yysize1 = yysize + yytnamerr (0, yytname[yyx]);
6.1931 + yysize_overflow |= yysize1 < yysize;
6.1932 + yysize = yysize1;
6.1933 + yyfmt = yystpcpy (yyfmt, yyprefix);
6.1934 + yyprefix = yyor;
6.1935 + }
6.1936 +
6.1937 + yyf = YY_(yyformat);
6.1938 + yysize1 = yysize + yystrlen (yyf);
6.1939 + yysize_overflow |= yysize1 < yysize;
6.1940 + yysize = yysize1;
6.1941 +
6.1942 + if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
6.1943 + yymsg = (char *) YYSTACK_ALLOC (yysize);
6.1944 + if (yymsg)
6.1945 + {
6.1946 + /* Avoid sprintf, as that infringes on the user's name space.
6.1947 + Don't have undefined behavior even if the translation
6.1948 + produced a string with the wrong number of "%s"s. */
6.1949 + char *yyp = yymsg;
6.1950 + int yyi = 0;
6.1951 + while ((*yyp = *yyf))
6.1952 + {
6.1953 + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
6.1954 + {
6.1955 + yyp += yytnamerr (yyp, yyarg[yyi++]);
6.1956 + yyf += 2;
6.1957 + }
6.1958 + else
6.1959 + {
6.1960 + yyp++;
6.1961 + yyf++;
6.1962 + }
6.1963 + }
6.1964 + yyerror (yymsg);
6.1965 + YYSTACK_FREE (yymsg);
6.1966 + }
6.1967 + else
6.1968 + {
6.1969 + yyerror (YY_("syntax error"));
6.1970 + goto yyexhaustedlab;
6.1971 + }
6.1972 + }
6.1973 + else
6.1974 +#endif /* YYERROR_VERBOSE */
6.1975 + yyerror (YY_("syntax error"));
6.1976 + }
6.1977 +
6.1978 +
6.1979 +
6.1980 + if (yyerrstatus == 3)
6.1981 + {
6.1982 + /* If just tried and failed to reuse look-ahead token after an
6.1983 + error, discard it. */
6.1984 +
6.1985 + if (yychar <= YYEOF)
6.1986 + {
6.1987 + /* Return failure if at end of input. */
6.1988 + if (yychar == YYEOF)
6.1989 + YYABORT;
6.1990 + }
6.1991 + else
6.1992 + {
6.1993 + yydestruct ("Error: discarding", yytoken, &yylval);
6.1994 + yychar = YYEMPTY;
6.1995 + }
6.1996 + }
6.1997 +
6.1998 + /* Else will try to reuse look-ahead token after shifting the error
6.1999 + token. */
6.2000 + goto yyerrlab1;
6.2001 +
6.2002 +
6.2003 +/*---------------------------------------------------.
6.2004 +| yyerrorlab -- error raised explicitly by YYERROR. |
6.2005 +`---------------------------------------------------*/
6.2006 +yyerrorlab:
6.2007 +
6.2008 + /* Pacify compilers like GCC when the user code never invokes
6.2009 + YYERROR and the label yyerrorlab therefore never appears in user
6.2010 + code. */
6.2011 + if (0)
6.2012 + goto yyerrorlab;
6.2013 +
6.2014 +yyvsp -= yylen;
6.2015 + yyssp -= yylen;
6.2016 + yystate = *yyssp;
6.2017 + goto yyerrlab1;
6.2018 +
6.2019 +
6.2020 +/*-------------------------------------------------------------.
6.2021 +| yyerrlab1 -- common code for both syntax error and YYERROR. |
6.2022 +`-------------------------------------------------------------*/
6.2023 +yyerrlab1:
6.2024 + yyerrstatus = 3; /* Each real token shifted decrements this. */
6.2025 +
6.2026 + for (;;)
6.2027 + {
6.2028 + yyn = yypact[yystate];
6.2029 + if (yyn != YYPACT_NINF)
6.2030 + {
6.2031 + yyn += YYTERROR;
6.2032 + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6.2033 + {
6.2034 + yyn = yytable[yyn];
6.2035 + if (0 < yyn)
6.2036 + break;
6.2037 + }
6.2038 + }
6.2039 +
6.2040 + /* Pop the current state because it cannot handle the error token. */
6.2041 + if (yyssp == yyss)
6.2042 + YYABORT;
6.2043 +
6.2044 +
6.2045 + yydestruct ("Error: popping", yystos[yystate], yyvsp);
6.2046 + YYPOPSTACK;
6.2047 + yystate = *yyssp;
6.2048 + YY_STACK_PRINT (yyss, yyssp);
6.2049 + }
6.2050 +
6.2051 + if (yyn == YYFINAL)
6.2052 + YYACCEPT;
6.2053 +
6.2054 + *++yyvsp = yylval;
6.2055 +
6.2056 +
6.2057 + /* Shift the error token. */
6.2058 + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6.2059 +
6.2060 + yystate = yyn;
6.2061 + goto yynewstate;
6.2062 +
6.2063 +
6.2064 +/*-------------------------------------.
6.2065 +| yyacceptlab -- YYACCEPT comes here. |
6.2066 +`-------------------------------------*/
6.2067 +yyacceptlab:
6.2068 + yyresult = 0;
6.2069 + goto yyreturn;
6.2070 +
6.2071 +/*-----------------------------------.
6.2072 +| yyabortlab -- YYABORT comes here. |
6.2073 +`-----------------------------------*/
6.2074 +yyabortlab:
6.2075 + yyresult = 1;
6.2076 + goto yyreturn;
6.2077 +
6.2078 +#ifndef yyoverflow
6.2079 +/*-------------------------------------------------.
6.2080 +| yyexhaustedlab -- memory exhaustion comes here. |
6.2081 +`-------------------------------------------------*/
6.2082 +yyexhaustedlab:
6.2083 + yyerror (YY_("memory exhausted"));
6.2084 + yyresult = 2;
6.2085 + /* Fall through. */
6.2086 +#endif
6.2087 +
6.2088 +yyreturn:
6.2089 + if (yychar != YYEOF && yychar != YYEMPTY)
6.2090 + yydestruct ("Cleanup: discarding lookahead",
6.2091 + yytoken, &yylval);
6.2092 + while (yyssp != yyss)
6.2093 + {
6.2094 + yydestruct ("Cleanup: popping",
6.2095 + yystos[*yyssp], yyvsp);
6.2096 + YYPOPSTACK;
6.2097 + }
6.2098 +#ifndef yyoverflow
6.2099 + if (yyss != yyssa)
6.2100 + YYSTACK_FREE (yyss);
6.2101 +#endif
6.2102 + return yyresult;
6.2103 +}
6.2104 +
6.2105 +
6.2106 +
6.2107 +
6.2108 +
6.2109 +void conf_parse(const char *name)
6.2110 +{
6.2111 + struct symbol *sym;
6.2112 + int i;
6.2113 +
6.2114 + zconf_initscan(name);
6.2115 +
6.2116 + sym_init();
6.2117 + menu_init();
6.2118 + modules_sym = sym_lookup(NULL, 0);
6.2119 + modules_sym->type = S_BOOLEAN;
6.2120 + modules_sym->flags |= SYMBOL_AUTO;
6.2121 + rootmenu.prompt = menu_add_prompt(P_MENU, PROJECT_NAME" Configuration", NULL);
6.2122 +
6.2123 +#if YYDEBUG
6.2124 + if (getenv("ZCONF_DEBUG"))
6.2125 + zconfdebug = 1;
6.2126 +#endif
6.2127 + zconfparse();
6.2128 + if (zconfnerrs)
6.2129 + exit(1);
6.2130 + if (!modules_sym->prop) {
6.2131 + struct property *prop;
6.2132 +
6.2133 + prop = prop_alloc(P_DEFAULT, modules_sym);
6.2134 + prop->expr = expr_alloc_symbol(sym_lookup("MODULES", 0));
6.2135 + }
6.2136 + menu_finalize(&rootmenu);
6.2137 + for_all_symbols(i, sym) {
6.2138 + sym_check_deps(sym);
6.2139 + }
6.2140 +
6.2141 + sym_set_change_count(1);
6.2142 +}
6.2143 +
6.2144 +const char *zconf_tokenname(int token)
6.2145 +{
6.2146 + switch (token) {
6.2147 + case T_MENU: return "menu";
6.2148 + case T_ENDMENU: return "endmenu";
6.2149 + case T_CHOICE: return "choice";
6.2150 + case T_ENDCHOICE: return "endchoice";
6.2151 + case T_IF: return "if";
6.2152 + case T_ENDIF: return "endif";
6.2153 + case T_DEPENDS: return "depends";
6.2154 + }
6.2155 + return "<token>";
6.2156 +}
6.2157 +
6.2158 +static bool zconf_endtoken(struct kconf_id *id, int starttoken, int endtoken)
6.2159 +{
6.2160 + if (id->token != endtoken) {
6.2161 + zconf_error("unexpected '%s' within %s block",
6.2162 + kconf_id_strings + id->name, zconf_tokenname(starttoken));
6.2163 + zconfnerrs++;
6.2164 + return false;
6.2165 + }
6.2166 + if (current_menu->file != current_file) {
6.2167 + zconf_error("'%s' in different file than '%s'",
6.2168 + kconf_id_strings + id->name, zconf_tokenname(starttoken));
6.2169 + fprintf(stderr, "%s:%d: location of the '%s'\n",
6.2170 + current_menu->file->name, current_menu->lineno,
6.2171 + zconf_tokenname(starttoken));
6.2172 + zconfnerrs++;
6.2173 + return false;
6.2174 + }
6.2175 + return true;
6.2176 +}
6.2177 +
6.2178 +static void zconfprint(const char *err, ...)
6.2179 +{
6.2180 + va_list ap;
6.2181 +
6.2182 + fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
6.2183 + va_start(ap, err);
6.2184 + vfprintf(stderr, err, ap);
6.2185 + va_end(ap);
6.2186 + fprintf(stderr, "\n");
6.2187 +}
6.2188 +
6.2189 +static void zconf_error(const char *err, ...)
6.2190 +{
6.2191 + va_list ap;
6.2192 +
6.2193 + zconfnerrs++;
6.2194 + fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
6.2195 + va_start(ap, err);
6.2196 + vfprintf(stderr, err, ap);
6.2197 + va_end(ap);
6.2198 + fprintf(stderr, "\n");
6.2199 +}
6.2200 +
6.2201 +static void zconferror(const char *err)
6.2202 +{
6.2203 +#if YYDEBUG
6.2204 + fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
6.2205 +#endif
6.2206 +}
6.2207 +
6.2208 +void print_quoted_string(FILE *out, const char *str)
6.2209 +{
6.2210 + const char *p;
6.2211 + int len;
6.2212 +
6.2213 + putc('"', out);
6.2214 + while ((p = strchr(str, '"'))) {
6.2215 + len = p - str;
6.2216 + if (len)
6.2217 + fprintf(out, "%.*s", len, str);
6.2218 + fputs("\\\"", out);
6.2219 + str = p + 1;
6.2220 + }
6.2221 + fputs(str, out);
6.2222 + putc('"', out);
6.2223 +}
6.2224 +
6.2225 +void print_symbol(FILE *out, struct menu *menu)
6.2226 +{
6.2227 + struct symbol *sym = menu->sym;
6.2228 + struct property *prop;
6.2229 +
6.2230 + if (sym_is_choice(sym))
6.2231 + fprintf(out, "choice\n");
6.2232 + else
6.2233 + fprintf(out, "config %s\n", sym->name);
6.2234 + switch (sym->type) {
6.2235 + case S_BOOLEAN:
6.2236 + fputs(" boolean\n", out);
6.2237 + break;
6.2238 + case S_TRISTATE:
6.2239 + fputs(" tristate\n", out);
6.2240 + break;
6.2241 + case S_STRING:
6.2242 + fputs(" string\n", out);
6.2243 + break;
6.2244 + case S_INT:
6.2245 + fputs(" integer\n", out);
6.2246 + break;
6.2247 + case S_HEX:
6.2248 + fputs(" hex\n", out);
6.2249 + break;
6.2250 + default:
6.2251 + fputs(" ???\n", out);
6.2252 + break;
6.2253 + }
6.2254 + for (prop = sym->prop; prop; prop = prop->next) {
6.2255 + if (prop->menu != menu)
6.2256 + continue;
6.2257 + switch (prop->type) {
6.2258 + case P_PROMPT:
6.2259 + fputs(" prompt ", out);
6.2260 + print_quoted_string(out, prop->text);
6.2261 + if (!expr_is_yes(prop->visible.expr)) {
6.2262 + fputs(" if ", out);
6.2263 + expr_fprint(prop->visible.expr, out);
6.2264 + }
6.2265 + fputc('\n', out);
6.2266 + break;
6.2267 + case P_DEFAULT:
6.2268 + fputs( " default ", out);
6.2269 + expr_fprint(prop->expr, out);
6.2270 + if (!expr_is_yes(prop->visible.expr)) {
6.2271 + fputs(" if ", out);
6.2272 + expr_fprint(prop->visible.expr, out);
6.2273 + }
6.2274 + fputc('\n', out);
6.2275 + break;
6.2276 + case P_CHOICE:
6.2277 + fputs(" #choice value\n", out);
6.2278 + break;
6.2279 + default:
6.2280 + fprintf(out, " unknown prop %d!\n", prop->type);
6.2281 + break;
6.2282 + }
6.2283 + }
6.2284 + if (sym->help) {
6.2285 + int len = strlen(sym->help);
6.2286 + while (sym->help[--len] == '\n')
6.2287 + sym->help[len] = 0;
6.2288 + fprintf(out, " help\n%s\n", sym->help);
6.2289 + }
6.2290 + fputc('\n', out);
6.2291 +}
6.2292 +
6.2293 +void zconfdump(FILE *out)
6.2294 +{
6.2295 + struct property *prop;
6.2296 + struct symbol *sym;
6.2297 + struct menu *menu;
6.2298 +
6.2299 + menu = rootmenu.list;
6.2300 + while (menu) {
6.2301 + if ((sym = menu->sym))
6.2302 + print_symbol(out, menu);
6.2303 + else if ((prop = menu->prompt)) {
6.2304 + switch (prop->type) {
6.2305 + case P_COMMENT:
6.2306 + fputs("\ncomment ", out);
6.2307 + print_quoted_string(out, prop->text);
6.2308 + fputs("\n", out);
6.2309 + break;
6.2310 + case P_MENU:
6.2311 + fputs("\nmenu ", out);
6.2312 + print_quoted_string(out, prop->text);
6.2313 + fputs("\n", out);
6.2314 + break;
6.2315 + default:
6.2316 + ;
6.2317 + }
6.2318 + if (!expr_is_yes(prop->visible.expr)) {
6.2319 + fputs(" depends ", out);
6.2320 + expr_fprint(prop->visible.expr, out);
6.2321 + fputc('\n', out);
6.2322 + }
6.2323 + fputs("\n", out);
6.2324 + }
6.2325 +
6.2326 + if (menu->list)
6.2327 + menu = menu->list;
6.2328 + else if (menu->next)
6.2329 + menu = menu->next;
6.2330 + else while ((menu = menu->parent)) {
6.2331 + if (menu->prompt && menu->prompt->type == P_MENU)
6.2332 + fputs("\nendmenu\n", out);
6.2333 + if (menu->next) {
6.2334 + menu = menu->next;
6.2335 + break;
6.2336 + }
6.2337 + }
6.2338 + }
6.2339 +}
6.2340 +
6.2341 +#include "lex.zconf.c"
6.2342 +#include "util.c"
6.2343 +#include "confdata.c"
6.2344 +#include "expr.c"
6.2345 +#include "symbol.c"
6.2346 +#include "menu.c"
6.2347 +
6.2348 +
7.1 --- a/kconfig/zconf.tab.c_shipped Sun Sep 28 08:14:33 2008 +0000
7.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
7.3 @@ -1,2345 +0,0 @@
7.4 -/* A Bison parser, made by GNU Bison 2.1. */
7.5 -
7.6 -/* Skeleton parser for Yacc-like parsing with Bison,
7.7 - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
7.8 -
7.9 - This program is free software; you can redistribute it and/or modify
7.10 - it under the terms of the GNU General Public License as published by
7.11 - the Free Software Foundation; either version 2, or (at your option)
7.12 - any later version.
7.13 -
7.14 - This program is distributed in the hope that it will be useful,
7.15 - but WITHOUT ANY WARRANTY; without even the implied warranty of
7.16 - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7.17 - GNU General Public License for more details.
7.18 -
7.19 - You should have received a copy of the GNU General Public License
7.20 - along with this program; if not, write to the Free Software
7.21 - Foundation, Inc., 51 Franklin Street, Fifth Floor,
7.22 - Boston, MA 02110-1301, USA. */
7.23 -
7.24 -/* As a special exception, when this file is copied by Bison into a
7.25 - Bison output file, you may use that output file without restriction.
7.26 - This special exception was added by the Free Software Foundation
7.27 - in version 1.24 of Bison. */
7.28 -
7.29 -/* Written by Richard Stallman by simplifying the original so called
7.30 - ``semantic'' parser. */
7.31 -
7.32 -/* All symbols defined below should begin with yy or YY, to avoid
7.33 - infringing on user name space. This should be done even for local
7.34 - variables, as they might otherwise be expanded by user macros.
7.35 - There are some unavoidable exceptions within include files to
7.36 - define necessary library symbols; they are noted "INFRINGES ON
7.37 - USER NAME SPACE" below. */
7.38 -
7.39 -/* Identify Bison output. */
7.40 -#define YYBISON 1
7.41 -
7.42 -/* Bison version. */
7.43 -#define YYBISON_VERSION "2.1"
7.44 -
7.45 -/* Skeleton name. */
7.46 -#define YYSKELETON_NAME "yacc.c"
7.47 -
7.48 -/* Pure parsers. */
7.49 -#define YYPURE 0
7.50 -
7.51 -/* Using locations. */
7.52 -#define YYLSP_NEEDED 0
7.53 -
7.54 -/* Substitute the variable and function names. */
7.55 -#define yyparse zconfparse
7.56 -#define yylex zconflex
7.57 -#define yyerror zconferror
7.58 -#define yylval zconflval
7.59 -#define yychar zconfchar
7.60 -#define yydebug zconfdebug
7.61 -#define yynerrs zconfnerrs
7.62 -
7.63 -
7.64 -/* Tokens. */
7.65 -#ifndef YYTOKENTYPE
7.66 -# define YYTOKENTYPE
7.67 - /* Put the tokens into the symbol table, so that GDB and other debuggers
7.68 - know about them. */
7.69 - enum yytokentype {
7.70 - T_MAINMENU = 258,
7.71 - T_MENU = 259,
7.72 - T_ENDMENU = 260,
7.73 - T_SOURCE = 261,
7.74 - T_CHOICE = 262,
7.75 - T_ENDCHOICE = 263,
7.76 - T_COMMENT = 264,
7.77 - T_CONFIG = 265,
7.78 - T_MENUCONFIG = 266,
7.79 - T_HELP = 267,
7.80 - T_HELPTEXT = 268,
7.81 - T_IF = 269,
7.82 - T_ENDIF = 270,
7.83 - T_DEPENDS = 271,
7.84 - T_REQUIRES = 272,
7.85 - T_OPTIONAL = 273,
7.86 - T_PROMPT = 274,
7.87 - T_TYPE = 275,
7.88 - T_DEFAULT = 276,
7.89 - T_SELECT = 277,
7.90 - T_RANGE = 278,
7.91 - T_OPTION = 279,
7.92 - T_ON = 280,
7.93 - T_WORD = 281,
7.94 - T_WORD_QUOTE = 282,
7.95 - T_UNEQUAL = 283,
7.96 - T_CLOSE_PAREN = 284,
7.97 - T_OPEN_PAREN = 285,
7.98 - T_EOL = 286,
7.99 - T_OR = 287,
7.100 - T_AND = 288,
7.101 - T_EQUAL = 289,
7.102 - T_NOT = 290
7.103 - };
7.104 -#endif
7.105 -/* Tokens. */
7.106 -#define T_MAINMENU 258
7.107 -#define T_MENU 259
7.108 -#define T_ENDMENU 260
7.109 -#define T_SOURCE 261
7.110 -#define T_CHOICE 262
7.111 -#define T_ENDCHOICE 263
7.112 -#define T_COMMENT 264
7.113 -#define T_CONFIG 265
7.114 -#define T_MENUCONFIG 266
7.115 -#define T_HELP 267
7.116 -#define T_HELPTEXT 268
7.117 -#define T_IF 269
7.118 -#define T_ENDIF 270
7.119 -#define T_DEPENDS 271
7.120 -#define T_REQUIRES 272
7.121 -#define T_OPTIONAL 273
7.122 -#define T_PROMPT 274
7.123 -#define T_TYPE 275
7.124 -#define T_DEFAULT 276
7.125 -#define T_SELECT 277
7.126 -#define T_RANGE 278
7.127 -#define T_OPTION 279
7.128 -#define T_ON 280
7.129 -#define T_WORD 281
7.130 -#define T_WORD_QUOTE 282
7.131 -#define T_UNEQUAL 283
7.132 -#define T_CLOSE_PAREN 284
7.133 -#define T_OPEN_PAREN 285
7.134 -#define T_EOL 286
7.135 -#define T_OR 287
7.136 -#define T_AND 288
7.137 -#define T_EQUAL 289
7.138 -#define T_NOT 290
7.139 -
7.140 -
7.141 -
7.142 -
7.143 -/* Copy the first part of user declarations. */
7.144 -
7.145 -
7.146 -/*
7.147 - * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
7.148 - * Released under the terms of the GNU GPL v2.0.
7.149 - */
7.150 -
7.151 -#include <ctype.h>
7.152 -#include <stdarg.h>
7.153 -#include <stdio.h>
7.154 -#include <stdlib.h>
7.155 -#include <string.h>
7.156 -#include <stdbool.h>
7.157 -
7.158 -#define LKC_DIRECT_LINK
7.159 -#include "lkc.h"
7.160 -
7.161 -#include "zconf.hash.c"
7.162 -
7.163 -#define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
7.164 -
7.165 -#define PRINTD 0x0001
7.166 -#define DEBUG_PARSE 0x0002
7.167 -
7.168 -int cdebug = PRINTD;
7.169 -
7.170 -extern int zconflex(void);
7.171 -static void zconfprint(const char *err, ...);
7.172 -static void zconf_error(const char *err, ...);
7.173 -static void zconferror(const char *err);
7.174 -static bool zconf_endtoken(struct kconf_id *id, int starttoken, int endtoken);
7.175 -
7.176 -struct symbol *symbol_hash[257];
7.177 -
7.178 -static struct menu *current_menu, *current_entry;
7.179 -
7.180 -#define YYDEBUG 0
7.181 -#if YYDEBUG
7.182 -#define YYERROR_VERBOSE
7.183 -#endif
7.184 -
7.185 -
7.186 -/* Enabling traces. */
7.187 -#ifndef YYDEBUG
7.188 -# define YYDEBUG 0
7.189 -#endif
7.190 -
7.191 -/* Enabling verbose error messages. */
7.192 -#ifdef YYERROR_VERBOSE
7.193 -# undef YYERROR_VERBOSE
7.194 -# define YYERROR_VERBOSE 1
7.195 -#else
7.196 -# define YYERROR_VERBOSE 0
7.197 -#endif
7.198 -
7.199 -/* Enabling the token table. */
7.200 -#ifndef YYTOKEN_TABLE
7.201 -# define YYTOKEN_TABLE 0
7.202 -#endif
7.203 -
7.204 -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
7.205 -
7.206 -typedef union YYSTYPE {
7.207 - char *string;
7.208 - struct file *file;
7.209 - struct symbol *symbol;
7.210 - struct expr *expr;
7.211 - struct menu *menu;
7.212 - struct kconf_id *id;
7.213 -} YYSTYPE;
7.214 -/* Line 196 of yacc.c. */
7.215 -
7.216 -# define yystype YYSTYPE /* obsolescent; will be withdrawn */
7.217 -# define YYSTYPE_IS_DECLARED 1
7.218 -# define YYSTYPE_IS_TRIVIAL 1
7.219 -#endif
7.220 -
7.221 -
7.222 -
7.223 -/* Copy the second part of user declarations. */
7.224 -
7.225 -
7.226 -/* Line 219 of yacc.c. */
7.227 -
7.228 -
7.229 -#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
7.230 -# define YYSIZE_T __SIZE_TYPE__
7.231 -#endif
7.232 -#if ! defined (YYSIZE_T) && defined (size_t)
7.233 -# define YYSIZE_T size_t
7.234 -#endif
7.235 -#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
7.236 -# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
7.237 -# define YYSIZE_T size_t
7.238 -#endif
7.239 -#if ! defined (YYSIZE_T)
7.240 -# define YYSIZE_T unsigned int
7.241 -#endif
7.242 -
7.243 -#ifndef YY_
7.244 -# if YYENABLE_NLS
7.245 -# if ENABLE_NLS
7.246 -# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
7.247 -# define YY_(msgid) dgettext ("bison-runtime", msgid)
7.248 -# endif
7.249 -# endif
7.250 -# ifndef YY_
7.251 -# define YY_(msgid) msgid
7.252 -# endif
7.253 -#endif
7.254 -
7.255 -#if ! defined (yyoverflow) || YYERROR_VERBOSE
7.256 -
7.257 -/* The parser invokes alloca or malloc; define the necessary symbols. */
7.258 -
7.259 -# ifdef YYSTACK_USE_ALLOCA
7.260 -# if YYSTACK_USE_ALLOCA
7.261 -# ifdef __GNUC__
7.262 -# define YYSTACK_ALLOC __builtin_alloca
7.263 -# else
7.264 -# define YYSTACK_ALLOC alloca
7.265 -# if defined (__STDC__) || defined (__cplusplus)
7.266 -# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
7.267 -# define YYINCLUDED_STDLIB_H
7.268 -# endif
7.269 -# endif
7.270 -# endif
7.271 -# endif
7.272 -
7.273 -# ifdef YYSTACK_ALLOC
7.274 - /* Pacify GCC's `empty if-body' warning. */
7.275 -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
7.276 -# ifndef YYSTACK_ALLOC_MAXIMUM
7.277 - /* The OS might guarantee only one guard page at the bottom of the stack,
7.278 - and a page size can be as small as 4096 bytes. So we cannot safely
7.279 - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
7.280 - to allow for a few compiler-allocated temporary stack slots. */
7.281 -# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
7.282 -# endif
7.283 -# else
7.284 -# define YYSTACK_ALLOC YYMALLOC
7.285 -# define YYSTACK_FREE YYFREE
7.286 -# ifndef YYSTACK_ALLOC_MAXIMUM
7.287 -# define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
7.288 -# endif
7.289 -# ifdef __cplusplus
7.290 -extern "C" {
7.291 -# endif
7.292 -# ifndef YYMALLOC
7.293 -# define YYMALLOC malloc
7.294 -# if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
7.295 - && (defined (__STDC__) || defined (__cplusplus)))
7.296 -void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
7.297 -# endif
7.298 -# endif
7.299 -# ifndef YYFREE
7.300 -# define YYFREE free
7.301 -# if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
7.302 - && (defined (__STDC__) || defined (__cplusplus)))
7.303 -void free (void *); /* INFRINGES ON USER NAME SPACE */
7.304 -# endif
7.305 -# endif
7.306 -# ifdef __cplusplus
7.307 -}
7.308 -# endif
7.309 -# endif
7.310 -#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
7.311 -
7.312 -
7.313 -#if (! defined (yyoverflow) \
7.314 - && (! defined (__cplusplus) \
7.315 - || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
7.316 -
7.317 -/* A type that is properly aligned for any stack member. */
7.318 -union yyalloc
7.319 -{
7.320 - short int yyss;
7.321 - YYSTYPE yyvs;
7.322 - };
7.323 -
7.324 -/* The size of the maximum gap between one aligned stack and the next. */
7.325 -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
7.326 -
7.327 -/* The size of an array large to enough to hold all stacks, each with
7.328 - N elements. */
7.329 -# define YYSTACK_BYTES(N) \
7.330 - ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
7.331 - + YYSTACK_GAP_MAXIMUM)
7.332 -
7.333 -/* Copy COUNT objects from FROM to TO. The source and destination do
7.334 - not overlap. */
7.335 -# ifndef YYCOPY
7.336 -# if defined (__GNUC__) && 1 < __GNUC__
7.337 -# define YYCOPY(To, From, Count) \
7.338 - __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
7.339 -# else
7.340 -# define YYCOPY(To, From, Count) \
7.341 - do \
7.342 - { \
7.343 - YYSIZE_T yyi; \
7.344 - for (yyi = 0; yyi < (Count); yyi++) \
7.345 - (To)[yyi] = (From)[yyi]; \
7.346 - } \
7.347 - while (0)
7.348 -# endif
7.349 -# endif
7.350 -
7.351 -/* Relocate STACK from its old location to the new one. The
7.352 - local variables YYSIZE and YYSTACKSIZE give the old and new number of
7.353 - elements in the stack, and YYPTR gives the new location of the
7.354 - stack. Advance YYPTR to a properly aligned location for the next
7.355 - stack. */
7.356 -# define YYSTACK_RELOCATE(Stack) \
7.357 - do \
7.358 - { \
7.359 - YYSIZE_T yynewbytes; \
7.360 - YYCOPY (&yyptr->Stack, Stack, yysize); \
7.361 - Stack = &yyptr->Stack; \
7.362 - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
7.363 - yyptr += yynewbytes / sizeof (*yyptr); \
7.364 - } \
7.365 - while (0)
7.366 -
7.367 -#endif
7.368 -
7.369 -#if defined (__STDC__) || defined (__cplusplus)
7.370 - typedef signed char yysigned_char;
7.371 -#else
7.372 - typedef short int yysigned_char;
7.373 -#endif
7.374 -
7.375 -/* YYFINAL -- State number of the termination state. */
7.376 -#define YYFINAL 3
7.377 -/* YYLAST -- Last index in YYTABLE. */
7.378 -#define YYLAST 275
7.379 -
7.380 -/* YYNTOKENS -- Number of terminals. */
7.381 -#define YYNTOKENS 36
7.382 -/* YYNNTS -- Number of nonterminals. */
7.383 -#define YYNNTS 45
7.384 -/* YYNRULES -- Number of rules. */
7.385 -#define YYNRULES 110
7.386 -/* YYNRULES -- Number of states. */
7.387 -#define YYNSTATES 183
7.388 -
7.389 -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
7.390 -#define YYUNDEFTOK 2
7.391 -#define YYMAXUTOK 290
7.392 -
7.393 -#define YYTRANSLATE(YYX) \
7.394 - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
7.395 -
7.396 -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
7.397 -static const unsigned char yytranslate[] =
7.398 -{
7.399 - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.400 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.401 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.402 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.403 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.404 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.405 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.406 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.407 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.408 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.409 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.410 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.411 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.412 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.413 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.414 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.415 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.416 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.417 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.418 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.419 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.420 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.421 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.422 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.423 - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
7.424 - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
7.425 - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
7.426 - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
7.427 - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
7.428 - 35
7.429 -};
7.430 -
7.431 -#if YYDEBUG
7.432 -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
7.433 - YYRHS. */
7.434 -static const unsigned short int yyprhs[] =
7.435 -{
7.436 - 0, 0, 3, 5, 6, 9, 12, 15, 20, 23,
7.437 - 28, 33, 37, 39, 41, 43, 45, 47, 49, 51,
7.438 - 53, 55, 57, 59, 61, 63, 67, 70, 74, 77,
7.439 - 81, 84, 85, 88, 91, 94, 97, 100, 103, 107,
7.440 - 112, 117, 122, 128, 132, 133, 137, 138, 141, 144,
7.441 - 147, 149, 153, 154, 157, 160, 163, 166, 169, 174,
7.442 - 178, 181, 186, 187, 190, 194, 196, 200, 201, 204,
7.443 - 207, 210, 214, 217, 219, 223, 224, 227, 230, 233,
7.444 - 237, 241, 244, 247, 250, 251, 254, 257, 260, 265,
7.445 - 269, 273, 274, 277, 279, 281, 284, 287, 290, 292,
7.446 - 295, 296, 299, 301, 305, 309, 313, 316, 320, 324,
7.447 - 326
7.448 -};
7.449 -
7.450 -/* YYRHS -- A `-1'-separated list of the rules' RHS. */
7.451 -static const yysigned_char yyrhs[] =
7.452 -{
7.453 - 37, 0, -1, 38, -1, -1, 38, 40, -1, 38,
7.454 - 54, -1, 38, 65, -1, 38, 3, 75, 77, -1,
7.455 - 38, 76, -1, 38, 26, 1, 31, -1, 38, 39,
7.456 - 1, 31, -1, 38, 1, 31, -1, 16, -1, 19,
7.457 - -1, 20, -1, 22, -1, 18, -1, 23, -1, 21,
7.458 - -1, 31, -1, 60, -1, 69, -1, 43, -1, 45,
7.459 - -1, 67, -1, 26, 1, 31, -1, 1, 31, -1,
7.460 - 10, 26, 31, -1, 42, 46, -1, 11, 26, 31,
7.461 - -1, 44, 46, -1, -1, 46, 47, -1, 46, 48,
7.462 - -1, 46, 73, -1, 46, 71, -1, 46, 41, -1,
7.463 - 46, 31, -1, 20, 74, 31, -1, 19, 75, 78,
7.464 - 31, -1, 21, 79, 78, 31, -1, 22, 26, 78,
7.465 - 31, -1, 23, 80, 80, 78, 31, -1, 24, 49,
7.466 - 31, -1, -1, 49, 26, 50, -1, -1, 34, 75,
7.467 - -1, 7, 31, -1, 51, 55, -1, 76, -1, 52,
7.468 - 57, 53, -1, -1, 55, 56, -1, 55, 73, -1,
7.469 - 55, 71, -1, 55, 31, -1, 55, 41, -1, 19,
7.470 - 75, 78, 31, -1, 20, 74, 31, -1, 18, 31,
7.471 - -1, 21, 26, 78, 31, -1, -1, 57, 40, -1,
7.472 - 14, 79, 77, -1, 76, -1, 58, 61, 59, -1,
7.473 - -1, 61, 40, -1, 61, 65, -1, 61, 54, -1,
7.474 - 4, 75, 31, -1, 62, 72, -1, 76, -1, 63,
7.475 - 66, 64, -1, -1, 66, 40, -1, 66, 65, -1,
7.476 - 66, 54, -1, 6, 75, 31, -1, 9, 75, 31,
7.477 - -1, 68, 72, -1, 12, 31, -1, 70, 13, -1,
7.478 - -1, 72, 73, -1, 72, 31, -1, 72, 41, -1,
7.479 - 16, 25, 79, 31, -1, 16, 79, 31, -1, 17,
7.480 - 79, 31, -1, -1, 75, 78, -1, 26, -1, 27,
7.481 - -1, 5, 31, -1, 8, 31, -1, 15, 31, -1,
7.482 - 31, -1, 77, 31, -1, -1, 14, 79, -1, 80,
7.483 - -1, 80, 34, 80, -1, 80, 28, 80, -1, 30,
7.484 - 79, 29, -1, 35, 79, -1, 79, 32, 79, -1,
7.485 - 79, 33, 79, -1, 26, -1, 27, -1
7.486 -};
7.487 -
7.488 -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
7.489 -static const unsigned short int yyrline[] =
7.490 -{
7.491 - 0, 105, 105, 107, 109, 110, 111, 112, 113, 114,
7.492 - 115, 119, 123, 123, 123, 123, 123, 123, 123, 127,
7.493 - 128, 129, 130, 131, 132, 136, 137, 143, 151, 157,
7.494 - 165, 175, 177, 178, 179, 180, 181, 182, 185, 193,
7.495 - 199, 209, 215, 221, 224, 226, 237, 238, 243, 252,
7.496 - 257, 265, 268, 270, 271, 272, 273, 274, 277, 283,
7.497 - 294, 300, 310, 312, 317, 325, 333, 336, 338, 339,
7.498 - 340, 345, 352, 357, 365, 368, 370, 371, 372, 375,
7.499 - 383, 390, 397, 403, 410, 412, 413, 414, 417, 422,
7.500 - 427, 435, 437, 442, 443, 446, 447, 448, 452, 453,
7.501 - 456, 457, 460, 461, 462, 463, 464, 465, 466, 469,
7.502 - 470
7.503 -};
7.504 -#endif
7.505 -
7.506 -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
7.507 -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
7.508 - First, the terminals, then, starting at YYNTOKENS, nonterminals. */
7.509 -static const char *const yytname[] =
7.510 -{
7.511 - "$end", "error", "$undefined", "T_MAINMENU", "T_MENU", "T_ENDMENU",
7.512 - "T_SOURCE", "T_CHOICE", "T_ENDCHOICE", "T_COMMENT", "T_CONFIG",
7.513 - "T_MENUCONFIG", "T_HELP", "T_HELPTEXT", "T_IF", "T_ENDIF", "T_DEPENDS",
7.514 - "T_REQUIRES", "T_OPTIONAL", "T_PROMPT", "T_TYPE", "T_DEFAULT",
7.515 - "T_SELECT", "T_RANGE", "T_OPTION", "T_ON", "T_WORD", "T_WORD_QUOTE",
7.516 - "T_UNEQUAL", "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_EOL", "T_OR", "T_AND",
7.517 - "T_EQUAL", "T_NOT", "$accept", "input", "stmt_list", "option_name",
7.518 - "common_stmt", "option_error", "config_entry_start", "config_stmt",
7.519 - "menuconfig_entry_start", "menuconfig_stmt", "config_option_list",
7.520 - "config_option", "symbol_option", "symbol_option_list",
7.521 - "symbol_option_arg", "choice", "choice_entry", "choice_end",
7.522 - "choice_stmt", "choice_option_list", "choice_option", "choice_block",
7.523 - "if_entry", "if_end", "if_stmt", "if_block", "menu", "menu_entry",
7.524 - "menu_end", "menu_stmt", "menu_block", "source_stmt", "comment",
7.525 - "comment_stmt", "help_start", "help", "depends_list", "depends",
7.526 - "prompt_stmt_opt", "prompt", "end", "nl", "if_expr", "expr", "symbol", 0
7.527 -};
7.528 -#endif
7.529 -
7.530 -# ifdef YYPRINT
7.531 -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
7.532 - token YYLEX-NUM. */
7.533 -static const unsigned short int yytoknum[] =
7.534 -{
7.535 - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
7.536 - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
7.537 - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
7.538 - 285, 286, 287, 288, 289, 290
7.539 -};
7.540 -# endif
7.541 -
7.542 -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
7.543 -static const unsigned char yyr1[] =
7.544 -{
7.545 - 0, 36, 37, 38, 38, 38, 38, 38, 38, 38,
7.546 - 38, 38, 39, 39, 39, 39, 39, 39, 39, 40,
7.547 - 40, 40, 40, 40, 40, 41, 41, 42, 43, 44,
7.548 - 45, 46, 46, 46, 46, 46, 46, 46, 47, 47,
7.549 - 47, 47, 47, 48, 49, 49, 50, 50, 51, 52,
7.550 - 53, 54, 55, 55, 55, 55, 55, 55, 56, 56,
7.551 - 56, 56, 57, 57, 58, 59, 60, 61, 61, 61,
7.552 - 61, 62, 63, 64, 65, 66, 66, 66, 66, 67,
7.553 - 68, 69, 70, 71, 72, 72, 72, 72, 73, 73,
7.554 - 73, 74, 74, 75, 75, 76, 76, 76, 77, 77,
7.555 - 78, 78, 79, 79, 79, 79, 79, 79, 79, 80,
7.556 - 80
7.557 -};
7.558 -
7.559 -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
7.560 -static const unsigned char yyr2[] =
7.561 -{
7.562 - 0, 2, 1, 0, 2, 2, 2, 4, 2, 4,
7.563 - 4, 3, 1, 1, 1, 1, 1, 1, 1, 1,
7.564 - 1, 1, 1, 1, 1, 3, 2, 3, 2, 3,
7.565 - 2, 0, 2, 2, 2, 2, 2, 2, 3, 4,
7.566 - 4, 4, 5, 3, 0, 3, 0, 2, 2, 2,
7.567 - 1, 3, 0, 2, 2, 2, 2, 2, 4, 3,
7.568 - 2, 4, 0, 2, 3, 1, 3, 0, 2, 2,
7.569 - 2, 3, 2, 1, 3, 0, 2, 2, 2, 3,
7.570 - 3, 2, 2, 2, 0, 2, 2, 2, 4, 3,
7.571 - 3, 0, 2, 1, 1, 2, 2, 2, 1, 2,
7.572 - 0, 2, 1, 3, 3, 3, 2, 3, 3, 1,
7.573 - 1
7.574 -};
7.575 -
7.576 -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
7.577 - STATE-NUM when YYTABLE doesn't specify something else to do. Zero
7.578 - means the default is an error. */
7.579 -static const unsigned char yydefact[] =
7.580 -{
7.581 - 3, 0, 0, 1, 0, 0, 0, 0, 0, 0,
7.582 - 0, 0, 0, 0, 0, 0, 12, 16, 13, 14,
7.583 - 18, 15, 17, 0, 19, 0, 4, 31, 22, 31,
7.584 - 23, 52, 62, 5, 67, 20, 84, 75, 6, 24,
7.585 - 84, 21, 8, 11, 93, 94, 0, 0, 95, 0,
7.586 - 48, 96, 0, 0, 0, 109, 110, 0, 0, 0,
7.587 - 102, 97, 0, 0, 0, 0, 0, 0, 0, 0,
7.588 - 0, 0, 98, 7, 71, 79, 80, 27, 29, 0,
7.589 - 106, 0, 0, 64, 0, 0, 9, 10, 0, 0,
7.590 - 0, 0, 0, 91, 0, 0, 0, 44, 0, 37,
7.591 - 36, 32, 33, 0, 35, 34, 0, 0, 91, 0,
7.592 - 56, 57, 53, 55, 54, 63, 51, 50, 68, 70,
7.593 - 66, 69, 65, 86, 87, 85, 76, 78, 74, 77,
7.594 - 73, 99, 105, 107, 108, 104, 103, 26, 82, 0,
7.595 - 0, 0, 100, 0, 100, 100, 100, 0, 0, 0,
7.596 - 83, 60, 100, 0, 100, 0, 89, 90, 0, 0,
7.597 - 38, 92, 0, 0, 100, 46, 43, 25, 0, 59,
7.598 - 0, 88, 101, 39, 40, 41, 0, 0, 45, 58,
7.599 - 61, 42, 47
7.600 -};
7.601 -
7.602 -/* YYDEFGOTO[NTERM-NUM]. */
7.603 -static const short int yydefgoto[] =
7.604 -{
7.605 - -1, 1, 2, 25, 26, 100, 27, 28, 29, 30,
7.606 - 64, 101, 102, 148, 178, 31, 32, 116, 33, 66,
7.607 - 112, 67, 34, 120, 35, 68, 36, 37, 128, 38,
7.608 - 70, 39, 40, 41, 103, 104, 69, 105, 143, 144,
7.609 - 42, 73, 159, 59, 60
7.610 -};
7.611 -
7.612 -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
7.613 - STATE-NUM. */
7.614 -#define YYPACT_NINF -135
7.615 -static const short int yypact[] =
7.616 -{
7.617 - -135, 2, 170, -135, -14, 56, 56, -8, 56, 24,
7.618 - 67, 56, 7, 14, 62, 97, -135, -135, -135, -135,
7.619 - -135, -135, -135, 156, -135, 166, -135, -135, -135, -135,
7.620 - -135, -135, -135, -135, -135, -135, -135, -135, -135, -135,
7.621 - -135, -135, -135, -135, -135, -135, 138, 151, -135, 152,
7.622 - -135, -135, 163, 167, 176, -135, -135, 62, 62, 185,
7.623 - -19, -135, 188, 190, 42, 103, 194, 85, 70, 222,
7.624 - 70, 132, -135, 191, -135, -135, -135, -135, -135, 127,
7.625 - -135, 62, 62, 191, 104, 104, -135, -135, 193, 203,
7.626 - 9, 62, 56, 56, 62, 161, 104, -135, 196, -135,
7.627 - -135, -135, -135, 233, -135, -135, 204, 56, 56, 221,
7.628 - -135, -135, -135, -135, -135, -135, -135, -135, -135, -135,
7.629 - -135, -135, -135, -135, -135, -135, -135, -135, -135, -135,
7.630 - -135, -135, -135, 219, -135, -135, -135, -135, -135, 62,
7.631 - 209, 212, 240, 224, 240, -1, 240, 104, 41, 225,
7.632 - -135, -135, 240, 226, 240, 218, -135, -135, 62, 227,
7.633 - -135, -135, 228, 229, 240, 230, -135, -135, 231, -135,
7.634 - 232, -135, 112, -135, -135, -135, 234, 56, -135, -135,
7.635 - -135, -135, -135
7.636 -};
7.637 -
7.638 -/* YYPGOTO[NTERM-NUM]. */
7.639 -static const short int yypgoto[] =
7.640 -{
7.641 - -135, -135, -135, -135, 94, -45, -135, -135, -135, -135,
7.642 - 237, -135, -135, -135, -135, -135, -135, -135, -54, -135,
7.643 - -135, -135, -135, -135, -135, -135, -135, -135, -135, 1,
7.644 - -135, -135, -135, -135, -135, 195, 235, -44, 159, -5,
7.645 - 98, 210, -134, -53, -77
7.646 -};
7.647 -
7.648 -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
7.649 - positive, shift that token. If negative, reduce the rule which
7.650 - number is the opposite. If zero, do what YYDEFACT says.
7.651 - If YYTABLE_NINF, syntax error. */
7.652 -#define YYTABLE_NINF -82
7.653 -static const short int yytable[] =
7.654 -{
7.655 - 46, 47, 3, 49, 79, 80, 52, 135, 136, 84,
7.656 - 161, 162, 163, 158, 119, 85, 127, 43, 168, 147,
7.657 - 170, 111, 114, 48, 124, 125, 124, 125, 133, 134,
7.658 - 176, 81, 82, 53, 139, 55, 56, 140, 141, 57,
7.659 - 54, 145, -28, 88, 58, -28, -28, -28, -28, -28,
7.660 - -28, -28, -28, -28, 89, 50, -28, -28, 90, 91,
7.661 - -28, 92, 93, 94, 95, 96, 97, 165, 98, 121,
7.662 - 164, 129, 166, 99, 6, 7, 8, 9, 10, 11,
7.663 - 12, 13, 44, 45, 14, 15, 155, 142, 55, 56,
7.664 - 7, 8, 57, 10, 11, 12, 13, 58, 51, 14,
7.665 - 15, 24, 152, -30, 88, 172, -30, -30, -30, -30,
7.666 - -30, -30, -30, -30, -30, 89, 24, -30, -30, 90,
7.667 - 91, -30, 92, 93, 94, 95, 96, 97, 61, 98,
7.668 - 55, 56, -81, 88, 99, -81, -81, -81, -81, -81,
7.669 - -81, -81, -81, -81, 81, 82, -81, -81, 90, 91,
7.670 - -81, -81, -81, -81, -81, -81, 132, 62, 98, 81,
7.671 - 82, 115, 118, 123, 126, 117, 122, 63, 130, 72,
7.672 - -2, 4, 182, 5, 6, 7, 8, 9, 10, 11,
7.673 - 12, 13, 74, 75, 14, 15, 16, 146, 17, 18,
7.674 - 19, 20, 21, 22, 76, 88, 23, 149, 77, -49,
7.675 - -49, 24, -49, -49, -49, -49, 89, 78, -49, -49,
7.676 - 90, 91, 106, 107, 108, 109, 72, 81, 82, 86,
7.677 - 98, 87, 131, 88, 137, 110, -72, -72, -72, -72,
7.678 - -72, -72, -72, -72, 138, 151, -72, -72, 90, 91,
7.679 - 156, 81, 82, 157, 81, 82, 150, 154, 98, 171,
7.680 - 81, 82, 82, 123, 158, 160, 167, 169, 173, 174,
7.681 - 175, 113, 179, 180, 177, 181, 65, 153, 0, 83,
7.682 - 0, 0, 0, 0, 0, 71
7.683 -};
7.684 -
7.685 -static const short int yycheck[] =
7.686 -{
7.687 - 5, 6, 0, 8, 57, 58, 11, 84, 85, 28,
7.688 - 144, 145, 146, 14, 68, 34, 70, 31, 152, 96,
7.689 - 154, 66, 66, 31, 69, 69, 71, 71, 81, 82,
7.690 - 164, 32, 33, 26, 25, 26, 27, 90, 91, 30,
7.691 - 26, 94, 0, 1, 35, 3, 4, 5, 6, 7,
7.692 - 8, 9, 10, 11, 12, 31, 14, 15, 16, 17,
7.693 - 18, 19, 20, 21, 22, 23, 24, 26, 26, 68,
7.694 - 147, 70, 31, 31, 4, 5, 6, 7, 8, 9,
7.695 - 10, 11, 26, 27, 14, 15, 139, 92, 26, 27,
7.696 - 5, 6, 30, 8, 9, 10, 11, 35, 31, 14,
7.697 - 15, 31, 107, 0, 1, 158, 3, 4, 5, 6,
7.698 - 7, 8, 9, 10, 11, 12, 31, 14, 15, 16,
7.699 - 17, 18, 19, 20, 21, 22, 23, 24, 31, 26,
7.700 - 26, 27, 0, 1, 31, 3, 4, 5, 6, 7,
7.701 - 8, 9, 10, 11, 32, 33, 14, 15, 16, 17,
7.702 - 18, 19, 20, 21, 22, 23, 29, 1, 26, 32,
7.703 - 33, 67, 68, 31, 70, 67, 68, 1, 70, 31,
7.704 - 0, 1, 177, 3, 4, 5, 6, 7, 8, 9,
7.705 - 10, 11, 31, 31, 14, 15, 16, 26, 18, 19,
7.706 - 20, 21, 22, 23, 31, 1, 26, 1, 31, 5,
7.707 - 6, 31, 8, 9, 10, 11, 12, 31, 14, 15,
7.708 - 16, 17, 18, 19, 20, 21, 31, 32, 33, 31,
7.709 - 26, 31, 31, 1, 31, 31, 4, 5, 6, 7,
7.710 - 8, 9, 10, 11, 31, 31, 14, 15, 16, 17,
7.711 - 31, 32, 33, 31, 32, 33, 13, 26, 26, 31,
7.712 - 32, 33, 33, 31, 14, 31, 31, 31, 31, 31,
7.713 - 31, 66, 31, 31, 34, 31, 29, 108, -1, 59,
7.714 - -1, -1, -1, -1, -1, 40
7.715 -};
7.716 -
7.717 -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
7.718 - symbol of state STATE-NUM. */
7.719 -static const unsigned char yystos[] =
7.720 -{
7.721 - 0, 37, 38, 0, 1, 3, 4, 5, 6, 7,
7.722 - 8, 9, 10, 11, 14, 15, 16, 18, 19, 20,
7.723 - 21, 22, 23, 26, 31, 39, 40, 42, 43, 44,
7.724 - 45, 51, 52, 54, 58, 60, 62, 63, 65, 67,
7.725 - 68, 69, 76, 31, 26, 27, 75, 75, 31, 75,
7.726 - 31, 31, 75, 26, 26, 26, 27, 30, 35, 79,
7.727 - 80, 31, 1, 1, 46, 46, 55, 57, 61, 72,
7.728 - 66, 72, 31, 77, 31, 31, 31, 31, 31, 79,
7.729 - 79, 32, 33, 77, 28, 34, 31, 31, 1, 12,
7.730 - 16, 17, 19, 20, 21, 22, 23, 24, 26, 31,
7.731 - 41, 47, 48, 70, 71, 73, 18, 19, 20, 21,
7.732 - 31, 41, 56, 71, 73, 40, 53, 76, 40, 54,
7.733 - 59, 65, 76, 31, 41, 73, 40, 54, 64, 65,
7.734 - 76, 31, 29, 79, 79, 80, 80, 31, 31, 25,
7.735 - 79, 79, 75, 74, 75, 79, 26, 80, 49, 1,
7.736 - 13, 31, 75, 74, 26, 79, 31, 31, 14, 78,
7.737 - 31, 78, 78, 78, 80, 26, 31, 31, 78, 31,
7.738 - 78, 31, 79, 31, 31, 31, 78, 34, 50, 31,
7.739 - 31, 31, 75
7.740 -};
7.741 -
7.742 -#define yyerrok (yyerrstatus = 0)
7.743 -#define yyclearin (yychar = YYEMPTY)
7.744 -#define YYEMPTY (-2)
7.745 -#define YYEOF 0
7.746 -
7.747 -#define YYACCEPT goto yyacceptlab
7.748 -#define YYABORT goto yyabortlab
7.749 -#define YYERROR goto yyerrorlab
7.750 -
7.751 -
7.752 -/* Like YYERROR except do call yyerror. This remains here temporarily
7.753 - to ease the transition to the new meaning of YYERROR, for GCC.
7.754 - Once GCC version 2 has supplanted version 1, this can go. */
7.755 -
7.756 -#define YYFAIL goto yyerrlab
7.757 -
7.758 -#define YYRECOVERING() (!!yyerrstatus)
7.759 -
7.760 -#define YYBACKUP(Token, Value) \
7.761 -do \
7.762 - if (yychar == YYEMPTY && yylen == 1) \
7.763 - { \
7.764 - yychar = (Token); \
7.765 - yylval = (Value); \
7.766 - yytoken = YYTRANSLATE (yychar); \
7.767 - YYPOPSTACK; \
7.768 - goto yybackup; \
7.769 - } \
7.770 - else \
7.771 - { \
7.772 - yyerror (YY_("syntax error: cannot back up")); \
7.773 - YYERROR; \
7.774 - } \
7.775 -while (0)
7.776 -
7.777 -
7.778 -#define YYTERROR 1
7.779 -#define YYERRCODE 256
7.780 -
7.781 -
7.782 -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
7.783 - If N is 0, then set CURRENT to the empty location which ends
7.784 - the previous symbol: RHS[0] (always defined). */
7.785 -
7.786 -#define YYRHSLOC(Rhs, K) ((Rhs)[K])
7.787 -#ifndef YYLLOC_DEFAULT
7.788 -# define YYLLOC_DEFAULT(Current, Rhs, N) \
7.789 - do \
7.790 - if (N) \
7.791 - { \
7.792 - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
7.793 - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
7.794 - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
7.795 - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
7.796 - } \
7.797 - else \
7.798 - { \
7.799 - (Current).first_line = (Current).last_line = \
7.800 - YYRHSLOC (Rhs, 0).last_line; \
7.801 - (Current).first_column = (Current).last_column = \
7.802 - YYRHSLOC (Rhs, 0).last_column; \
7.803 - } \
7.804 - while (0)
7.805 -#endif
7.806 -
7.807 -
7.808 -/* YY_LOCATION_PRINT -- Print the location on the stream.
7.809 - This macro was not mandated originally: define only if we know
7.810 - we won't break user code: when these are the locations we know. */
7.811 -
7.812 -#ifndef YY_LOCATION_PRINT
7.813 -# if YYLTYPE_IS_TRIVIAL
7.814 -# define YY_LOCATION_PRINT(File, Loc) \
7.815 - fprintf (File, "%d.%d-%d.%d", \
7.816 - (Loc).first_line, (Loc).first_column, \
7.817 - (Loc).last_line, (Loc).last_column)
7.818 -# else
7.819 -# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
7.820 -# endif
7.821 -#endif
7.822 -
7.823 -
7.824 -/* YYLEX -- calling `yylex' with the right arguments. */
7.825 -
7.826 -#ifdef YYLEX_PARAM
7.827 -# define YYLEX yylex (YYLEX_PARAM)
7.828 -#else
7.829 -# define YYLEX yylex ()
7.830 -#endif
7.831 -
7.832 -/* Enable debugging if requested. */
7.833 -#if YYDEBUG
7.834 -
7.835 -# ifndef YYFPRINTF
7.836 -# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
7.837 -# define YYFPRINTF fprintf
7.838 -# endif
7.839 -
7.840 -# define YYDPRINTF(Args) \
7.841 -do { \
7.842 - if (yydebug) \
7.843 - YYFPRINTF Args; \
7.844 -} while (0)
7.845 -
7.846 -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
7.847 -do { \
7.848 - if (yydebug) \
7.849 - { \
7.850 - YYFPRINTF (stderr, "%s ", Title); \
7.851 - yysymprint (stderr, \
7.852 - Type, Value); \
7.853 - YYFPRINTF (stderr, "\n"); \
7.854 - } \
7.855 -} while (0)
7.856 -
7.857 -/*------------------------------------------------------------------.
7.858 -| yy_stack_print -- Print the state stack from its BOTTOM up to its |
7.859 -| TOP (included). |
7.860 -`------------------------------------------------------------------*/
7.861 -
7.862 -#if defined (__STDC__) || defined (__cplusplus)
7.863 -static void
7.864 -yy_stack_print (short int *bottom, short int *top)
7.865 -#else
7.866 -static void
7.867 -yy_stack_print (bottom, top)
7.868 - short int *bottom;
7.869 - short int *top;
7.870 -#endif
7.871 -{
7.872 - YYFPRINTF (stderr, "Stack now");
7.873 - for (/* Nothing. */; bottom <= top; ++bottom)
7.874 - YYFPRINTF (stderr, " %d", *bottom);
7.875 - YYFPRINTF (stderr, "\n");
7.876 -}
7.877 -
7.878 -# define YY_STACK_PRINT(Bottom, Top) \
7.879 -do { \
7.880 - if (yydebug) \
7.881 - yy_stack_print ((Bottom), (Top)); \
7.882 -} while (0)
7.883 -
7.884 -
7.885 -/*------------------------------------------------.
7.886 -| Report that the YYRULE is going to be reduced. |
7.887 -`------------------------------------------------*/
7.888 -
7.889 -#if defined (__STDC__) || defined (__cplusplus)
7.890 -static void
7.891 -yy_reduce_print (int yyrule)
7.892 -#else
7.893 -static void
7.894 -yy_reduce_print (yyrule)
7.895 - int yyrule;
7.896 -#endif
7.897 -{
7.898 - int yyi;
7.899 - unsigned long int yylno = yyrline[yyrule];
7.900 - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
7.901 - yyrule - 1, yylno);
7.902 - /* Print the symbols being reduced, and their result. */
7.903 - for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
7.904 - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
7.905 - YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
7.906 -}
7.907 -
7.908 -# define YY_REDUCE_PRINT(Rule) \
7.909 -do { \
7.910 - if (yydebug) \
7.911 - yy_reduce_print (Rule); \
7.912 -} while (0)
7.913 -
7.914 -/* Nonzero means print parse trace. It is left uninitialized so that
7.915 - multiple parsers can coexist. */
7.916 -int yydebug;
7.917 -#else /* !YYDEBUG */
7.918 -# define YYDPRINTF(Args)
7.919 -# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
7.920 -# define YY_STACK_PRINT(Bottom, Top)
7.921 -# define YY_REDUCE_PRINT(Rule)
7.922 -#endif /* !YYDEBUG */
7.923 -
7.924 -
7.925 -/* YYINITDEPTH -- initial size of the parser's stacks. */
7.926 -#ifndef YYINITDEPTH
7.927 -# define YYINITDEPTH 200
7.928 -#endif
7.929 -
7.930 -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
7.931 - if the built-in stack extension method is used).
7.932 -
7.933 - Do not make this value too large; the results are undefined if
7.934 - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
7.935 - evaluated with infinite-precision integer arithmetic. */
7.936 -
7.937 -#ifndef YYMAXDEPTH
7.938 -# define YYMAXDEPTH 10000
7.939 -#endif
7.940 -
7.941 -
7.942 -
7.943 -#if YYERROR_VERBOSE
7.944 -
7.945 -# ifndef yystrlen
7.946 -# if defined (__GLIBC__) && defined (_STRING_H)
7.947 -# define yystrlen strlen
7.948 -# else
7.949 -/* Return the length of YYSTR. */
7.950 -static YYSIZE_T
7.951 -# if defined (__STDC__) || defined (__cplusplus)
7.952 -yystrlen (const char *yystr)
7.953 -# else
7.954 -yystrlen (yystr)
7.955 - const char *yystr;
7.956 -# endif
7.957 -{
7.958 - const char *yys = yystr;
7.959 -
7.960 - while (*yys++ != '\0')
7.961 - continue;
7.962 -
7.963 - return yys - yystr - 1;
7.964 -}
7.965 -# endif
7.966 -# endif
7.967 -
7.968 -# ifndef yystpcpy
7.969 -# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
7.970 -# define yystpcpy stpcpy
7.971 -# else
7.972 -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
7.973 - YYDEST. */
7.974 -static char *
7.975 -# if defined (__STDC__) || defined (__cplusplus)
7.976 -yystpcpy (char *yydest, const char *yysrc)
7.977 -# else
7.978 -yystpcpy (yydest, yysrc)
7.979 - char *yydest;
7.980 - const char *yysrc;
7.981 -# endif
7.982 -{
7.983 - char *yyd = yydest;
7.984 - const char *yys = yysrc;
7.985 -
7.986 - while ((*yyd++ = *yys++) != '\0')
7.987 - continue;
7.988 -
7.989 - return yyd - 1;
7.990 -}
7.991 -# endif
7.992 -# endif
7.993 -
7.994 -# ifndef yytnamerr
7.995 -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
7.996 - quotes and backslashes, so that it's suitable for yyerror. The
7.997 - heuristic is that double-quoting is unnecessary unless the string
7.998 - contains an apostrophe, a comma, or backslash (other than
7.999 - backslash-backslash). YYSTR is taken from yytname. If YYRES is
7.1000 - null, do not copy; instead, return the length of what the result
7.1001 - would have been. */
7.1002 -static YYSIZE_T
7.1003 -yytnamerr (char *yyres, const char *yystr)
7.1004 -{
7.1005 - if (*yystr == '"')
7.1006 - {
7.1007 - size_t yyn = 0;
7.1008 - char const *yyp = yystr;
7.1009 -
7.1010 - for (;;)
7.1011 - switch (*++yyp)
7.1012 - {
7.1013 - case '\'':
7.1014 - case ',':
7.1015 - goto do_not_strip_quotes;
7.1016 -
7.1017 - case '\\':
7.1018 - if (*++yyp != '\\')
7.1019 - goto do_not_strip_quotes;
7.1020 - /* Fall through. */
7.1021 - default:
7.1022 - if (yyres)
7.1023 - yyres[yyn] = *yyp;
7.1024 - yyn++;
7.1025 - break;
7.1026 -
7.1027 - case '"':
7.1028 - if (yyres)
7.1029 - yyres[yyn] = '\0';
7.1030 - return yyn;
7.1031 - }
7.1032 - do_not_strip_quotes: ;
7.1033 - }
7.1034 -
7.1035 - if (! yyres)
7.1036 - return yystrlen (yystr);
7.1037 -
7.1038 - return yystpcpy (yyres, yystr) - yyres;
7.1039 -}
7.1040 -# endif
7.1041 -
7.1042 -#endif /* YYERROR_VERBOSE */
7.1043 -
7.1044 -
7.1045 -
7.1046 -#if YYDEBUG
7.1047 -/*--------------------------------.
7.1048 -| Print this symbol on YYOUTPUT. |
7.1049 -`--------------------------------*/
7.1050 -
7.1051 -#if defined (__STDC__) || defined (__cplusplus)
7.1052 -static void
7.1053 -yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
7.1054 -#else
7.1055 -static void
7.1056 -yysymprint (yyoutput, yytype, yyvaluep)
7.1057 - FILE *yyoutput;
7.1058 - int yytype;
7.1059 - YYSTYPE *yyvaluep;
7.1060 -#endif
7.1061 -{
7.1062 - /* Pacify ``unused variable'' warnings. */
7.1063 - (void) yyvaluep;
7.1064 -
7.1065 - if (yytype < YYNTOKENS)
7.1066 - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
7.1067 - else
7.1068 - YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
7.1069 -
7.1070 -
7.1071 -# ifdef YYPRINT
7.1072 - if (yytype < YYNTOKENS)
7.1073 - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
7.1074 -# endif
7.1075 - switch (yytype)
7.1076 - {
7.1077 - default:
7.1078 - break;
7.1079 - }
7.1080 - YYFPRINTF (yyoutput, ")");
7.1081 -}
7.1082 -
7.1083 -#endif /* ! YYDEBUG */
7.1084 -/*-----------------------------------------------.
7.1085 -| Release the memory associated to this symbol. |
7.1086 -`-----------------------------------------------*/
7.1087 -
7.1088 -#if defined (__STDC__) || defined (__cplusplus)
7.1089 -static void
7.1090 -yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
7.1091 -#else
7.1092 -static void
7.1093 -yydestruct (yymsg, yytype, yyvaluep)
7.1094 - const char *yymsg;
7.1095 - int yytype;
7.1096 - YYSTYPE *yyvaluep;
7.1097 -#endif
7.1098 -{
7.1099 - /* Pacify ``unused variable'' warnings. */
7.1100 - (void) yyvaluep;
7.1101 -
7.1102 - if (!yymsg)
7.1103 - yymsg = "Deleting";
7.1104 - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
7.1105 -
7.1106 - switch (yytype)
7.1107 - {
7.1108 - case 52: /* "choice_entry" */
7.1109 -
7.1110 - {
7.1111 - fprintf(stderr, "%s:%d: missing end statement for this entry\n",
7.1112 - (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
7.1113 - if (current_menu == (yyvaluep->menu))
7.1114 - menu_end_menu();
7.1115 -};
7.1116 -
7.1117 - break;
7.1118 - case 58: /* "if_entry" */
7.1119 -
7.1120 - {
7.1121 - fprintf(stderr, "%s:%d: missing end statement for this entry\n",
7.1122 - (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
7.1123 - if (current_menu == (yyvaluep->menu))
7.1124 - menu_end_menu();
7.1125 -};
7.1126 -
7.1127 - break;
7.1128 - case 63: /* "menu_entry" */
7.1129 -
7.1130 - {
7.1131 - fprintf(stderr, "%s:%d: missing end statement for this entry\n",
7.1132 - (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
7.1133 - if (current_menu == (yyvaluep->menu))
7.1134 - menu_end_menu();
7.1135 -};
7.1136 -
7.1137 - break;
7.1138 -
7.1139 - default:
7.1140 - break;
7.1141 - }
7.1142 -}
7.1143 -
7.1144 -
7.1145 -/* Prevent warnings from -Wmissing-prototypes. */
7.1146 -
7.1147 -#ifdef YYPARSE_PARAM
7.1148 -# if defined (__STDC__) || defined (__cplusplus)
7.1149 -int yyparse (void *YYPARSE_PARAM);
7.1150 -# else
7.1151 -int yyparse ();
7.1152 -# endif
7.1153 -#else /* ! YYPARSE_PARAM */
7.1154 -#if defined (__STDC__) || defined (__cplusplus)
7.1155 -int yyparse (void);
7.1156 -#else
7.1157 -int yyparse ();
7.1158 -#endif
7.1159 -#endif /* ! YYPARSE_PARAM */
7.1160 -
7.1161 -
7.1162 -
7.1163 -/* The look-ahead symbol. */
7.1164 -int yychar;
7.1165 -
7.1166 -/* The semantic value of the look-ahead symbol. */
7.1167 -YYSTYPE yylval;
7.1168 -
7.1169 -/* Number of syntax errors so far. */
7.1170 -int yynerrs;
7.1171 -
7.1172 -
7.1173 -
7.1174 -/*----------.
7.1175 -| yyparse. |
7.1176 -`----------*/
7.1177 -
7.1178 -#ifdef YYPARSE_PARAM
7.1179 -# if defined (__STDC__) || defined (__cplusplus)
7.1180 -int yyparse (void *YYPARSE_PARAM)
7.1181 -# else
7.1182 -int yyparse (YYPARSE_PARAM)
7.1183 - void *YYPARSE_PARAM;
7.1184 -# endif
7.1185 -#else /* ! YYPARSE_PARAM */
7.1186 -#if defined (__STDC__) || defined (__cplusplus)
7.1187 -int
7.1188 -yyparse (void)
7.1189 -#else
7.1190 -int
7.1191 -yyparse ()
7.1192 - ;
7.1193 -#endif
7.1194 -#endif
7.1195 -{
7.1196 -
7.1197 - int yystate;
7.1198 - int yyn;
7.1199 - int yyresult;
7.1200 - /* Number of tokens to shift before error messages enabled. */
7.1201 - int yyerrstatus;
7.1202 - /* Look-ahead token as an internal (translated) token number. */
7.1203 - int yytoken = 0;
7.1204 -
7.1205 - /* Three stacks and their tools:
7.1206 - `yyss': related to states,
7.1207 - `yyvs': related to semantic values,
7.1208 - `yyls': related to locations.
7.1209 -
7.1210 - Refer to the stacks thru separate pointers, to allow yyoverflow
7.1211 - to reallocate them elsewhere. */
7.1212 -
7.1213 - /* The state stack. */
7.1214 - short int yyssa[YYINITDEPTH];
7.1215 - short int *yyss = yyssa;
7.1216 - short int *yyssp;
7.1217 -
7.1218 - /* The semantic value stack. */
7.1219 - YYSTYPE yyvsa[YYINITDEPTH];
7.1220 - YYSTYPE *yyvs = yyvsa;
7.1221 - YYSTYPE *yyvsp;
7.1222 -
7.1223 -
7.1224 -
7.1225 -#define YYPOPSTACK (yyvsp--, yyssp--)
7.1226 -
7.1227 - YYSIZE_T yystacksize = YYINITDEPTH;
7.1228 -
7.1229 - /* The variables used to return semantic value and location from the
7.1230 - action routines. */
7.1231 - YYSTYPE yyval;
7.1232 -
7.1233 -
7.1234 - /* When reducing, the number of symbols on the RHS of the reduced
7.1235 - rule. */
7.1236 - int yylen;
7.1237 -
7.1238 - YYDPRINTF ((stderr, "Starting parse\n"));
7.1239 -
7.1240 - yystate = 0;
7.1241 - yyerrstatus = 0;
7.1242 - yynerrs = 0;
7.1243 - yychar = YYEMPTY; /* Cause a token to be read. */
7.1244 -
7.1245 - /* Initialize stack pointers.
7.1246 - Waste one element of value and location stack
7.1247 - so that they stay on the same level as the state stack.
7.1248 - The wasted elements are never initialized. */
7.1249 -
7.1250 - yyssp = yyss;
7.1251 - yyvsp = yyvs;
7.1252 -
7.1253 - goto yysetstate;
7.1254 -
7.1255 -/*------------------------------------------------------------.
7.1256 -| yynewstate -- Push a new state, which is found in yystate. |
7.1257 -`------------------------------------------------------------*/
7.1258 - yynewstate:
7.1259 - /* In all cases, when you get here, the value and location stacks
7.1260 - have just been pushed. so pushing a state here evens the stacks.
7.1261 - */
7.1262 - yyssp++;
7.1263 -
7.1264 - yysetstate:
7.1265 - *yyssp = yystate;
7.1266 -
7.1267 - if (yyss + yystacksize - 1 <= yyssp)
7.1268 - {
7.1269 - /* Get the current used size of the three stacks, in elements. */
7.1270 - YYSIZE_T yysize = yyssp - yyss + 1;
7.1271 -
7.1272 -#ifdef yyoverflow
7.1273 - {
7.1274 - /* Give user a chance to reallocate the stack. Use copies of
7.1275 - these so that the &'s don't force the real ones into
7.1276 - memory. */
7.1277 - YYSTYPE *yyvs1 = yyvs;
7.1278 - short int *yyss1 = yyss;
7.1279 -
7.1280 -
7.1281 - /* Each stack pointer address is followed by the size of the
7.1282 - data in use in that stack, in bytes. This used to be a
7.1283 - conditional around just the two extra args, but that might
7.1284 - be undefined if yyoverflow is a macro. */
7.1285 - yyoverflow (YY_("memory exhausted"),
7.1286 - &yyss1, yysize * sizeof (*yyssp),
7.1287 - &yyvs1, yysize * sizeof (*yyvsp),
7.1288 -
7.1289 - &yystacksize);
7.1290 -
7.1291 - yyss = yyss1;
7.1292 - yyvs = yyvs1;
7.1293 - }
7.1294 -#else /* no yyoverflow */
7.1295 -# ifndef YYSTACK_RELOCATE
7.1296 - goto yyexhaustedlab;
7.1297 -# else
7.1298 - /* Extend the stack our own way. */
7.1299 - if (YYMAXDEPTH <= yystacksize)
7.1300 - goto yyexhaustedlab;
7.1301 - yystacksize *= 2;
7.1302 - if (YYMAXDEPTH < yystacksize)
7.1303 - yystacksize = YYMAXDEPTH;
7.1304 -
7.1305 - {
7.1306 - short int *yyss1 = yyss;
7.1307 - union yyalloc *yyptr =
7.1308 - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
7.1309 - if (! yyptr)
7.1310 - goto yyexhaustedlab;
7.1311 - YYSTACK_RELOCATE (yyss);
7.1312 - YYSTACK_RELOCATE (yyvs);
7.1313 -
7.1314 -# undef YYSTACK_RELOCATE
7.1315 - if (yyss1 != yyssa)
7.1316 - YYSTACK_FREE (yyss1);
7.1317 - }
7.1318 -# endif
7.1319 -#endif /* no yyoverflow */
7.1320 -
7.1321 - yyssp = yyss + yysize - 1;
7.1322 - yyvsp = yyvs + yysize - 1;
7.1323 -
7.1324 -
7.1325 - YYDPRINTF ((stderr, "Stack size increased to %lu\n",
7.1326 - (unsigned long int) yystacksize));
7.1327 -
7.1328 - if (yyss + yystacksize - 1 <= yyssp)
7.1329 - YYABORT;
7.1330 - }
7.1331 -
7.1332 - YYDPRINTF ((stderr, "Entering state %d\n", yystate));
7.1333 -
7.1334 - goto yybackup;
7.1335 -
7.1336 -/*-----------.
7.1337 -| yybackup. |
7.1338 -`-----------*/
7.1339 -yybackup:
7.1340 -
7.1341 -/* Do appropriate processing given the current state. */
7.1342 -/* Read a look-ahead token if we need one and don't already have one. */
7.1343 -/* yyresume: */
7.1344 -
7.1345 - /* First try to decide what to do without reference to look-ahead token. */
7.1346 -
7.1347 - yyn = yypact[yystate];
7.1348 - if (yyn == YYPACT_NINF)
7.1349 - goto yydefault;
7.1350 -
7.1351 - /* Not known => get a look-ahead token if don't already have one. */
7.1352 -
7.1353 - /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
7.1354 - if (yychar == YYEMPTY)
7.1355 - {
7.1356 - YYDPRINTF ((stderr, "Reading a token: "));
7.1357 - yychar = YYLEX;
7.1358 - }
7.1359 -
7.1360 - if (yychar <= YYEOF)
7.1361 - {
7.1362 - yychar = yytoken = YYEOF;
7.1363 - YYDPRINTF ((stderr, "Now at end of input.\n"));
7.1364 - }
7.1365 - else
7.1366 - {
7.1367 - yytoken = YYTRANSLATE (yychar);
7.1368 - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
7.1369 - }
7.1370 -
7.1371 - /* If the proper action on seeing token YYTOKEN is to reduce or to
7.1372 - detect an error, take that action. */
7.1373 - yyn += yytoken;
7.1374 - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
7.1375 - goto yydefault;
7.1376 - yyn = yytable[yyn];
7.1377 - if (yyn <= 0)
7.1378 - {
7.1379 - if (yyn == 0 || yyn == YYTABLE_NINF)
7.1380 - goto yyerrlab;
7.1381 - yyn = -yyn;
7.1382 - goto yyreduce;
7.1383 - }
7.1384 -
7.1385 - if (yyn == YYFINAL)
7.1386 - YYACCEPT;
7.1387 -
7.1388 - /* Shift the look-ahead token. */
7.1389 - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
7.1390 -
7.1391 - /* Discard the token being shifted unless it is eof. */
7.1392 - if (yychar != YYEOF)
7.1393 - yychar = YYEMPTY;
7.1394 -
7.1395 - *++yyvsp = yylval;
7.1396 -
7.1397 -
7.1398 - /* Count tokens shifted since error; after three, turn off error
7.1399 - status. */
7.1400 - if (yyerrstatus)
7.1401 - yyerrstatus--;
7.1402 -
7.1403 - yystate = yyn;
7.1404 - goto yynewstate;
7.1405 -
7.1406 -
7.1407 -/*-----------------------------------------------------------.
7.1408 -| yydefault -- do the default action for the current state. |
7.1409 -`-----------------------------------------------------------*/
7.1410 -yydefault:
7.1411 - yyn = yydefact[yystate];
7.1412 - if (yyn == 0)
7.1413 - goto yyerrlab;
7.1414 - goto yyreduce;
7.1415 -
7.1416 -
7.1417 -/*-----------------------------.
7.1418 -| yyreduce -- Do a reduction. |
7.1419 -`-----------------------------*/
7.1420 -yyreduce:
7.1421 - /* yyn is the number of a rule to reduce with. */
7.1422 - yylen = yyr2[yyn];
7.1423 -
7.1424 - /* If YYLEN is nonzero, implement the default value of the action:
7.1425 - `$$ = $1'.
7.1426 -
7.1427 - Otherwise, the following line sets YYVAL to garbage.
7.1428 - This behavior is undocumented and Bison
7.1429 - users should not rely upon it. Assigning to YYVAL
7.1430 - unconditionally makes the parser a bit smaller, and it avoids a
7.1431 - GCC warning that YYVAL may be used uninitialized. */
7.1432 - yyval = yyvsp[1-yylen];
7.1433 -
7.1434 -
7.1435 - YY_REDUCE_PRINT (yyn);
7.1436 - switch (yyn)
7.1437 - {
7.1438 - case 8:
7.1439 -
7.1440 - { zconf_error("unexpected end statement"); ;}
7.1441 - break;
7.1442 -
7.1443 - case 9:
7.1444 -
7.1445 - { zconf_error("unknown statement \"%s\"", (yyvsp[-2].string)); ;}
7.1446 - break;
7.1447 -
7.1448 - case 10:
7.1449 -
7.1450 - {
7.1451 - zconf_error("unexpected option \"%s\"", kconf_id_strings + (yyvsp[-2].id)->name);
7.1452 -;}
7.1453 - break;
7.1454 -
7.1455 - case 11:
7.1456 -
7.1457 - { zconf_error("invalid statement"); ;}
7.1458 - break;
7.1459 -
7.1460 - case 25:
7.1461 -
7.1462 - { zconf_error("unknown option \"%s\"", (yyvsp[-2].string)); ;}
7.1463 - break;
7.1464 -
7.1465 - case 26:
7.1466 -
7.1467 - { zconf_error("invalid option"); ;}
7.1468 - break;
7.1469 -
7.1470 - case 27:
7.1471 -
7.1472 - {
7.1473 - struct symbol *sym = sym_lookup((yyvsp[-1].string), 0);
7.1474 - sym->flags |= SYMBOL_OPTIONAL;
7.1475 - menu_add_entry(sym);
7.1476 - printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
7.1477 -;}
7.1478 - break;
7.1479 -
7.1480 - case 28:
7.1481 -
7.1482 - {
7.1483 - menu_end_entry();
7.1484 - printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
7.1485 -;}
7.1486 - break;
7.1487 -
7.1488 - case 29:
7.1489 -
7.1490 - {
7.1491 - struct symbol *sym = sym_lookup((yyvsp[-1].string), 0);
7.1492 - sym->flags |= SYMBOL_OPTIONAL;
7.1493 - menu_add_entry(sym);
7.1494 - printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
7.1495 -;}
7.1496 - break;
7.1497 -
7.1498 - case 30:
7.1499 -
7.1500 - {
7.1501 - if (current_entry->prompt)
7.1502 - current_entry->prompt->type = P_MENU;
7.1503 - else
7.1504 - zconfprint("warning: menuconfig statement without prompt");
7.1505 - menu_end_entry();
7.1506 - printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
7.1507 -;}
7.1508 - break;
7.1509 -
7.1510 - case 38:
7.1511 -
7.1512 - {
7.1513 - menu_set_type((yyvsp[-2].id)->stype);
7.1514 - printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
7.1515 - zconf_curname(), zconf_lineno(),
7.1516 - (yyvsp[-2].id)->stype);
7.1517 -;}
7.1518 - break;
7.1519 -
7.1520 - case 39:
7.1521 -
7.1522 - {
7.1523 - menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
7.1524 - printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
7.1525 -;}
7.1526 - break;
7.1527 -
7.1528 - case 40:
7.1529 -
7.1530 - {
7.1531 - menu_add_expr(P_DEFAULT, (yyvsp[-2].expr), (yyvsp[-1].expr));
7.1532 - if ((yyvsp[-3].id)->stype != S_UNKNOWN)
7.1533 - menu_set_type((yyvsp[-3].id)->stype);
7.1534 - printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
7.1535 - zconf_curname(), zconf_lineno(),
7.1536 - (yyvsp[-3].id)->stype);
7.1537 -;}
7.1538 - break;
7.1539 -
7.1540 - case 41:
7.1541 -
7.1542 - {
7.1543 - menu_add_symbol(P_SELECT, sym_lookup((yyvsp[-2].string), 0), (yyvsp[-1].expr));
7.1544 - printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
7.1545 -;}
7.1546 - break;
7.1547 -
7.1548 - case 42:
7.1549 -
7.1550 - {
7.1551 - menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[-3].symbol), (yyvsp[-2].symbol)), (yyvsp[-1].expr));
7.1552 - printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
7.1553 -;}
7.1554 - break;
7.1555 -
7.1556 - case 45:
7.1557 -
7.1558 - {
7.1559 - struct kconf_id *id = kconf_id_lookup((yyvsp[-1].string), strlen((yyvsp[-1].string)));
7.1560 - if (id && id->flags & TF_OPTION)
7.1561 - menu_add_option(id->token, (yyvsp[0].string));
7.1562 - else
7.1563 - zconfprint("warning: ignoring unknown option %s", (yyvsp[-1].string));
7.1564 - free((yyvsp[-1].string));
7.1565 -;}
7.1566 - break;
7.1567 -
7.1568 - case 46:
7.1569 -
7.1570 - { (yyval.string) = NULL; ;}
7.1571 - break;
7.1572 -
7.1573 - case 47:
7.1574 -
7.1575 - { (yyval.string) = (yyvsp[0].string); ;}
7.1576 - break;
7.1577 -
7.1578 - case 48:
7.1579 -
7.1580 - {
7.1581 - struct symbol *sym = sym_lookup(NULL, 0);
7.1582 - sym->flags |= SYMBOL_CHOICE;
7.1583 - menu_add_entry(sym);
7.1584 - menu_add_expr(P_CHOICE, NULL, NULL);
7.1585 - printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
7.1586 -;}
7.1587 - break;
7.1588 -
7.1589 - case 49:
7.1590 -
7.1591 - {
7.1592 - (yyval.menu) = menu_add_menu();
7.1593 -;}
7.1594 - break;
7.1595 -
7.1596 - case 50:
7.1597 -
7.1598 - {
7.1599 - if (zconf_endtoken((yyvsp[0].id), T_CHOICE, T_ENDCHOICE)) {
7.1600 - menu_end_menu();
7.1601 - printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
7.1602 - }
7.1603 -;}
7.1604 - break;
7.1605 -
7.1606 - case 58:
7.1607 -
7.1608 - {
7.1609 - menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
7.1610 - printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
7.1611 -;}
7.1612 - break;
7.1613 -
7.1614 - case 59:
7.1615 -
7.1616 - {
7.1617 - if ((yyvsp[-2].id)->stype == S_BOOLEAN || (yyvsp[-2].id)->stype == S_TRISTATE) {
7.1618 - menu_set_type((yyvsp[-2].id)->stype);
7.1619 - printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
7.1620 - zconf_curname(), zconf_lineno(),
7.1621 - (yyvsp[-2].id)->stype);
7.1622 - } else
7.1623 - YYERROR;
7.1624 -;}
7.1625 - break;
7.1626 -
7.1627 - case 60:
7.1628 -
7.1629 - {
7.1630 - current_entry->sym->flags |= SYMBOL_OPTIONAL;
7.1631 - printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
7.1632 -;}
7.1633 - break;
7.1634 -
7.1635 - case 61:
7.1636 -
7.1637 - {
7.1638 - if ((yyvsp[-3].id)->stype == S_UNKNOWN) {
7.1639 - menu_add_symbol(P_DEFAULT, sym_lookup((yyvsp[-2].string), 0), (yyvsp[-1].expr));
7.1640 - printd(DEBUG_PARSE, "%s:%d:default\n",
7.1641 - zconf_curname(), zconf_lineno());
7.1642 - } else
7.1643 - YYERROR;
7.1644 -;}
7.1645 - break;
7.1646 -
7.1647 - case 64:
7.1648 -
7.1649 - {
7.1650 - printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
7.1651 - menu_add_entry(NULL);
7.1652 - menu_add_dep((yyvsp[-1].expr));
7.1653 - (yyval.menu) = menu_add_menu();
7.1654 -;}
7.1655 - break;
7.1656 -
7.1657 - case 65:
7.1658 -
7.1659 - {
7.1660 - if (zconf_endtoken((yyvsp[0].id), T_IF, T_ENDIF)) {
7.1661 - menu_end_menu();
7.1662 - printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
7.1663 - }
7.1664 -;}
7.1665 - break;
7.1666 -
7.1667 - case 71:
7.1668 -
7.1669 - {
7.1670 - menu_add_entry(NULL);
7.1671 - menu_add_prompt(P_MENU, (yyvsp[-1].string), NULL);
7.1672 - printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
7.1673 -;}
7.1674 - break;
7.1675 -
7.1676 - case 72:
7.1677 -
7.1678 - {
7.1679 - (yyval.menu) = menu_add_menu();
7.1680 -;}
7.1681 - break;
7.1682 -
7.1683 - case 73:
7.1684 -
7.1685 - {
7.1686 - if (zconf_endtoken((yyvsp[0].id), T_MENU, T_ENDMENU)) {
7.1687 - menu_end_menu();
7.1688 - printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
7.1689 - }
7.1690 -;}
7.1691 - break;
7.1692 -
7.1693 - case 79:
7.1694 -
7.1695 - {
7.1696 - printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
7.1697 - zconf_nextfile((yyvsp[-1].string));
7.1698 -;}
7.1699 - break;
7.1700 -
7.1701 - case 80:
7.1702 -
7.1703 - {
7.1704 - menu_add_entry(NULL);
7.1705 - menu_add_prompt(P_COMMENT, (yyvsp[-1].string), NULL);
7.1706 - printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
7.1707 -;}
7.1708 - break;
7.1709 -
7.1710 - case 81:
7.1711 -
7.1712 - {
7.1713 - menu_end_entry();
7.1714 -;}
7.1715 - break;
7.1716 -
7.1717 - case 82:
7.1718 -
7.1719 - {
7.1720 - printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
7.1721 - zconf_starthelp();
7.1722 -;}
7.1723 - break;
7.1724 -
7.1725 - case 83:
7.1726 -
7.1727 - {
7.1728 - current_entry->sym->help = (yyvsp[0].string);
7.1729 -;}
7.1730 - break;
7.1731 -
7.1732 - case 88:
7.1733 -
7.1734 - {
7.1735 - menu_add_dep((yyvsp[-1].expr));
7.1736 - printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
7.1737 -;}
7.1738 - break;
7.1739 -
7.1740 - case 89:
7.1741 -
7.1742 - {
7.1743 - menu_add_dep((yyvsp[-1].expr));
7.1744 - printd(DEBUG_PARSE, "%s:%d:depends\n", zconf_curname(), zconf_lineno());
7.1745 -;}
7.1746 - break;
7.1747 -
7.1748 - case 90:
7.1749 -
7.1750 - {
7.1751 - menu_add_dep((yyvsp[-1].expr));
7.1752 - printd(DEBUG_PARSE, "%s:%d:requires\n", zconf_curname(), zconf_lineno());
7.1753 -;}
7.1754 - break;
7.1755 -
7.1756 - case 92:
7.1757 -
7.1758 - {
7.1759 - menu_add_prompt(P_PROMPT, (yyvsp[-1].string), (yyvsp[0].expr));
7.1760 -;}
7.1761 - break;
7.1762 -
7.1763 - case 95:
7.1764 -
7.1765 - { (yyval.id) = (yyvsp[-1].id); ;}
7.1766 - break;
7.1767 -
7.1768 - case 96:
7.1769 -
7.1770 - { (yyval.id) = (yyvsp[-1].id); ;}
7.1771 - break;
7.1772 -
7.1773 - case 97:
7.1774 -
7.1775 - { (yyval.id) = (yyvsp[-1].id); ;}
7.1776 - break;
7.1777 -
7.1778 - case 100:
7.1779 -
7.1780 - { (yyval.expr) = NULL; ;}
7.1781 - break;
7.1782 -
7.1783 - case 101:
7.1784 -
7.1785 - { (yyval.expr) = (yyvsp[0].expr); ;}
7.1786 - break;
7.1787 -
7.1788 - case 102:
7.1789 -
7.1790 - { (yyval.expr) = expr_alloc_symbol((yyvsp[0].symbol)); ;}
7.1791 - break;
7.1792 -
7.1793 - case 103:
7.1794 -
7.1795 - { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); ;}
7.1796 - break;
7.1797 -
7.1798 - case 104:
7.1799 -
7.1800 - { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); ;}
7.1801 - break;
7.1802 -
7.1803 - case 105:
7.1804 -
7.1805 - { (yyval.expr) = (yyvsp[-1].expr); ;}
7.1806 - break;
7.1807 -
7.1808 - case 106:
7.1809 -
7.1810 - { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[0].expr)); ;}
7.1811 - break;
7.1812 -
7.1813 - case 107:
7.1814 -
7.1815 - { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
7.1816 - break;
7.1817 -
7.1818 - case 108:
7.1819 -
7.1820 - { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
7.1821 - break;
7.1822 -
7.1823 - case 109:
7.1824 -
7.1825 - { (yyval.symbol) = sym_lookup((yyvsp[0].string), 0); free((yyvsp[0].string)); ;}
7.1826 - break;
7.1827 -
7.1828 - case 110:
7.1829 -
7.1830 - { (yyval.symbol) = sym_lookup((yyvsp[0].string), 1); free((yyvsp[0].string)); ;}
7.1831 - break;
7.1832 -
7.1833 -
7.1834 - default: break;
7.1835 - }
7.1836 -
7.1837 -/* Line 1126 of yacc.c. */
7.1838 -
7.1839 -
7.1840 - yyvsp -= yylen;
7.1841 - yyssp -= yylen;
7.1842 -
7.1843 -
7.1844 - YY_STACK_PRINT (yyss, yyssp);
7.1845 -
7.1846 - *++yyvsp = yyval;
7.1847 -
7.1848 -
7.1849 - /* Now `shift' the result of the reduction. Determine what state
7.1850 - that goes to, based on the state we popped back to and the rule
7.1851 - number reduced by. */
7.1852 -
7.1853 - yyn = yyr1[yyn];
7.1854 -
7.1855 - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
7.1856 - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
7.1857 - yystate = yytable[yystate];
7.1858 - else
7.1859 - yystate = yydefgoto[yyn - YYNTOKENS];
7.1860 -
7.1861 - goto yynewstate;
7.1862 -
7.1863 -
7.1864 -/*------------------------------------.
7.1865 -| yyerrlab -- here on detecting error |
7.1866 -`------------------------------------*/
7.1867 -yyerrlab:
7.1868 - /* If not already recovering from an error, report this error. */
7.1869 - if (!yyerrstatus)
7.1870 - {
7.1871 - ++yynerrs;
7.1872 -#if YYERROR_VERBOSE
7.1873 - yyn = yypact[yystate];
7.1874 -
7.1875 - if (YYPACT_NINF < yyn && yyn < YYLAST)
7.1876 - {
7.1877 - int yytype = YYTRANSLATE (yychar);
7.1878 - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
7.1879 - YYSIZE_T yysize = yysize0;
7.1880 - YYSIZE_T yysize1;
7.1881 - int yysize_overflow = 0;
7.1882 - char *yymsg = 0;
7.1883 -# define YYERROR_VERBOSE_ARGS_MAXIMUM 5
7.1884 - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
7.1885 - int yyx;
7.1886 -
7.1887 -#if 0
7.1888 - /* This is so xgettext sees the translatable formats that are
7.1889 - constructed on the fly. */
7.1890 - YY_("syntax error, unexpected %s");
7.1891 - YY_("syntax error, unexpected %s, expecting %s");
7.1892 - YY_("syntax error, unexpected %s, expecting %s or %s");
7.1893 - YY_("syntax error, unexpected %s, expecting %s or %s or %s");
7.1894 - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
7.1895 -#endif
7.1896 - char *yyfmt;
7.1897 - char const *yyf;
7.1898 - static char const yyunexpected[] = "syntax error, unexpected %s";
7.1899 - static char const yyexpecting[] = ", expecting %s";
7.1900 - static char const yyor[] = " or %s";
7.1901 - char yyformat[sizeof yyunexpected
7.1902 - + sizeof yyexpecting - 1
7.1903 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
7.1904 - * (sizeof yyor - 1))];
7.1905 - char const *yyprefix = yyexpecting;
7.1906 -
7.1907 - /* Start YYX at -YYN if negative to avoid negative indexes in
7.1908 - YYCHECK. */
7.1909 - int yyxbegin = yyn < 0 ? -yyn : 0;
7.1910 -
7.1911 - /* Stay within bounds of both yycheck and yytname. */
7.1912 - int yychecklim = YYLAST - yyn;
7.1913 - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
7.1914 - int yycount = 1;
7.1915 -
7.1916 - yyarg[0] = yytname[yytype];
7.1917 - yyfmt = yystpcpy (yyformat, yyunexpected);
7.1918 -
7.1919 - for (yyx = yyxbegin; yyx < yyxend; ++yyx)
7.1920 - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
7.1921 - {
7.1922 - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
7.1923 - {
7.1924 - yycount = 1;
7.1925 - yysize = yysize0;
7.1926 - yyformat[sizeof yyunexpected - 1] = '\0';
7.1927 - break;
7.1928 - }
7.1929 - yyarg[yycount++] = yytname[yyx];
7.1930 - yysize1 = yysize + yytnamerr (0, yytname[yyx]);
7.1931 - yysize_overflow |= yysize1 < yysize;
7.1932 - yysize = yysize1;
7.1933 - yyfmt = yystpcpy (yyfmt, yyprefix);
7.1934 - yyprefix = yyor;
7.1935 - }
7.1936 -
7.1937 - yyf = YY_(yyformat);
7.1938 - yysize1 = yysize + yystrlen (yyf);
7.1939 - yysize_overflow |= yysize1 < yysize;
7.1940 - yysize = yysize1;
7.1941 -
7.1942 - if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
7.1943 - yymsg = (char *) YYSTACK_ALLOC (yysize);
7.1944 - if (yymsg)
7.1945 - {
7.1946 - /* Avoid sprintf, as that infringes on the user's name space.
7.1947 - Don't have undefined behavior even if the translation
7.1948 - produced a string with the wrong number of "%s"s. */
7.1949 - char *yyp = yymsg;
7.1950 - int yyi = 0;
7.1951 - while ((*yyp = *yyf))
7.1952 - {
7.1953 - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
7.1954 - {
7.1955 - yyp += yytnamerr (yyp, yyarg[yyi++]);
7.1956 - yyf += 2;
7.1957 - }
7.1958 - else
7.1959 - {
7.1960 - yyp++;
7.1961 - yyf++;
7.1962 - }
7.1963 - }
7.1964 - yyerror (yymsg);
7.1965 - YYSTACK_FREE (yymsg);
7.1966 - }
7.1967 - else
7.1968 - {
7.1969 - yyerror (YY_("syntax error"));
7.1970 - goto yyexhaustedlab;
7.1971 - }
7.1972 - }
7.1973 - else
7.1974 -#endif /* YYERROR_VERBOSE */
7.1975 - yyerror (YY_("syntax error"));
7.1976 - }
7.1977 -
7.1978 -
7.1979 -
7.1980 - if (yyerrstatus == 3)
7.1981 - {
7.1982 - /* If just tried and failed to reuse look-ahead token after an
7.1983 - error, discard it. */
7.1984 -
7.1985 - if (yychar <= YYEOF)
7.1986 - {
7.1987 - /* Return failure if at end of input. */
7.1988 - if (yychar == YYEOF)
7.1989 - YYABORT;
7.1990 - }
7.1991 - else
7.1992 - {
7.1993 - yydestruct ("Error: discarding", yytoken, &yylval);
7.1994 - yychar = YYEMPTY;
7.1995 - }
7.1996 - }
7.1997 -
7.1998 - /* Else will try to reuse look-ahead token after shifting the error
7.1999 - token. */
7.2000 - goto yyerrlab1;
7.2001 -
7.2002 -
7.2003 -/*---------------------------------------------------.
7.2004 -| yyerrorlab -- error raised explicitly by YYERROR. |
7.2005 -`---------------------------------------------------*/
7.2006 -yyerrorlab:
7.2007 -
7.2008 - /* Pacify compilers like GCC when the user code never invokes
7.2009 - YYERROR and the label yyerrorlab therefore never appears in user
7.2010 - code. */
7.2011 - if (0)
7.2012 - goto yyerrorlab;
7.2013 -
7.2014 -yyvsp -= yylen;
7.2015 - yyssp -= yylen;
7.2016 - yystate = *yyssp;
7.2017 - goto yyerrlab1;
7.2018 -
7.2019 -
7.2020 -/*-------------------------------------------------------------.
7.2021 -| yyerrlab1 -- common code for both syntax error and YYERROR. |
7.2022 -`-------------------------------------------------------------*/
7.2023 -yyerrlab1:
7.2024 - yyerrstatus = 3; /* Each real token shifted decrements this. */
7.2025 -
7.2026 - for (;;)
7.2027 - {
7.2028 - yyn = yypact[yystate];
7.2029 - if (yyn != YYPACT_NINF)
7.2030 - {
7.2031 - yyn += YYTERROR;
7.2032 - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
7.2033 - {
7.2034 - yyn = yytable[yyn];
7.2035 - if (0 < yyn)
7.2036 - break;
7.2037 - }
7.2038 - }
7.2039 -
7.2040 - /* Pop the current state because it cannot handle the error token. */
7.2041 - if (yyssp == yyss)
7.2042 - YYABORT;
7.2043 -
7.2044 -
7.2045 - yydestruct ("Error: popping", yystos[yystate], yyvsp);
7.2046 - YYPOPSTACK;
7.2047 - yystate = *yyssp;
7.2048 - YY_STACK_PRINT (yyss, yyssp);
7.2049 - }
7.2050 -
7.2051 - if (yyn == YYFINAL)
7.2052 - YYACCEPT;
7.2053 -
7.2054 - *++yyvsp = yylval;
7.2055 -
7.2056 -
7.2057 - /* Shift the error token. */
7.2058 - YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7.2059 -
7.2060 - yystate = yyn;
7.2061 - goto yynewstate;
7.2062 -
7.2063 -
7.2064 -/*-------------------------------------.
7.2065 -| yyacceptlab -- YYACCEPT comes here. |
7.2066 -`-------------------------------------*/
7.2067 -yyacceptlab:
7.2068 - yyresult = 0;
7.2069 - goto yyreturn;
7.2070 -
7.2071 -/*-----------------------------------.
7.2072 -| yyabortlab -- YYABORT comes here. |
7.2073 -`-----------------------------------*/
7.2074 -yyabortlab:
7.2075 - yyresult = 1;
7.2076 - goto yyreturn;
7.2077 -
7.2078 -#ifndef yyoverflow
7.2079 -/*-------------------------------------------------.
7.2080 -| yyexhaustedlab -- memory exhaustion comes here. |
7.2081 -`-------------------------------------------------*/
7.2082 -yyexhaustedlab:
7.2083 - yyerror (YY_("memory exhausted"));
7.2084 - yyresult = 2;
7.2085 - /* Fall through. */
7.2086 -#endif
7.2087 -
7.2088 -yyreturn:
7.2089 - if (yychar != YYEOF && yychar != YYEMPTY)
7.2090 - yydestruct ("Cleanup: discarding lookahead",
7.2091 - yytoken, &yylval);
7.2092 - while (yyssp != yyss)
7.2093 - {
7.2094 - yydestruct ("Cleanup: popping",
7.2095 - yystos[*yyssp], yyvsp);
7.2096 - YYPOPSTACK;
7.2097 - }
7.2098 -#ifndef yyoverflow
7.2099 - if (yyss != yyssa)
7.2100 - YYSTACK_FREE (yyss);
7.2101 -#endif
7.2102 - return yyresult;
7.2103 -}
7.2104 -
7.2105 -
7.2106 -
7.2107 -
7.2108 -
7.2109 -void conf_parse(const char *name)
7.2110 -{
7.2111 - struct symbol *sym;
7.2112 - int i;
7.2113 -
7.2114 - zconf_initscan(name);
7.2115 -
7.2116 - sym_init();
7.2117 - menu_init();
7.2118 - modules_sym = sym_lookup(NULL, 0);
7.2119 - modules_sym->type = S_BOOLEAN;
7.2120 - modules_sym->flags |= SYMBOL_AUTO;
7.2121 - rootmenu.prompt = menu_add_prompt(P_MENU, PROJECT_NAME" Configuration", NULL);
7.2122 -
7.2123 -#if YYDEBUG
7.2124 - if (getenv("ZCONF_DEBUG"))
7.2125 - zconfdebug = 1;
7.2126 -#endif
7.2127 - zconfparse();
7.2128 - if (zconfnerrs)
7.2129 - exit(1);
7.2130 - if (!modules_sym->prop) {
7.2131 - struct property *prop;
7.2132 -
7.2133 - prop = prop_alloc(P_DEFAULT, modules_sym);
7.2134 - prop->expr = expr_alloc_symbol(sym_lookup("MODULES", 0));
7.2135 - }
7.2136 - menu_finalize(&rootmenu);
7.2137 - for_all_symbols(i, sym) {
7.2138 - sym_check_deps(sym);
7.2139 - }
7.2140 -
7.2141 - sym_set_change_count(1);
7.2142 -}
7.2143 -
7.2144 -const char *zconf_tokenname(int token)
7.2145 -{
7.2146 - switch (token) {
7.2147 - case T_MENU: return "menu";
7.2148 - case T_ENDMENU: return "endmenu";
7.2149 - case T_CHOICE: return "choice";
7.2150 - case T_ENDCHOICE: return "endchoice";
7.2151 - case T_IF: return "if";
7.2152 - case T_ENDIF: return "endif";
7.2153 - case T_DEPENDS: return "depends";
7.2154 - }
7.2155 - return "<token>";
7.2156 -}
7.2157 -
7.2158 -static bool zconf_endtoken(struct kconf_id *id, int starttoken, int endtoken)
7.2159 -{
7.2160 - if (id->token != endtoken) {
7.2161 - zconf_error("unexpected '%s' within %s block",
7.2162 - kconf_id_strings + id->name, zconf_tokenname(starttoken));
7.2163 - zconfnerrs++;
7.2164 - return false;
7.2165 - }
7.2166 - if (current_menu->file != current_file) {
7.2167 - zconf_error("'%s' in different file than '%s'",
7.2168 - kconf_id_strings + id->name, zconf_tokenname(starttoken));
7.2169 - fprintf(stderr, "%s:%d: location of the '%s'\n",
7.2170 - current_menu->file->name, current_menu->lineno,
7.2171 - zconf_tokenname(starttoken));
7.2172 - zconfnerrs++;
7.2173 - return false;
7.2174 - }
7.2175 - return true;
7.2176 -}
7.2177 -
7.2178 -static void zconfprint(const char *err, ...)
7.2179 -{
7.2180 - va_list ap;
7.2181 -
7.2182 - fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
7.2183 - va_start(ap, err);
7.2184 - vfprintf(stderr, err, ap);
7.2185 - va_end(ap);
7.2186 - fprintf(stderr, "\n");
7.2187 -}
7.2188 -
7.2189 -static void zconf_error(const char *err, ...)
7.2190 -{
7.2191 - va_list ap;
7.2192 -
7.2193 - zconfnerrs++;
7.2194 - fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
7.2195 - va_start(ap, err);
7.2196 - vfprintf(stderr, err, ap);
7.2197 - va_end(ap);
7.2198 - fprintf(stderr, "\n");
7.2199 -}
7.2200 -
7.2201 -static void zconferror(const char *err)
7.2202 -{
7.2203 -#if YYDEBUG
7.2204 - fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
7.2205 -#endif
7.2206 -}
7.2207 -
7.2208 -void print_quoted_string(FILE *out, const char *str)
7.2209 -{
7.2210 - const char *p;
7.2211 - int len;
7.2212 -
7.2213 - putc('"', out);
7.2214 - while ((p = strchr(str, '"'))) {
7.2215 - len = p - str;
7.2216 - if (len)
7.2217 - fprintf(out, "%.*s", len, str);
7.2218 - fputs("\\\"", out);
7.2219 - str = p + 1;
7.2220 - }
7.2221 - fputs(str, out);
7.2222 - putc('"', out);
7.2223 -}
7.2224 -
7.2225 -void print_symbol(FILE *out, struct menu *menu)
7.2226 -{
7.2227 - struct symbol *sym = menu->sym;
7.2228 - struct property *prop;
7.2229 -
7.2230 - if (sym_is_choice(sym))
7.2231 - fprintf(out, "choice\n");
7.2232 - else
7.2233 - fprintf(out, "config %s\n", sym->name);
7.2234 - switch (sym->type) {
7.2235 - case S_BOOLEAN:
7.2236 - fputs(" boolean\n", out);
7.2237 - break;
7.2238 - case S_TRISTATE:
7.2239 - fputs(" tristate\n", out);
7.2240 - break;
7.2241 - case S_STRING:
7.2242 - fputs(" string\n", out);
7.2243 - break;
7.2244 - case S_INT:
7.2245 - fputs(" integer\n", out);
7.2246 - break;
7.2247 - case S_HEX:
7.2248 - fputs(" hex\n", out);
7.2249 - break;
7.2250 - default:
7.2251 - fputs(" ???\n", out);
7.2252 - break;
7.2253 - }
7.2254 - for (prop = sym->prop; prop; prop = prop->next) {
7.2255 - if (prop->menu != menu)
7.2256 - continue;
7.2257 - switch (prop->type) {
7.2258 - case P_PROMPT:
7.2259 - fputs(" prompt ", out);
7.2260 - print_quoted_string(out, prop->text);
7.2261 - if (!expr_is_yes(prop->visible.expr)) {
7.2262 - fputs(" if ", out);
7.2263 - expr_fprint(prop->visible.expr, out);
7.2264 - }
7.2265 - fputc('\n', out);
7.2266 - break;
7.2267 - case P_DEFAULT:
7.2268 - fputs( " default ", out);
7.2269 - expr_fprint(prop->expr, out);
7.2270 - if (!expr_is_yes(prop->visible.expr)) {
7.2271 - fputs(" if ", out);
7.2272 - expr_fprint(prop->visible.expr, out);
7.2273 - }
7.2274 - fputc('\n', out);
7.2275 - break;
7.2276 - case P_CHOICE:
7.2277 - fputs(" #choice value\n", out);
7.2278 - break;
7.2279 - default:
7.2280 - fprintf(out, " unknown prop %d!\n", prop->type);
7.2281 - break;
7.2282 - }
7.2283 - }
7.2284 - if (sym->help) {
7.2285 - int len = strlen(sym->help);
7.2286 - while (sym->help[--len] == '\n')
7.2287 - sym->help[len] = 0;
7.2288 - fprintf(out, " help\n%s\n", sym->help);
7.2289 - }
7.2290 - fputc('\n', out);
7.2291 -}
7.2292 -
7.2293 -void zconfdump(FILE *out)
7.2294 -{
7.2295 - struct property *prop;
7.2296 - struct symbol *sym;
7.2297 - struct menu *menu;
7.2298 -
7.2299 - menu = rootmenu.list;
7.2300 - while (menu) {
7.2301 - if ((sym = menu->sym))
7.2302 - print_symbol(out, menu);
7.2303 - else if ((prop = menu->prompt)) {
7.2304 - switch (prop->type) {
7.2305 - case P_COMMENT:
7.2306 - fputs("\ncomment ", out);
7.2307 - print_quoted_string(out, prop->text);
7.2308 - fputs("\n", out);
7.2309 - break;
7.2310 - case P_MENU:
7.2311 - fputs("\nmenu ", out);
7.2312 - print_quoted_string(out, prop->text);
7.2313 - fputs("\n", out);
7.2314 - break;
7.2315 - default:
7.2316 - ;
7.2317 - }
7.2318 - if (!expr_is_yes(prop->visible.expr)) {
7.2319 - fputs(" depends ", out);
7.2320 - expr_fprint(prop->visible.expr, out);
7.2321 - fputc('\n', out);
7.2322 - }
7.2323 - fputs("\n", out);
7.2324 - }
7.2325 -
7.2326 - if (menu->list)
7.2327 - menu = menu->list;
7.2328 - else if (menu->next)
7.2329 - menu = menu->next;
7.2330 - else while ((menu = menu->parent)) {
7.2331 - if (menu->prompt && menu->prompt->type == P_MENU)
7.2332 - fputs("\nendmenu\n", out);
7.2333 - if (menu->next) {
7.2334 - menu = menu->next;
7.2335 - break;
7.2336 - }
7.2337 - }
7.2338 - }
7.2339 -}
7.2340 -
7.2341 -#include "lex.zconf.c"
7.2342 -#include "util.c"
7.2343 -#include "confdata.c"
7.2344 -#include "expr.c"
7.2345 -#include "symbol.c"
7.2346 -#include "menu.c"
7.2347 -
7.2348 -