projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
build: add new menuconfig code based on linux 3.9
[openwrt/openwrt.git] / scripts / config / zconf.tab.c_shipped
1 /* A Bison parser, made by GNU Bison 2.3. */
2
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
22
23 /* As a special exception, you may create a larger work that contains
24 part or all of the Bison parser skeleton and distribute that work
25 under terms of your choice, so long as that work isn't itself a
26 parser generator using the skeleton or a modified version thereof
27 as a parser skeleton. Alternatively, if you modify or redistribute
28 the parser skeleton itself, you may (at your option) remove this
29 special exception, which will cause the skeleton and the resulting
30 Bison output files to be licensed under the GNU General Public
31 License without this special exception.
32
33 This special exception was added by the Free Software Foundation in
34 version 2.2 of Bison. */
35
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37 simplifying the original so-called "semantic" parser. */
38
39 /* All symbols defined below should begin with yy or YY, to avoid
40 infringing on user name space. This should be done even for local
41 variables, as they might otherwise be expanded by user macros.
42 There are some unavoidable exceptions within include files to
43 define necessary library symbols; they are noted "INFRINGES ON
44 USER NAME SPACE" below. */
45
46 /* Identify Bison output. */
47 #define YYBISON 1
48
49 /* Bison version. */
50 #define YYBISON_VERSION "2.3"
51
52 /* Skeleton name. */
53 #define YYSKELETON_NAME "yacc.c"
54
55 /* Pure parsers. */
56 #define YYPURE 0
57
58 /* Using locations. */
59 #define YYLSP_NEEDED 0
60
61 /* Substitute the variable and function names. */
62 #define yyparse zconfparse
63 #define yylex zconflex
64 #define yyerror zconferror
65 #define yylval zconflval
66 #define yychar zconfchar
67 #define yydebug zconfdebug
68 #define yynerrs zconfnerrs
69
70
71 /* Tokens. */
72 #ifndef YYTOKENTYPE
73 # define YYTOKENTYPE
74 /* Put the tokens into the symbol table, so that GDB and other debuggers
75 know about them. */
76 enum yytokentype {
77 T_MAINMENU = 258,
78 T_MENU = 259,
79 T_ENDMENU = 260,
80 T_SOURCE = 261,
81 T_CHOICE = 262,
82 T_ENDCHOICE = 263,
83 T_COMMENT = 264,
84 T_CONFIG = 265,
85 T_MENUCONFIG = 266,
86 T_HELP = 267,
87 T_HELPTEXT = 268,
88 T_IF = 269,
89 T_ENDIF = 270,
90 T_DEPENDS = 271,
91 T_OPTIONAL = 272,
92 T_PROMPT = 273,
93 T_TYPE = 274,
94 T_DEFAULT = 275,
95 T_SELECT = 276,
96 T_RANGE = 277,
97 T_VISIBLE = 278,
98 T_OPTION = 279,
99 T_ON = 280,
100 T_RESET = 281,
101 T_WORD = 282,
102 T_WORD_QUOTE = 283,
103 T_UNEQUAL = 284,
104 T_CLOSE_PAREN = 285,
105 T_OPEN_PAREN = 286,
106 T_EOL = 287,
107 T_OR = 288,
108 T_AND = 289,
109 T_EQUAL = 290,
110 T_NOT = 291
111 };
112 #endif
113 /* Tokens. */
114 #define T_MAINMENU 258
115 #define T_MENU 259
116 #define T_ENDMENU 260
117 #define T_SOURCE 261
118 #define T_CHOICE 262
119 #define T_ENDCHOICE 263
120 #define T_COMMENT 264
121 #define T_CONFIG 265
122 #define T_MENUCONFIG 266
123 #define T_HELP 267
124 #define T_HELPTEXT 268
125 #define T_IF 269
126 #define T_ENDIF 270
127 #define T_DEPENDS 271
128 #define T_OPTIONAL 272
129 #define T_PROMPT 273
130 #define T_TYPE 274
131 #define T_DEFAULT 275
132 #define T_SELECT 276
133 #define T_RANGE 277
134 #define T_VISIBLE 278
135 #define T_OPTION 279
136 #define T_ON 280
137 #define T_RESET 281
138 #define T_WORD 282
139 #define T_WORD_QUOTE 283
140 #define T_UNEQUAL 284
141 #define T_CLOSE_PAREN 285
142 #define T_OPEN_PAREN 286
143 #define T_EOL 287
144 #define T_OR 288
145 #define T_AND 289
146 #define T_EQUAL 290
147 #define T_NOT 291
148
149
150
151
152 /* Copy the first part of user declarations. */
153
154
155 /*
156 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
157 * Released under the terms of the GNU GPL v2.0.
158 */
159
160 #include <ctype.h>
161 #include <stdarg.h>
162 #include <stdio.h>
163 #include <stdlib.h>
164 #include <string.h>
165 #include <stdbool.h>
166
167 #include "lkc.h"
168
169 #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
170
171 #define PRINTD 0x0001
172 #define DEBUG_PARSE 0x0002
173
174 int cdebug = PRINTD;
175
176 extern int zconflex(void);
177 static void zconfprint(const char *err, ...);
178 static void zconf_error(const char *err, ...);
179 static void zconferror(const char *err);
180 static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken);
181
182 struct symbol *symbol_hash[SYMBOL_HASHSIZE];
183
184 static struct menu *current_menu, *current_entry;
185
186
187
188 /* Enabling traces. */
189 #ifndef YYDEBUG
190 # define YYDEBUG 0
191 #endif
192
193 /* Enabling verbose error messages. */
194 #ifdef YYERROR_VERBOSE
195 # undef YYERROR_VERBOSE
196 # define YYERROR_VERBOSE 1
197 #else
198 # define YYERROR_VERBOSE 0
199 #endif
200
201 /* Enabling the token table. */
202 #ifndef YYTOKEN_TABLE
203 # define YYTOKEN_TABLE 0
204 #endif
205
206 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
207 typedef union YYSTYPE
208
209 {
210 char *string;
211 struct file *file;
212 struct symbol *symbol;
213 struct expr *expr;
214 struct menu *menu;
215 const struct kconf_id *id;
216 }
217 /* Line 193 of yacc.c. */
218
219 YYSTYPE;
220 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
221 # define YYSTYPE_IS_DECLARED 1
222 # define YYSTYPE_IS_TRIVIAL 1
223 #endif
224
225
226
227 /* Copy the second part of user declarations. */
228
229
230 /* Include zconf.hash.c here so it can see the token constants. */
231 #include "zconf.hash.c"
232
233
234 /* Line 216 of yacc.c. */
235
236
237 #ifdef short
238 # undef short
239 #endif
240
241 #ifdef YYTYPE_UINT8
242 typedef YYTYPE_UINT8 yytype_uint8;
243 #else
244 typedef unsigned char yytype_uint8;
245 #endif
246
247 #ifdef YYTYPE_INT8
248 typedef YYTYPE_INT8 yytype_int8;
249 #elif (defined __STDC__ || defined __C99__FUNC__ \
250 || defined __cplusplus || defined _MSC_VER)
251 typedef signed char yytype_int8;
252 #else
253 typedef short int yytype_int8;
254 #endif
255
256 #ifdef YYTYPE_UINT16
257 typedef YYTYPE_UINT16 yytype_uint16;
258 #else
259 typedef unsigned short int yytype_uint16;
260 #endif
261
262 #ifdef YYTYPE_INT16
263 typedef YYTYPE_INT16 yytype_int16;
264 #else
265 typedef short int yytype_int16;
266 #endif
267
268 #ifndef YYSIZE_T
269 # ifdef __SIZE_TYPE__
270 # define YYSIZE_T __SIZE_TYPE__
271 # elif defined size_t
272 # define YYSIZE_T size_t
273 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
274 || defined __cplusplus || defined _MSC_VER)
275 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
276 # define YYSIZE_T size_t
277 # else
278 # define YYSIZE_T unsigned int
279 # endif
280 #endif
281
282 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
283
284 #ifndef YY_
285 # if defined YYENABLE_NLS && YYENABLE_NLS
286 # if ENABLE_NLS
287 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
288 # define YY_(msgid) dgettext ("bison-runtime", msgid)
289 # endif
290 # endif
291 # ifndef YY_
292 # define YY_(msgid) msgid
293 # endif
294 #endif
295
296 /* Suppress unused-variable warnings by "using" E. */
297 #if ! defined lint || defined __GNUC__
298 # define YYUSE(e) ((void) (e))
299 #else
300 # define YYUSE(e) /* empty */
301 #endif
302
303 /* Identity function, used to suppress warnings about constant conditions. */
304 #ifndef lint
305 # define YYID(n) (n)
306 #else
307 #if (defined __STDC__ || defined __C99__FUNC__ \
308 || defined __cplusplus || defined _MSC_VER)
309 static int
310 YYID (int i)
311 #else
312 static int
313 YYID (i)
314 int i;
315 #endif
316 {
317 return i;
318 }
319 #endif
320
321 #if ! defined yyoverflow || YYERROR_VERBOSE
322
323 /* The parser invokes alloca or malloc; define the necessary symbols. */
324
325 # ifdef YYSTACK_USE_ALLOCA
326 # if YYSTACK_USE_ALLOCA
327 # ifdef __GNUC__
328 # define YYSTACK_ALLOC __builtin_alloca
329 # elif defined __BUILTIN_VA_ARG_INCR
330 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
331 # elif defined _AIX
332 # define YYSTACK_ALLOC __alloca
333 # elif defined _MSC_VER
334 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
335 # define alloca _alloca
336 # else
337 # define YYSTACK_ALLOC alloca
338 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
339 || defined __cplusplus || defined _MSC_VER)
340 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
341 # ifndef _STDLIB_H
342 # define _STDLIB_H 1
343 # endif
344 # endif
345 # endif
346 # endif
347 # endif
348
349 # ifdef YYSTACK_ALLOC
350 /* Pacify GCC's `empty if-body' warning. */
351 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
352 # ifndef YYSTACK_ALLOC_MAXIMUM
353 /* The OS might guarantee only one guard page at the bottom of the stack,
354 and a page size can be as small as 4096 bytes. So we cannot safely
355 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
356 to allow for a few compiler-allocated temporary stack slots. */
357 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
358 # endif
359 # else
360 # define YYSTACK_ALLOC YYMALLOC
361 # define YYSTACK_FREE YYFREE
362 # ifndef YYSTACK_ALLOC_MAXIMUM
363 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
364 # endif
365 # if (defined __cplusplus && ! defined _STDLIB_H \
366 && ! ((defined YYMALLOC || defined malloc) \
367 && (defined YYFREE || defined free)))
368 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
369 # ifndef _STDLIB_H
370 # define _STDLIB_H 1
371 # endif
372 # endif
373 # ifndef YYMALLOC
374 # define YYMALLOC malloc
375 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
376 || defined __cplusplus || defined _MSC_VER)
377 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
378 # endif
379 # endif
380 # ifndef YYFREE
381 # define YYFREE free
382 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
383 || defined __cplusplus || defined _MSC_VER)
384 void free (void *); /* INFRINGES ON USER NAME SPACE */
385 # endif
386 # endif
387 # endif
388 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
389
390
391 #if (! defined yyoverflow \
392 && (! defined __cplusplus \
393 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
394
395 /* A type that is properly aligned for any stack member. */
396 union yyalloc
397 {
398 yytype_int16 yyss;
399 YYSTYPE yyvs;
400 };
401
402 /* The size of the maximum gap between one aligned stack and the next. */
403 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
404
405 /* The size of an array large to enough to hold all stacks, each with
406 N elements. */
407 # define YYSTACK_BYTES(N) \
408 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
409 + YYSTACK_GAP_MAXIMUM)
410
411 /* Copy COUNT objects from FROM to TO. The source and destination do
412 not overlap. */
413 # ifndef YYCOPY
414 # if defined __GNUC__ && 1 < __GNUC__
415 # define YYCOPY(To, From, Count) \
416 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
417 # else
418 # define YYCOPY(To, From, Count) \
419 do \
420 { \
421 YYSIZE_T yyi; \
422 for (yyi = 0; yyi < (Count); yyi++) \
423 (To)[yyi] = (From)[yyi]; \
424 } \
425 while (YYID (0))
426 # endif
427 # endif
428
429 /* Relocate STACK from its old location to the new one. The
430 local variables YYSIZE and YYSTACKSIZE give the old and new number of
431 elements in the stack, and YYPTR gives the new location of the
432 stack. Advance YYPTR to a properly aligned location for the next
433 stack. */
434 # define YYSTACK_RELOCATE(Stack) \
435 do \
436 { \
437 YYSIZE_T yynewbytes; \
438 YYCOPY (&yyptr->Stack, Stack, yysize); \
439 Stack = &yyptr->Stack; \
440 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
441 yyptr += yynewbytes / sizeof (*yyptr); \
442 } \
443 while (YYID (0))
444
445 #endif
446
447 /* YYFINAL -- State number of the termination state. */
448 #define YYFINAL 11
449 /* YYLAST -- Last index in YYTABLE. */
450 #define YYLAST 295
451
452 /* YYNTOKENS -- Number of terminals. */
453 #define YYNTOKENS 37
454 /* YYNNTS -- Number of nonterminals. */
455 #define YYNNTS 50
456 /* YYNRULES -- Number of rules. */
457 #define YYNRULES 120
458 /* YYNRULES -- Number of states. */
459 #define YYNSTATES 195
460
461 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
462 #define YYUNDEFTOK 2
463 #define YYMAXUTOK 291
464
465 #define YYTRANSLATE(YYX) \
466 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
467
468 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
469 static const yytype_uint8 yytranslate[] =
470 {
471 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
472 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
473 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
474 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
475 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
476 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
477 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
480 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
481 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
496 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
497 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
498 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
499 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
500 35, 36
501 };
502
503 #if YYDEBUG
504 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
505 YYRHS. */
506 static const yytype_uint16 yyprhs[] =
507 {
508 0, 0, 3, 6, 8, 11, 13, 14, 17, 20,
509 23, 26, 31, 36, 40, 42, 44, 46, 48, 50,
510 52, 54, 56, 58, 60, 62, 64, 66, 68, 70,
511 74, 77, 81, 84, 88, 91, 92, 95, 98, 101,
512 104, 107, 110, 114, 119, 124, 129, 135, 139, 140,
513 144, 145, 148, 152, 155, 157, 161, 162, 165, 168,
514 171, 174, 177, 182, 186, 189, 193, 198, 199, 202,
515 206, 208, 212, 213, 216, 219, 222, 226, 230, 234,
516 236, 240, 241, 244, 247, 250, 254, 258, 261, 264,
517 267, 268, 271, 274, 277, 282, 283, 286, 289, 292,
518 293, 296, 298, 300, 303, 306, 309, 311, 314, 315,
519 318, 320, 324, 328, 332, 335, 339, 343, 345, 347,
520 348
521 };
522
523 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
524 static const yytype_int8 yyrhs[] =
525 {
526 38, 0, -1, 82, 39, -1, 39, -1, 64, 40,
527 -1, 40, -1, -1, 40, 42, -1, 40, 56, -1,
528 40, 68, -1, 40, 81, -1, 40, 27, 1, 32,
529 -1, 40, 41, 1, 32, -1, 40, 1, 32, -1,
530 16, -1, 18, -1, 19, -1, 21, -1, 17, -1,
531 22, -1, 20, -1, 23, -1, 26, -1, 32, -1,
532 62, -1, 72, -1, 45, -1, 47, -1, 70, -1,
533 27, 1, 32, -1, 1, 32, -1, 10, 27, 32,
534 -1, 44, 48, -1, 11, 27, 32, -1, 46, 48,
535 -1, -1, 48, 49, -1, 48, 50, -1, 48, 76,
536 -1, 48, 74, -1, 48, 43, -1, 48, 32, -1,
537 19, 79, 32, -1, 18, 80, 83, 32, -1, 20,
538 84, 83, 32, -1, 21, 27, 83, 32, -1, 22,
539 85, 85, 83, 32, -1, 24, 51, 32, -1, -1,
540 51, 27, 52, -1, -1, 35, 80, -1, 7, 86,
541 32, -1, 53, 57, -1, 81, -1, 54, 59, 55,
542 -1, -1, 57, 58, -1, 57, 76, -1, 57, 74,
543 -1, 57, 32, -1, 57, 43, -1, 18, 80, 83,
544 32, -1, 19, 79, 32, -1, 17, 32, -1, 26,
545 83, 32, -1, 20, 27, 83, 32, -1, -1, 59,
546 42, -1, 14, 84, 82, -1, 81, -1, 60, 63,
547 61, -1, -1, 63, 42, -1, 63, 68, -1, 63,
548 56, -1, 3, 80, 82, -1, 4, 80, 32, -1,
549 65, 77, 75, -1, 81, -1, 66, 69, 67, -1,
550 -1, 69, 42, -1, 69, 68, -1, 69, 56, -1,
551 6, 80, 32, -1, 9, 80, 32, -1, 71, 75,
552 -1, 12, 32, -1, 73, 13, -1, -1, 75, 76,
553 -1, 75, 32, -1, 75, 43, -1, 16, 25, 84,
554 32, -1, -1, 77, 78, -1, 77, 32, -1, 23,
555 83, -1, -1, 80, 83, -1, 27, -1, 28, -1,
556 5, 32, -1, 8, 32, -1, 15, 32, -1, 32,
557 -1, 82, 32, -1, -1, 14, 84, -1, 85, -1,
558 85, 35, 85, -1, 85, 29, 85, -1, 31, 84,
559 30, -1, 36, 84, -1, 84, 33, 84, -1, 84,
560 34, 84, -1, 27, -1, 28, -1, -1, 27, -1
561 };
562
563 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
564 static const yytype_uint16 yyrline[] =
565 {
566 0, 104, 104, 104, 106, 106, 108, 110, 111, 112,
567 113, 114, 115, 119, 123, 123, 123, 123, 123, 123,
568 123, 123, 123, 127, 128, 129, 130, 131, 132, 136,
569 137, 143, 151, 157, 165, 175, 177, 178, 179, 180,
570 181, 182, 185, 193, 199, 209, 215, 221, 224, 226,
571 237, 238, 243, 252, 257, 265, 268, 270, 271, 272,
572 273, 274, 277, 283, 294, 300, 305, 315, 317, 322,
573 330, 338, 341, 343, 344, 345, 350, 357, 364, 369,
574 377, 380, 382, 383, 384, 387, 395, 402, 409, 415,
575 422, 424, 425, 426, 429, 437, 439, 440, 443, 450,
576 452, 457, 458, 461, 462, 463, 467, 468, 471, 472,
577 475, 476, 477, 478, 479, 480, 481, 484, 485, 488,
578 489
579 };
580 #endif
581
582 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
583 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
584 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
585 static const char *const yytname[] =
586 {
587 "$end", "error", "$undefined", "T_MAINMENU", "T_MENU", "T_ENDMENU",
588 "T_SOURCE", "T_CHOICE", "T_ENDCHOICE", "T_COMMENT", "T_CONFIG",
589 "T_MENUCONFIG", "T_HELP", "T_HELPTEXT", "T_IF", "T_ENDIF", "T_DEPENDS",
590 "T_OPTIONAL", "T_PROMPT", "T_TYPE", "T_DEFAULT", "T_SELECT", "T_RANGE",
591 "T_VISIBLE", "T_OPTION", "T_ON", "T_RESET", "T_WORD", "T_WORD_QUOTE",
592 "T_UNEQUAL", "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_EOL", "T_OR", "T_AND",
593 "T_EQUAL", "T_NOT", "$accept", "input", "start", "stmt_list",
594 "option_name", "common_stmt", "option_error", "config_entry_start",
595 "config_stmt", "menuconfig_entry_start", "menuconfig_stmt",
596 "config_option_list", "config_option", "symbol_option",
597 "symbol_option_list", "symbol_option_arg", "choice", "choice_entry",
598 "choice_end", "choice_stmt", "choice_option_list", "choice_option",
599 "choice_block", "if_entry", "if_end", "if_stmt", "if_block",
600 "mainmenu_stmt", "menu", "menu_entry", "menu_end", "menu_stmt",
601 "menu_block", "source_stmt", "comment", "comment_stmt", "help_start",
602 "help", "depends_list", "depends", "visibility_list", "visible",
603 "prompt_stmt_opt", "prompt", "end", "nl", "if_expr", "expr", "symbol",
604 "word_opt", 0
605 };
606 #endif
607
608 # ifdef YYPRINT
609 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
610 token YYLEX-NUM. */
611 static const yytype_uint16 yytoknum[] =
612 {
613 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
614 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
615 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
616 285, 286, 287, 288, 289, 290, 291
617 };
618 # endif
619
620 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
621 static const yytype_uint8 yyr1[] =
622 {
623 0, 37, 38, 38, 39, 39, 40, 40, 40, 40,
624 40, 40, 40, 40, 41, 41, 41, 41, 41, 41,
625 41, 41, 41, 42, 42, 42, 42, 42, 42, 43,
626 43, 44, 45, 46, 47, 48, 48, 48, 48, 48,
627 48, 48, 49, 49, 49, 49, 49, 50, 51, 51,
628 52, 52, 53, 54, 55, 56, 57, 57, 57, 57,
629 57, 57, 58, 58, 58, 58, 58, 59, 59, 60,
630 61, 62, 63, 63, 63, 63, 64, 65, 66, 67,
631 68, 69, 69, 69, 69, 70, 71, 72, 73, 74,
632 75, 75, 75, 75, 76, 77, 77, 77, 78, 79,
633 79, 80, 80, 81, 81, 81, 82, 82, 83, 83,
634 84, 84, 84, 84, 84, 84, 84, 85, 85, 86,
635 86
636 };
637
638 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
639 static const yytype_uint8 yyr2[] =
640 {
641 0, 2, 2, 1, 2, 1, 0, 2, 2, 2,
642 2, 4, 4, 3, 1, 1, 1, 1, 1, 1,
643 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
644 2, 3, 2, 3, 2, 0, 2, 2, 2, 2,
645 2, 2, 3, 4, 4, 4, 5, 3, 0, 3,
646 0, 2, 3, 2, 1, 3, 0, 2, 2, 2,
647 2, 2, 4, 3, 2, 3, 4, 0, 2, 3,
648 1, 3, 0, 2, 2, 2, 3, 3, 3, 1,
649 3, 0, 2, 2, 2, 3, 3, 2, 2, 2,
650 0, 2, 2, 2, 4, 0, 2, 2, 2, 0,
651 2, 1, 1, 2, 2, 2, 1, 2, 0, 2,
652 1, 3, 3, 3, 2, 3, 3, 1, 1, 0,
653 1
654 };
655
656 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
657 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
658 means the default is an error. */
659 static const yytype_uint8 yydefact[] =
660 {
661 6, 0, 106, 0, 3, 0, 6, 6, 101, 102,
662 0, 1, 0, 0, 0, 0, 119, 0, 0, 0,
663 0, 0, 0, 14, 18, 15, 16, 20, 17, 19,
664 21, 22, 0, 23, 0, 7, 35, 26, 35, 27,
665 56, 67, 8, 72, 24, 95, 81, 9, 28, 90,
666 25, 10, 0, 107, 2, 76, 13, 0, 103, 0,
667 120, 0, 104, 0, 0, 0, 117, 118, 0, 0,
668 0, 110, 105, 0, 0, 0, 0, 0, 0, 0,
669 90, 0, 0, 77, 85, 52, 86, 31, 33, 0,
670 114, 0, 0, 69, 0, 0, 11, 12, 0, 0,
671 0, 0, 99, 0, 0, 0, 48, 0, 41, 40,
672 36, 37, 0, 39, 38, 0, 0, 99, 0, 108,
673 60, 61, 57, 59, 58, 68, 55, 54, 73, 75,
674 71, 74, 70, 108, 97, 0, 96, 82, 84, 80,
675 83, 79, 92, 93, 91, 113, 115, 116, 112, 111,
676 30, 88, 0, 108, 0, 108, 108, 108, 0, 0,
677 0, 89, 64, 108, 0, 108, 0, 0, 98, 0,
678 0, 42, 100, 0, 0, 108, 50, 47, 29, 0,
679 63, 0, 109, 65, 94, 43, 44, 45, 0, 0,
680 49, 62, 66, 46, 51
681 };
682
683 /* YYDEFGOTO[NTERM-NUM]. */
684 static const yytype_int16 yydefgoto[] =
685 {
686 -1, 3, 4, 5, 34, 35, 109, 36, 37, 38,
687 39, 75, 110, 111, 159, 190, 40, 41, 126, 42,
688 77, 122, 78, 43, 130, 44, 79, 6, 45, 46,
689 139, 47, 81, 48, 49, 50, 112, 113, 82, 114,
690 80, 136, 154, 155, 51, 7, 167, 70, 71, 61
691 };
692
693 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
694 STATE-NUM. */
695 #define YYPACT_NINF -127
696 static const yytype_int16 yypact[] =
697 {
698 6, 16, -127, 10, -127, 160, -127, 13, -127, -127,
699 -14, -127, -10, 16, 25, 16, 21, 35, 16, 44,
700 61, -8, 62, -127, -127, -127, -127, -127, -127, -127,
701 -127, -127, 100, -127, 126, -127, -127, -127, -127, -127,
702 -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
703 -127, -127, 189, -127, -127, 98, -127, 101, -127, 112,
704 -127, 124, -127, 127, 130, 140, -127, -127, -8, -8,
705 0, 17, -127, 141, 152, 102, 131, 64, 45, 261,
706 3, 261, 218, -127, -127, -127, -127, -127, -127, 28,
707 -127, -8, -8, 98, 70, 70, -127, -127, 153, 159,
708 176, 16, 16, -8, 175, 70, -127, 212, -127, -127,
709 -127, -127, 201, -127, -127, 185, 16, 16, 193, 216,
710 -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
711 -127, -127, -127, 216, -127, 247, -127, -127, -127, -127,
712 -127, -127, -127, -127, -127, -127, 197, -127, -127, -127,
713 -127, -127, -8, 216, 210, 216, 7, 216, 70, 15,
714 211, -127, -127, 216, 214, 216, -8, 227, -127, 248,
715 228, -127, -127, 232, 241, 216, 242, -127, -127, 246,
716 -127, 252, 71, -127, -127, -127, -127, -127, 254, 16,
717 -127, -127, -127, -127, -127
718 };
719
720 /* YYPGOTO[NTERM-NUM]. */
721 static const yytype_int16 yypgoto[] =
722 {
723 -127, -127, 280, 282, -127, 8, -71, -127, -127, -127,
724 -127, 251, -127, -127, -127, -127, -127, -127, -127, 168,
725 -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
726 -127, 204, -127, -127, -127, -127, -127, 213, 215, -69,
727 -127, -127, 174, -1, 14, -7, -126, -67, -90, -127
728 };
729
730 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
731 positive, shift that token. If negative, reduce the rule which
732 number is the opposite. If zero, do what YYDEFACT says.
733 If YYTABLE_NINF, syntax error. */
734 #define YYTABLE_NINF -88
735 static const yytype_int16 yytable[] =
736 {
737 10, 89, 90, 55, 148, 149, 121, 168, 124, 1,
738 11, 143, 57, 144, 59, 158, 1, 63, 2, 66,
739 67, 166, 56, 68, 146, 147, 133, 170, 69, 172,
740 173, 174, 2, 91, 92, 134, 156, 179, 2, 181,
741 91, 92, 176, 8, 9, 53, 94, 177, 60, 188,
742 14, 15, 95, 17, 18, 19, 20, 58, 145, 21,
743 22, 91, 92, 93, 143, 98, 144, 62, 175, -53,
744 -53, 64, -53, -53, -53, -53, 99, 33, -53, -53,
745 100, 115, 116, 117, 118, 169, 125, 128, 65, 137,
746 119, 107, 127, 132, 72, 141, 120, 66, 67, 182,
747 153, 73, -32, 98, 91, 92, -32, -32, -32, -32,
748 -32, -32, -32, -32, 99, 163, -32, -32, 100, -32,
749 101, 102, 103, 104, 105, -32, 106, 74, -32, 107,
750 53, -34, 98, 83, 108, -34, -34, -34, -34, -34,
751 -34, -34, -34, 99, 84, -34, -34, 100, -34, 101,
752 102, 103, 104, 105, -34, 106, 85, -34, 107, 86,
753 -5, 12, 87, 108, 13, 14, 15, 16, 17, 18,
754 19, 20, 88, 96, 21, 22, 23, 24, 25, 26,
755 27, 28, 29, 30, 97, 150, 31, 32, 194, -4,
756 12, 151, 33, 13, 14, 15, 16, 17, 18, 19,
757 20, 152, 157, 21, 22, 23, 24, 25, 26, 27,
758 28, 29, 30, 160, 161, 31, 32, 162, -87, 98,
759 165, 33, -87, -87, -87, -87, -87, -87, -87, -87,
760 166, 92, -87, -87, 100, -87, -87, -87, -87, -87,
761 -87, -87, 171, 178, -87, 107, 180, 129, 98, 138,
762 142, -78, -78, -78, -78, -78, -78, -78, -78, 183,
763 185, -78, -78, 100, 186, 13, 14, 15, 16, 17,
764 18, 19, 20, 187, 107, 21, 22, 189, 191, 142,
765 184, 91, 92, 131, 192, 140, 193, 54, 52, 76,
766 123, 164, 0, 33, 0, 135
767 };
768
769 static const yytype_int16 yycheck[] =
770 {
771 1, 68, 69, 10, 94, 95, 77, 133, 77, 3,
772 0, 82, 13, 82, 15, 105, 3, 18, 32, 27,
773 28, 14, 32, 31, 91, 92, 23, 153, 36, 155,
774 156, 157, 32, 33, 34, 32, 103, 163, 32, 165,
775 33, 34, 27, 27, 28, 32, 29, 32, 27, 175,
776 5, 6, 35, 8, 9, 10, 11, 32, 30, 14,
777 15, 33, 34, 70, 135, 1, 135, 32, 158, 5,
778 6, 27, 8, 9, 10, 11, 12, 32, 14, 15,
779 16, 17, 18, 19, 20, 152, 78, 79, 27, 81,
780 26, 27, 78, 79, 32, 81, 32, 27, 28, 166,
781 101, 1, 0, 1, 33, 34, 4, 5, 6, 7,
782 8, 9, 10, 11, 12, 116, 14, 15, 16, 17,
783 18, 19, 20, 21, 22, 23, 24, 1, 26, 27,
784 32, 0, 1, 32, 32, 4, 5, 6, 7, 8,
785 9, 10, 11, 12, 32, 14, 15, 16, 17, 18,
786 19, 20, 21, 22, 23, 24, 32, 26, 27, 32,
787 0, 1, 32, 32, 4, 5, 6, 7, 8, 9,
788 10, 11, 32, 32, 14, 15, 16, 17, 18, 19,
789 20, 21, 22, 23, 32, 32, 26, 27, 189, 0,
790 1, 32, 32, 4, 5, 6, 7, 8, 9, 10,
791 11, 25, 27, 14, 15, 16, 17, 18, 19, 20,
792 21, 22, 23, 1, 13, 26, 27, 32, 0, 1,
793 27, 32, 4, 5, 6, 7, 8, 9, 10, 11,
794 14, 34, 14, 15, 16, 17, 18, 19, 20, 21,
795 22, 23, 32, 32, 26, 27, 32, 79, 1, 81,
796 32, 4, 5, 6, 7, 8, 9, 10, 11, 32,
797 32, 14, 15, 16, 32, 4, 5, 6, 7, 8,
798 9, 10, 11, 32, 27, 14, 15, 35, 32, 32,
799 32, 33, 34, 79, 32, 81, 32, 7, 6, 38,
800 77, 117, -1, 32, -1, 80
801 };
802
803 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
804 symbol of state STATE-NUM. */
805 static const yytype_uint8 yystos[] =
806 {
807 0, 3, 32, 38, 39, 40, 64, 82, 27, 28,
808 80, 0, 1, 4, 5, 6, 7, 8, 9, 10,
809 11, 14, 15, 16, 17, 18, 19, 20, 21, 22,
810 23, 26, 27, 32, 41, 42, 44, 45, 46, 47,
811 53, 54, 56, 60, 62, 65, 66, 68, 70, 71,
812 72, 81, 40, 32, 39, 82, 32, 80, 32, 80,
813 27, 86, 32, 80, 27, 27, 27, 28, 31, 36,
814 84, 85, 32, 1, 1, 48, 48, 57, 59, 63,
815 77, 69, 75, 32, 32, 32, 32, 32, 32, 84,
816 84, 33, 34, 82, 29, 35, 32, 32, 1, 12,
817 16, 18, 19, 20, 21, 22, 24, 27, 32, 43,
818 49, 50, 73, 74, 76, 17, 18, 19, 20, 26,
819 32, 43, 58, 74, 76, 42, 55, 81, 42, 56,
820 61, 68, 81, 23, 32, 75, 78, 42, 56, 67,
821 68, 81, 32, 43, 76, 30, 84, 84, 85, 85,
822 32, 32, 25, 80, 79, 80, 84, 27, 85, 51,
823 1, 13, 32, 80, 79, 27, 14, 83, 83, 84,
824 83, 32, 83, 83, 83, 85, 27, 32, 32, 83,
825 32, 83, 84, 32, 32, 32, 32, 32, 83, 35,
826 52, 32, 32, 32, 80
827 };
828
829 #define yyerrok (yyerrstatus = 0)
830 #define yyclearin (yychar = YYEMPTY)
831 #define YYEMPTY (-2)
832 #define YYEOF 0
833
834 #define YYACCEPT goto yyacceptlab
835 #define YYABORT goto yyabortlab
836 #define YYERROR goto yyerrorlab
837
838
839 /* Like YYERROR except do call yyerror. This remains here temporarily
840 to ease the transition to the new meaning of YYERROR, for GCC.
841 Once GCC version 2 has supplanted version 1, this can go. */
842
843 #define YYFAIL goto yyerrlab
844
845 #define YYRECOVERING() (!!yyerrstatus)
846
847 #define YYBACKUP(Token, Value) \
848 do \
849 if (yychar == YYEMPTY && yylen == 1) \
850 { \
851 yychar = (Token); \
852 yylval = (Value); \
853 yytoken = YYTRANSLATE (yychar); \
854 YYPOPSTACK (1); \
855 goto yybackup; \
856 } \
857 else \
858 { \
859 yyerror (YY_("syntax error: cannot back up")); \
860 YYERROR; \
861 } \
862 while (YYID (0))
863
864
865 #define YYTERROR 1
866 #define YYERRCODE 256
867
868
869 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
870 If N is 0, then set CURRENT to the empty location which ends
871 the previous symbol: RHS[0] (always defined). */
872
873 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
874 #ifndef YYLLOC_DEFAULT
875 # define YYLLOC_DEFAULT(Current, Rhs, N) \
876 do \
877 if (YYID (N)) \
878 { \
879 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
880 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
881 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
882 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
883 } \
884 else \
885 { \
886 (Current).first_line = (Current).last_line = \
887 YYRHSLOC (Rhs, 0).last_line; \
888 (Current).first_column = (Current).last_column = \
889 YYRHSLOC (Rhs, 0).last_column; \
890 } \
891 while (YYID (0))
892 #endif
893
894
895 /* YY_LOCATION_PRINT -- Print the location on the stream.
896 This macro was not mandated originally: define only if we know
897 we won't break user code: when these are the locations we know. */
898
899 #ifndef YY_LOCATION_PRINT
900 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
901 # define YY_LOCATION_PRINT(File, Loc) \
902 fprintf (File, "%d.%d-%d.%d", \
903 (Loc).first_line, (Loc).first_column, \
904 (Loc).last_line, (Loc).last_column)
905 # else
906 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
907 # endif
908 #endif
909
910
911 /* YYLEX -- calling `yylex' with the right arguments. */
912
913 #ifdef YYLEX_PARAM
914 # define YYLEX yylex (YYLEX_PARAM)
915 #else
916 # define YYLEX yylex ()
917 #endif
918
919 /* Enable debugging if requested. */
920 #if YYDEBUG
921
922 # ifndef YYFPRINTF
923 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
924 # define YYFPRINTF fprintf
925 # endif
926
927 # define YYDPRINTF(Args) \
928 do { \
929 if (yydebug) \
930 YYFPRINTF Args; \
931 } while (YYID (0))
932
933 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
934 do { \
935 if (yydebug) \
936 { \
937 YYFPRINTF (stderr, "%s ", Title); \
938 yy_symbol_print (stderr, \
939 Type, Value); \
940 YYFPRINTF (stderr, "\n"); \
941 } \
942 } while (YYID (0))
943
944
945 /*--------------------------------.
946 | Print this symbol on YYOUTPUT. |
947 `--------------------------------*/
948
949 /*ARGSUSED*/
950 #if (defined __STDC__ || defined __C99__FUNC__ \
951 || defined __cplusplus || defined _MSC_VER)
952 static void
953 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
954 #else
955 static void
956 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
957 FILE *yyoutput;
958 int yytype;
959 YYSTYPE const * const yyvaluep;
960 #endif
961 {
962 if (!yyvaluep)
963 return;
964 # ifdef YYPRINT
965 if (yytype < YYNTOKENS)
966 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
967 # else
968 YYUSE (yyoutput);
969 # endif
970 switch (yytype)
971 {
972 default:
973 break;
974 }
975 }
976
977
978 /*--------------------------------.
979 | Print this symbol on YYOUTPUT. |
980 `--------------------------------*/
981
982 #if (defined __STDC__ || defined __C99__FUNC__ \
983 || defined __cplusplus || defined _MSC_VER)
984 static void
985 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
986 #else
987 static void
988 yy_symbol_print (yyoutput, yytype, yyvaluep)
989 FILE *yyoutput;
990 int yytype;
991 YYSTYPE const * const yyvaluep;
992 #endif
993 {
994 if (yytype < YYNTOKENS)
995 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
996 else
997 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
998
999 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1000 YYFPRINTF (yyoutput, ")");
1001 }
1002
1003 /*------------------------------------------------------------------.
1004 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1005 | TOP (included). |
1006 `------------------------------------------------------------------*/
1007
1008 #if (defined __STDC__ || defined __C99__FUNC__ \
1009 || defined __cplusplus || defined _MSC_VER)
1010 static void
1011 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1012 #else
1013 static void
1014 yy_stack_print (bottom, top)
1015 yytype_int16 *bottom;
1016 yytype_int16 *top;
1017 #endif
1018 {
1019 YYFPRINTF (stderr, "Stack now");
1020 for (; bottom <= top; ++bottom)
1021 YYFPRINTF (stderr, " %d", *bottom);
1022 YYFPRINTF (stderr, "\n");
1023 }
1024
1025 # define YY_STACK_PRINT(Bottom, Top) \
1026 do { \
1027 if (yydebug) \
1028 yy_stack_print ((Bottom), (Top)); \
1029 } while (YYID (0))
1030
1031
1032 /*------------------------------------------------.
1033 | Report that the YYRULE is going to be reduced. |
1034 `------------------------------------------------*/
1035
1036 #if (defined __STDC__ || defined __C99__FUNC__ \
1037 || defined __cplusplus || defined _MSC_VER)
1038 static void
1039 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1040 #else
1041 static void
1042 yy_reduce_print (yyvsp, yyrule)
1043 YYSTYPE *yyvsp;
1044 int yyrule;
1045 #endif
1046 {
1047 int yynrhs = yyr2[yyrule];
1048 int yyi;
1049 unsigned long int yylno = yyrline[yyrule];
1050 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1051 yyrule - 1, yylno);
1052 /* The symbols being reduced. */
1053 for (yyi = 0; yyi < yynrhs; yyi++)
1054 {
1055 fprintf (stderr, " $%d = ", yyi + 1);
1056 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1057 &(yyvsp[(yyi + 1) - (yynrhs)])
1058 );
1059 fprintf (stderr, "\n");
1060 }
1061 }
1062
1063 # define YY_REDUCE_PRINT(Rule) \
1064 do { \
1065 if (yydebug) \
1066 yy_reduce_print (yyvsp, Rule); \
1067 } while (YYID (0))
1068
1069 /* Nonzero means print parse trace. It is left uninitialized so that
1070 multiple parsers can coexist. */
1071 int yydebug;
1072 #else /* !YYDEBUG */
1073 # define YYDPRINTF(Args)
1074 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1075 # define YY_STACK_PRINT(Bottom, Top)
1076 # define YY_REDUCE_PRINT(Rule)
1077 #endif /* !YYDEBUG */
1078
1079
1080 /* YYINITDEPTH -- initial size of the parser's stacks. */
1081 #ifndef YYINITDEPTH
1082 # define YYINITDEPTH 200
1083 #endif
1084
1085 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1086 if the built-in stack extension method is used).
1087
1088 Do not make this value too large; the results are undefined if
1089 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1090 evaluated with infinite-precision integer arithmetic. */
1091
1092 #ifndef YYMAXDEPTH
1093 # define YYMAXDEPTH 10000
1094 #endif
1095
1096 \f
1097
1098 #if YYERROR_VERBOSE
1099
1100 # ifndef yystrlen
1101 # if defined __GLIBC__ && defined _STRING_H
1102 # define yystrlen strlen
1103 # else
1104 /* Return the length of YYSTR. */
1105 #if (defined __STDC__ || defined __C99__FUNC__ \
1106 || defined __cplusplus || defined _MSC_VER)
1107 static YYSIZE_T
1108 yystrlen (const char *yystr)
1109 #else
1110 static YYSIZE_T
1111 yystrlen (yystr)
1112 const char *yystr;
1113 #endif
1114 {
1115 YYSIZE_T yylen;
1116 for (yylen = 0; yystr[yylen]; yylen++)
1117 continue;
1118 return yylen;
1119 }
1120 # endif
1121 # endif
1122
1123 # ifndef yystpcpy
1124 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1125 # define yystpcpy stpcpy
1126 # else
1127 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1128 YYDEST. */
1129 #if (defined __STDC__ || defined __C99__FUNC__ \
1130 || defined __cplusplus || defined _MSC_VER)
1131 static char *
1132 yystpcpy (char *yydest, const char *yysrc)
1133 #else
1134 static char *
1135 yystpcpy (yydest, yysrc)
1136 char *yydest;
1137 const char *yysrc;
1138 #endif
1139 {
1140 char *yyd = yydest;
1141 const char *yys = yysrc;
1142
1143 while ((*yyd++ = *yys++) != '\0')
1144 continue;
1145
1146 return yyd - 1;
1147 }
1148 # endif
1149 # endif
1150
1151 # ifndef yytnamerr
1152 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1153 quotes and backslashes, so that it's suitable for yyerror. The
1154 heuristic is that double-quoting is unnecessary unless the string
1155 contains an apostrophe, a comma, or backslash (other than
1156 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1157 null, do not copy; instead, return the length of what the result
1158 would have been. */
1159 static YYSIZE_T
1160 yytnamerr (char *yyres, const char *yystr)
1161 {
1162 if (*yystr == '"')
1163 {
1164 YYSIZE_T yyn = 0;
1165 char const *yyp = yystr;
1166
1167 for (;;)
1168 switch (*++yyp)
1169 {
1170 case '\'':
1171 case ',':
1172 goto do_not_strip_quotes;
1173
1174 case '\\':
1175 if (*++yyp != '\\')
1176 goto do_not_strip_quotes;
1177 /* Fall through. */
1178 default:
1179 if (yyres)
1180 yyres[yyn] = *yyp;
1181 yyn++;
1182 break;
1183
1184 case '"':
1185 if (yyres)
1186 yyres[yyn] = '\0';
1187 return yyn;
1188 }
1189 do_not_strip_quotes: ;
1190 }
1191
1192 if (! yyres)
1193 return yystrlen (yystr);
1194
1195 return yystpcpy (yyres, yystr) - yyres;
1196 }
1197 # endif
1198
1199 /* Copy into YYRESULT an error message about the unexpected token
1200 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1201 including the terminating null byte. If YYRESULT is null, do not
1202 copy anything; just return the number of bytes that would be
1203 copied. As a special case, return 0 if an ordinary "syntax error"
1204 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1205 size calculation. */
1206 static YYSIZE_T
1207 yysyntax_error (char *yyresult, int yystate, int yychar)
1208 {
1209 int yyn = yypact[yystate];
1210
1211 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1212 return 0;
1213 else
1214 {
1215 int yytype = YYTRANSLATE (yychar);
1216 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1217 YYSIZE_T yysize = yysize0;
1218 YYSIZE_T yysize1;
1219 int yysize_overflow = 0;
1220 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1221 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1222 int yyx;
1223
1224 # if 0
1225 /* This is so xgettext sees the translatable formats that are
1226 constructed on the fly. */
1227 YY_("syntax error, unexpected %s");
1228 YY_("syntax error, unexpected %s, expecting %s");
1229 YY_("syntax error, unexpected %s, expecting %s or %s");
1230 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1231 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1232 # endif
1233 char *yyfmt;
1234 char const *yyf;
1235 static char const yyunexpected[] = "syntax error, unexpected %s";
1236 static char const yyexpecting[] = ", expecting %s";
1237 static char const yyor[] = " or %s";
1238 char yyformat[sizeof yyunexpected
1239 + sizeof yyexpecting - 1
1240 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1241 * (sizeof yyor - 1))];
1242 char const *yyprefix = yyexpecting;
1243
1244 /* Start YYX at -YYN if negative to avoid negative indexes in
1245 YYCHECK. */
1246 int yyxbegin = yyn < 0 ? -yyn : 0;
1247
1248 /* Stay within bounds of both yycheck and yytname. */
1249 int yychecklim = YYLAST - yyn + 1;
1250 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1251 int yycount = 1;
1252
1253 yyarg[0] = yytname[yytype];
1254 yyfmt = yystpcpy (yyformat, yyunexpected);
1255
1256 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1257 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1258 {
1259 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1260 {
1261 yycount = 1;
1262 yysize = yysize0;
1263 yyformat[sizeof yyunexpected - 1] = '\0';
1264 break;
1265 }
1266 yyarg[yycount++] = yytname[yyx];
1267 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1268 yysize_overflow |= (yysize1 < yysize);
1269 yysize = yysize1;
1270 yyfmt = yystpcpy (yyfmt, yyprefix);
1271 yyprefix = yyor;
1272 }
1273
1274 yyf = YY_(yyformat);
1275 yysize1 = yysize + yystrlen (yyf);
1276 yysize_overflow |= (yysize1 < yysize);
1277 yysize = yysize1;
1278
1279 if (yysize_overflow)
1280 return YYSIZE_MAXIMUM;
1281
1282 if (yyresult)
1283 {
1284 /* Avoid sprintf, as that infringes on the user's name space.
1285 Don't have undefined behavior even if the translation
1286 produced a string with the wrong number of "%s"s. */
1287 char *yyp = yyresult;
1288 int yyi = 0;
1289 while ((*yyp = *yyf) != '\0')
1290 {
1291 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1292 {
1293 yyp += yytnamerr (yyp, yyarg[yyi++]);
1294 yyf += 2;
1295 }
1296 else
1297 {
1298 yyp++;
1299 yyf++;
1300 }
1301 }
1302 }
1303 return yysize;
1304 }
1305 }
1306 #endif /* YYERROR_VERBOSE */
1307 \f
1308
1309 /*-----------------------------------------------.
1310 | Release the memory associated to this symbol. |
1311 `-----------------------------------------------*/
1312
1313 /*ARGSUSED*/
1314 #if (defined __STDC__ || defined __C99__FUNC__ \
1315 || defined __cplusplus || defined _MSC_VER)
1316 static void
1317 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1318 #else
1319 static void
1320 yydestruct (yymsg, yytype, yyvaluep)
1321 const char *yymsg;
1322 int yytype;
1323 YYSTYPE *yyvaluep;
1324 #endif
1325 {
1326 YYUSE (yyvaluep);
1327
1328 if (!yymsg)
1329 yymsg = "Deleting";
1330 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1331
1332 switch (yytype)
1333 {
1334 case 54: /* "choice_entry" */
1335
1336 {
1337 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1338 (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
1339 if (current_menu == (yyvaluep->menu))
1340 menu_end_menu();
1341 };
1342
1343 break;
1344 case 60: /* "if_entry" */
1345
1346 {
1347 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1348 (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
1349 if (current_menu == (yyvaluep->menu))
1350 menu_end_menu();
1351 };
1352
1353 break;
1354 case 66: /* "menu_entry" */
1355
1356 {
1357 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1358 (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
1359 if (current_menu == (yyvaluep->menu))
1360 menu_end_menu();
1361 };
1362
1363 break;
1364
1365 default:
1366 break;
1367 }
1368 }
1369 \f
1370
1371 /* Prevent warnings from -Wmissing-prototypes. */
1372
1373 #ifdef YYPARSE_PARAM
1374 #if defined __STDC__ || defined __cplusplus
1375 int yyparse (void *YYPARSE_PARAM);
1376 #else
1377 int yyparse ();
1378 #endif
1379 #else /* ! YYPARSE_PARAM */
1380 #if defined __STDC__ || defined __cplusplus
1381 int yyparse (void);
1382 #else
1383 int yyparse ();
1384 #endif
1385 #endif /* ! YYPARSE_PARAM */
1386
1387
1388
1389 /* The look-ahead symbol. */
1390 int yychar;
1391
1392 /* The semantic value of the look-ahead symbol. */
1393 YYSTYPE yylval;
1394
1395 /* Number of syntax errors so far. */
1396 int yynerrs;
1397
1398
1399
1400 /*----------.
1401 | yyparse. |
1402 `----------*/
1403
1404 #ifdef YYPARSE_PARAM
1405 #if (defined __STDC__ || defined __C99__FUNC__ \
1406 || defined __cplusplus || defined _MSC_VER)
1407 int
1408 yyparse (void *YYPARSE_PARAM)
1409 #else
1410 int
1411 yyparse (YYPARSE_PARAM)
1412 void *YYPARSE_PARAM;
1413 #endif
1414 #else /* ! YYPARSE_PARAM */
1415 #if (defined __STDC__ || defined __C99__FUNC__ \
1416 || defined __cplusplus || defined _MSC_VER)
1417 int
1418 yyparse (void)
1419 #else
1420 int
1421 yyparse ()
1422
1423 #endif
1424 #endif
1425 {
1426
1427 int yystate;
1428 int yyn;
1429 int yyresult;
1430 /* Number of tokens to shift before error messages enabled. */
1431 int yyerrstatus;
1432 /* Look-ahead token as an internal (translated) token number. */
1433 int yytoken = 0;
1434 #if YYERROR_VERBOSE
1435 /* Buffer for error messages, and its allocated size. */
1436 char yymsgbuf[128];
1437 char *yymsg = yymsgbuf;
1438 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1439 #endif
1440
1441 /* Three stacks and their tools:
1442 `yyss': related to states,
1443 `yyvs': related to semantic values,
1444 `yyls': related to locations.
1445
1446 Refer to the stacks thru separate pointers, to allow yyoverflow
1447 to reallocate them elsewhere. */
1448
1449 /* The state stack. */
1450 yytype_int16 yyssa[YYINITDEPTH];
1451 yytype_int16 *yyss = yyssa;
1452 yytype_int16 *yyssp;
1453
1454 /* The semantic value stack. */
1455 YYSTYPE yyvsa[YYINITDEPTH];
1456 YYSTYPE *yyvs = yyvsa;
1457 YYSTYPE *yyvsp;
1458
1459
1460
1461 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1462
1463 YYSIZE_T yystacksize = YYINITDEPTH;
1464
1465 /* The variables used to return semantic value and location from the
1466 action routines. */
1467 YYSTYPE yyval;
1468
1469
1470 /* The number of symbols on the RHS of the reduced rule.
1471 Keep to zero when no symbol should be popped. */
1472 int yylen = 0;
1473
1474 YYDPRINTF ((stderr, "Starting parse\n"));
1475
1476 yystate = 0;
1477 yyerrstatus = 0;
1478 yynerrs = 0;
1479 yychar = YYEMPTY; /* Cause a token to be read. */
1480
1481 /* Initialize stack pointers.
1482 Waste one element of value and location stack
1483 so that they stay on the same level as the state stack.
1484 The wasted elements are never initialized. */
1485
1486 yyssp = yyss;
1487 yyvsp = yyvs;
1488
1489 goto yysetstate;
1490
1491 /*------------------------------------------------------------.
1492 | yynewstate -- Push a new state, which is found in yystate. |
1493 `------------------------------------------------------------*/
1494 yynewstate:
1495 /* In all cases, when you get here, the value and location stacks
1496 have just been pushed. So pushing a state here evens the stacks. */
1497 yyssp++;
1498
1499 yysetstate:
1500 *yyssp = yystate;
1501
1502 if (yyss + yystacksize - 1 <= yyssp)
1503 {
1504 /* Get the current used size of the three stacks, in elements. */
1505 YYSIZE_T yysize = yyssp - yyss + 1;
1506
1507 #ifdef yyoverflow
1508 {
1509 /* Give user a chance to reallocate the stack. Use copies of
1510 these so that the &'s don't force the real ones into
1511 memory. */
1512 YYSTYPE *yyvs1 = yyvs;
1513 yytype_int16 *yyss1 = yyss;
1514
1515
1516 /* Each stack pointer address is followed by the size of the
1517 data in use in that stack, in bytes. This used to be a
1518 conditional around just the two extra args, but that might
1519 be undefined if yyoverflow is a macro. */
1520 yyoverflow (YY_("memory exhausted"),
1521 &yyss1, yysize * sizeof (*yyssp),
1522 &yyvs1, yysize * sizeof (*yyvsp),
1523
1524 &yystacksize);
1525
1526 yyss = yyss1;
1527 yyvs = yyvs1;
1528 }
1529 #else /* no yyoverflow */
1530 # ifndef YYSTACK_RELOCATE
1531 goto yyexhaustedlab;
1532 # else
1533 /* Extend the stack our own way. */
1534 if (YYMAXDEPTH <= yystacksize)
1535 goto yyexhaustedlab;
1536 yystacksize *= 2;
1537 if (YYMAXDEPTH < yystacksize)
1538 yystacksize = YYMAXDEPTH;
1539
1540 {
1541 yytype_int16 *yyss1 = yyss;
1542 union yyalloc *yyptr =
1543 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1544 if (! yyptr)
1545 goto yyexhaustedlab;
1546 YYSTACK_RELOCATE (yyss);
1547 YYSTACK_RELOCATE (yyvs);
1548
1549 # undef YYSTACK_RELOCATE
1550 if (yyss1 != yyssa)
1551 YYSTACK_FREE (yyss1);
1552 }
1553 # endif
1554 #endif /* no yyoverflow */
1555
1556 yyssp = yyss + yysize - 1;
1557 yyvsp = yyvs + yysize - 1;
1558
1559
1560 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1561 (unsigned long int) yystacksize));
1562
1563 if (yyss + yystacksize - 1 <= yyssp)
1564 YYABORT;
1565 }
1566
1567 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1568
1569 goto yybackup;
1570
1571 /*-----------.
1572 | yybackup. |
1573 `-----------*/
1574 yybackup:
1575
1576 /* Do appropriate processing given the current state. Read a
1577 look-ahead token if we need one and don't already have one. */
1578
1579 /* First try to decide what to do without reference to look-ahead token. */
1580 yyn = yypact[yystate];
1581 if (yyn == YYPACT_NINF)
1582 goto yydefault;
1583
1584 /* Not known => get a look-ahead token if don't already have one. */
1585
1586 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1587 if (yychar == YYEMPTY)
1588 {
1589 YYDPRINTF ((stderr, "Reading a token: "));
1590 yychar = YYLEX;
1591 }
1592
1593 if (yychar <= YYEOF)
1594 {
1595 yychar = yytoken = YYEOF;
1596 YYDPRINTF ((stderr, "Now at end of input.\n"));
1597 }
1598 else
1599 {
1600 yytoken = YYTRANSLATE (yychar);
1601 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1602 }
1603
1604 /* If the proper action on seeing token YYTOKEN is to reduce or to
1605 detect an error, take that action. */
1606 yyn += yytoken;
1607 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1608 goto yydefault;
1609 yyn = yytable[yyn];
1610 if (yyn <= 0)
1611 {
1612 if (yyn == 0 || yyn == YYTABLE_NINF)
1613 goto yyerrlab;
1614 yyn = -yyn;
1615 goto yyreduce;
1616 }
1617
1618 if (yyn == YYFINAL)
1619 YYACCEPT;
1620
1621 /* Count tokens shifted since error; after three, turn off error
1622 status. */
1623 if (yyerrstatus)
1624 yyerrstatus--;
1625
1626 /* Shift the look-ahead token. */
1627 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1628
1629 /* Discard the shifted token unless it is eof. */
1630 if (yychar != YYEOF)
1631 yychar = YYEMPTY;
1632
1633 yystate = yyn;
1634 *++yyvsp = yylval;
1635
1636 goto yynewstate;
1637
1638
1639 /*-----------------------------------------------------------.
1640 | yydefault -- do the default action for the current state. |
1641 `-----------------------------------------------------------*/
1642 yydefault:
1643 yyn = yydefact[yystate];
1644 if (yyn == 0)
1645 goto yyerrlab;
1646 goto yyreduce;
1647
1648
1649 /*-----------------------------.
1650 | yyreduce -- Do a reduction. |
1651 `-----------------------------*/
1652 yyreduce:
1653 /* yyn is the number of a rule to reduce with. */
1654 yylen = yyr2[yyn];
1655
1656 /* If YYLEN is nonzero, implement the default value of the action:
1657 `$$ = $1'.
1658
1659 Otherwise, the following line sets YYVAL to garbage.
1660 This behavior is undocumented and Bison
1661 users should not rely upon it. Assigning to YYVAL
1662 unconditionally makes the parser a bit smaller, and it avoids a
1663 GCC warning that YYVAL may be used uninitialized. */
1664 yyval = yyvsp[1-yylen];
1665
1666
1667 YY_REDUCE_PRINT (yyn);
1668 switch (yyn)
1669 {
1670 case 10:
1671
1672 { zconf_error("unexpected end statement"); ;}
1673 break;
1674
1675 case 11:
1676
1677 { zconf_error("unknown statement \"%s\"", (yyvsp[(2) - (4)].string)); ;}
1678 break;
1679
1680 case 12:
1681
1682 {
1683 zconf_error("unexpected option \"%s\"", kconf_id_strings + (yyvsp[(2) - (4)].id)->name);
1684 ;}
1685 break;
1686
1687 case 13:
1688
1689 { zconf_error("invalid statement"); ;}
1690 break;
1691
1692 case 29:
1693
1694 { zconf_error("unknown option \"%s\"", (yyvsp[(1) - (3)].string)); ;}
1695 break;
1696
1697 case 30:
1698
1699 { zconf_error("invalid option"); ;}
1700 break;
1701
1702 case 31:
1703
1704 {
1705 struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0);
1706 sym->flags |= SYMBOL_OPTIONAL;
1707 menu_add_entry(sym);
1708 printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
1709 ;}
1710 break;
1711
1712 case 32:
1713
1714 {
1715 menu_end_entry();
1716 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1717 ;}
1718 break;
1719
1720 case 33:
1721
1722 {
1723 struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0);
1724 sym->flags |= SYMBOL_OPTIONAL;
1725 menu_add_entry(sym);
1726 printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
1727 ;}
1728 break;
1729
1730 case 34:
1731
1732 {
1733 if (current_entry->prompt)
1734 current_entry->prompt->type = P_MENU;
1735 else
1736 zconfprint("warning: menuconfig statement without prompt");
1737 menu_end_entry();
1738 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1739 ;}
1740 break;
1741
1742 case 42:
1743
1744 {
1745 menu_set_type((yyvsp[(1) - (3)].id)->stype);
1746 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1747 zconf_curname(), zconf_lineno(),
1748 (yyvsp[(1) - (3)].id)->stype);
1749 ;}
1750 break;
1751
1752 case 43:
1753
1754 {
1755 menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr));
1756 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1757 ;}
1758 break;
1759
1760 case 44:
1761
1762 {
1763 menu_add_expr(P_DEFAULT, (yyvsp[(2) - (4)].expr), (yyvsp[(3) - (4)].expr));
1764 if ((yyvsp[(1) - (4)].id)->stype != S_UNKNOWN)
1765 menu_set_type((yyvsp[(1) - (4)].id)->stype);
1766 printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
1767 zconf_curname(), zconf_lineno(),
1768 (yyvsp[(1) - (4)].id)->stype);
1769 ;}
1770 break;
1771
1772 case 45:
1773
1774 {
1775 menu_add_symbol(P_SELECT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr));
1776 printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
1777 ;}
1778 break;
1779
1780 case 46:
1781
1782 {
1783 menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[(2) - (5)].symbol), (yyvsp[(3) - (5)].symbol)), (yyvsp[(4) - (5)].expr));
1784 printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
1785 ;}
1786 break;
1787
1788 case 49:
1789
1790 {
1791 const struct kconf_id *id = kconf_id_lookup((yyvsp[(2) - (3)].string), strlen((yyvsp[(2) - (3)].string)));
1792 if (id && id->flags & TF_OPTION)
1793 menu_add_option(id->token, (yyvsp[(3) - (3)].string));
1794 else
1795 zconfprint("warning: ignoring unknown option %s", (yyvsp[(2) - (3)].string));
1796 free((yyvsp[(2) - (3)].string));
1797 ;}
1798 break;
1799
1800 case 50:
1801
1802 { (yyval.string) = NULL; ;}
1803 break;
1804
1805 case 51:
1806
1807 { (yyval.string) = (yyvsp[(2) - (2)].string); ;}
1808 break;
1809
1810 case 52:
1811
1812 {
1813 struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), SYMBOL_CHOICE);
1814 sym->flags |= SYMBOL_AUTO;
1815 menu_add_entry(sym);
1816 menu_add_expr(P_CHOICE, NULL, NULL);
1817 printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
1818 ;}
1819 break;
1820
1821 case 53:
1822
1823 {
1824 (yyval.menu) = menu_add_menu();
1825 ;}
1826 break;
1827
1828 case 54:
1829
1830 {
1831 if (zconf_endtoken((yyvsp[(1) - (1)].id), T_CHOICE, T_ENDCHOICE)) {
1832 menu_end_menu();
1833 printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
1834 }
1835 ;}
1836 break;
1837
1838 case 62:
1839
1840 {
1841 menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr));
1842 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1843 ;}
1844 break;
1845
1846 case 63:
1847
1848 {
1849 if ((yyvsp[(1) - (3)].id)->stype == S_BOOLEAN || (yyvsp[(1) - (3)].id)->stype == S_TRISTATE) {
1850 menu_set_type((yyvsp[(1) - (3)].id)->stype);
1851 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1852 zconf_curname(), zconf_lineno(),
1853 (yyvsp[(1) - (3)].id)->stype);
1854 } else
1855 YYERROR;
1856 ;}
1857 break;
1858
1859 case 64:
1860
1861 {
1862 current_entry->sym->flags |= SYMBOL_OPTIONAL;
1863 printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
1864 ;}
1865 break;
1866
1867 case 65:
1868
1869 {
1870 menu_add_prop(P_RESET, NULL, NULL, (yyvsp[(2) - (3)].expr));
1871 ;}
1872 break;
1873
1874 case 66:
1875
1876 {
1877 if ((yyvsp[(1) - (4)].id)->stype == S_UNKNOWN) {
1878 menu_add_symbol(P_DEFAULT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr));
1879 printd(DEBUG_PARSE, "%s:%d:default\n",
1880 zconf_curname(), zconf_lineno());
1881 } else
1882 YYERROR;
1883 ;}
1884 break;
1885
1886 case 69:
1887
1888 {
1889 printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
1890 menu_add_entry(NULL);
1891 menu_add_dep((yyvsp[(2) - (3)].expr));
1892 (yyval.menu) = menu_add_menu();
1893 ;}
1894 break;
1895
1896 case 70:
1897
1898 {
1899 if (zconf_endtoken((yyvsp[(1) - (1)].id), T_IF, T_ENDIF)) {
1900 menu_end_menu();
1901 printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
1902 }
1903 ;}
1904 break;
1905
1906 case 76:
1907
1908 {
1909 menu_add_prompt(P_MENU, (yyvsp[(2) - (3)].string), NULL);
1910 ;}
1911 break;
1912
1913 case 77:
1914
1915 {
1916 menu_add_entry(NULL);
1917 menu_add_prompt(P_MENU, (yyvsp[(2) - (3)].string), NULL);
1918 printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
1919 ;}
1920 break;
1921
1922 case 78:
1923
1924 {
1925 (yyval.menu) = menu_add_menu();
1926 ;}
1927 break;
1928
1929 case 79:
1930
1931 {
1932 if (zconf_endtoken((yyvsp[(1) - (1)].id), T_MENU, T_ENDMENU)) {
1933 menu_end_menu();
1934 printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
1935 }
1936 ;}
1937 break;
1938
1939 case 85:
1940
1941 {
1942 printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
1943 zconf_nextfile((yyvsp[(2) - (3)].string));
1944 ;}
1945 break;
1946
1947 case 86:
1948
1949 {
1950 menu_add_entry(NULL);
1951 menu_add_prompt(P_COMMENT, (yyvsp[(2) - (3)].string), NULL);
1952 printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
1953 ;}
1954 break;
1955
1956 case 87:
1957
1958 {
1959 menu_end_entry();
1960 ;}
1961 break;
1962
1963 case 88:
1964
1965 {
1966 printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
1967 zconf_starthelp();
1968 ;}
1969 break;
1970
1971 case 89:
1972
1973 {
1974 current_entry->help = (yyvsp[(2) - (2)].string);
1975 ;}
1976 break;
1977
1978 case 94:
1979
1980 {
1981 menu_add_dep((yyvsp[(3) - (4)].expr));
1982 printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
1983 ;}
1984 break;
1985
1986 case 98:
1987
1988 {
1989 menu_add_visibility((yyvsp[(2) - (2)].expr));
1990 ;}
1991 break;
1992
1993 case 100:
1994
1995 {
1996 menu_add_prompt(P_PROMPT, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].expr));
1997 ;}
1998 break;
1999
2000 case 103:
2001
2002 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
2003 break;
2004
2005 case 104:
2006
2007 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
2008 break;
2009
2010 case 105:
2011
2012 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
2013 break;
2014
2015 case 108:
2016
2017 { (yyval.expr) = NULL; ;}
2018 break;
2019
2020 case 109:
2021
2022 { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;}
2023 break;
2024
2025 case 110:
2026
2027 { (yyval.expr) = expr_alloc_symbol((yyvsp[(1) - (1)].symbol)); ;}
2028 break;
2029
2030 case 111:
2031
2032 { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
2033 break;
2034
2035 case 112:
2036
2037 { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
2038 break;
2039
2040 case 113:
2041
2042 { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
2043 break;
2044
2045 case 114:
2046
2047 { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[(2) - (2)].expr)); ;}
2048 break;
2049
2050 case 115:
2051
2052 { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
2053 break;
2054
2055 case 116:
2056
2057 { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
2058 break;
2059
2060 case 117:
2061
2062 { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), 0); free((yyvsp[(1) - (1)].string)); ;}
2063 break;
2064
2065 case 118:
2066
2067 { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), SYMBOL_CONST); free((yyvsp[(1) - (1)].string)); ;}
2068 break;
2069
2070 case 119:
2071
2072 { (yyval.string) = NULL; ;}
2073 break;
2074
2075
2076 /* Line 1267 of yacc.c. */
2077
2078 default: break;
2079 }
2080 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2081
2082 YYPOPSTACK (yylen);
2083 yylen = 0;
2084 YY_STACK_PRINT (yyss, yyssp);
2085
2086 *++yyvsp = yyval;
2087
2088
2089 /* Now `shift' the result of the reduction. Determine what state
2090 that goes to, based on the state we popped back to and the rule
2091 number reduced by. */
2092
2093 yyn = yyr1[yyn];
2094
2095 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2096 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2097 yystate = yytable[yystate];
2098 else
2099 yystate = yydefgoto[yyn - YYNTOKENS];
2100
2101 goto yynewstate;
2102
2103
2104 /*------------------------------------.
2105 | yyerrlab -- here on detecting error |
2106 `------------------------------------*/
2107 yyerrlab:
2108 /* If not already recovering from an error, report this error. */
2109 if (!yyerrstatus)
2110 {
2111 ++yynerrs;
2112 #if ! YYERROR_VERBOSE
2113 yyerror (YY_("syntax error"));
2114 #else
2115 {
2116 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2117 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2118 {
2119 YYSIZE_T yyalloc = 2 * yysize;
2120 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2121 yyalloc = YYSTACK_ALLOC_MAXIMUM;
2122 if (yymsg != yymsgbuf)
2123 YYSTACK_FREE (yymsg);
2124 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2125 if (yymsg)
2126 yymsg_alloc = yyalloc;
2127 else
2128 {
2129 yymsg = yymsgbuf;
2130 yymsg_alloc = sizeof yymsgbuf;
2131 }
2132 }
2133
2134 if (0 < yysize && yysize <= yymsg_alloc)
2135 {
2136 (void) yysyntax_error (yymsg, yystate, yychar);
2137 yyerror (yymsg);
2138 }
2139 else
2140 {
2141 yyerror (YY_("syntax error"));
2142 if (yysize != 0)
2143 goto yyexhaustedlab;
2144 }
2145 }
2146 #endif
2147 }
2148
2149
2150
2151 if (yyerrstatus == 3)
2152 {
2153 /* If just tried and failed to reuse look-ahead token after an
2154 error, discard it. */
2155
2156 if (yychar <= YYEOF)
2157 {
2158 /* Return failure if at end of input. */
2159 if (yychar == YYEOF)
2160 YYABORT;
2161 }
2162 else
2163 {
2164 yydestruct ("Error: discarding",
2165 yytoken, &yylval);
2166 yychar = YYEMPTY;
2167 }
2168 }
2169
2170 /* Else will try to reuse look-ahead token after shifting the error
2171 token. */
2172 goto yyerrlab1;
2173
2174
2175 /*---------------------------------------------------.
2176 | yyerrorlab -- error raised explicitly by YYERROR. |
2177 `---------------------------------------------------*/
2178 yyerrorlab:
2179
2180 /* Pacify compilers like GCC when the user code never invokes
2181 YYERROR and the label yyerrorlab therefore never appears in user
2182 code. */
2183 if (/*CONSTCOND*/ 0)
2184 goto yyerrorlab;
2185
2186 /* Do not reclaim the symbols of the rule which action triggered
2187 this YYERROR. */
2188 YYPOPSTACK (yylen);
2189 yylen = 0;
2190 YY_STACK_PRINT (yyss, yyssp);
2191 yystate = *yyssp;
2192 goto yyerrlab1;
2193
2194
2195 /*-------------------------------------------------------------.
2196 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2197 `-------------------------------------------------------------*/
2198 yyerrlab1:
2199 yyerrstatus = 3; /* Each real token shifted decrements this. */
2200
2201 for (;;)
2202 {
2203 yyn = yypact[yystate];
2204 if (yyn != YYPACT_NINF)
2205 {
2206 yyn += YYTERROR;
2207 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2208 {
2209 yyn = yytable[yyn];
2210 if (0 < yyn)
2211 break;
2212 }
2213 }
2214
2215 /* Pop the current state because it cannot handle the error token. */
2216 if (yyssp == yyss)
2217 YYABORT;
2218
2219
2220 yydestruct ("Error: popping",
2221 yystos[yystate], yyvsp);
2222 YYPOPSTACK (1);
2223 yystate = *yyssp;
2224 YY_STACK_PRINT (yyss, yyssp);
2225 }
2226
2227 if (yyn == YYFINAL)
2228 YYACCEPT;
2229
2230 *++yyvsp = yylval;
2231
2232
2233 /* Shift the error token. */
2234 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2235
2236 yystate = yyn;
2237 goto yynewstate;
2238
2239
2240 /*-------------------------------------.
2241 | yyacceptlab -- YYACCEPT comes here. |
2242 `-------------------------------------*/
2243 yyacceptlab:
2244 yyresult = 0;
2245 goto yyreturn;
2246
2247 /*-----------------------------------.
2248 | yyabortlab -- YYABORT comes here. |
2249 `-----------------------------------*/
2250 yyabortlab:
2251 yyresult = 1;
2252 goto yyreturn;
2253
2254 #ifndef yyoverflow
2255 /*-------------------------------------------------.
2256 | yyexhaustedlab -- memory exhaustion comes here. |
2257 `-------------------------------------------------*/
2258 yyexhaustedlab:
2259 yyerror (YY_("memory exhausted"));
2260 yyresult = 2;
2261 /* Fall through. */
2262 #endif
2263
2264 yyreturn:
2265 if (yychar != YYEOF && yychar != YYEMPTY)
2266 yydestruct ("Cleanup: discarding lookahead",
2267 yytoken, &yylval);
2268 /* Do not reclaim the symbols of the rule which action triggered
2269 this YYABORT or YYACCEPT. */
2270 YYPOPSTACK (yylen);
2271 YY_STACK_PRINT (yyss, yyssp);
2272 while (yyssp != yyss)
2273 {
2274 yydestruct ("Cleanup: popping",
2275 yystos[*yyssp], yyvsp);
2276 YYPOPSTACK (1);
2277 }
2278 #ifndef yyoverflow
2279 if (yyss != yyssa)
2280 YYSTACK_FREE (yyss);
2281 #endif
2282 #if YYERROR_VERBOSE
2283 if (yymsg != yymsgbuf)
2284 YYSTACK_FREE (yymsg);
2285 #endif
2286 /* Make sure YYID is used. */
2287 return YYID (yyresult);
2288 }
2289
2290
2291
2292
2293
2294 void conf_parse(const char *name)
2295 {
2296 struct symbol *sym;
2297 int i;
2298
2299 zconf_initscan(name);
2300
2301 sym_init();
2302 _menu_init();
2303 modules_sym = sym_lookup(NULL, 0);
2304 modules_sym->type = S_BOOLEAN;
2305 modules_sym->flags |= SYMBOL_AUTO;
2306 rootmenu.prompt = menu_add_prompt(P_MENU, "Linux Kernel Configuration", NULL);
2307
2308 #if YYDEBUG
2309 if (getenv("ZCONF_DEBUG"))
2310 zconfdebug = 1;
2311 #endif
2312 zconfparse();
2313 if (zconfnerrs)
2314 exit(1);
2315 if (!modules_sym->prop) {
2316 struct property *prop;
2317
2318 prop = prop_alloc(P_DEFAULT, modules_sym);
2319 prop->expr = expr_alloc_symbol(sym_lookup("MODULES", 0));
2320 }
2321
2322 rootmenu.prompt->text = _(rootmenu.prompt->text);
2323 rootmenu.prompt->text = sym_expand_string_value(rootmenu.prompt->text);
2324
2325 menu_finalize(&rootmenu);
2326 for_all_symbols(i, sym) {
2327 if (sym_check_deps(sym))
2328 zconfnerrs++;
2329 }
2330 if (zconfnerrs)
2331 exit(1);
2332 sym_set_change_count(1);
2333 }
2334
2335 static const char *zconf_tokenname(int token)
2336 {
2337 switch (token) {
2338 case T_MENU: return "menu";
2339 case T_ENDMENU: return "endmenu";
2340 case T_CHOICE: return "choice";
2341 case T_ENDCHOICE: return "endchoice";
2342 case T_IF: return "if";
2343 case T_ENDIF: return "endif";
2344 case T_DEPENDS: return "depends";
2345 case T_VISIBLE: return "visible";
2346 }
2347 return "<token>";
2348 }
2349
2350 static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken)
2351 {
2352 if (id->token != endtoken) {
2353 zconf_error("unexpected '%s' within %s block",
2354 kconf_id_strings + id->name, zconf_tokenname(starttoken));
2355 zconfnerrs++;
2356 return false;
2357 }
2358 if (current_menu->file != current_file) {
2359 zconf_error("'%s' in different file than '%s'",
2360 kconf_id_strings + id->name, zconf_tokenname(starttoken));
2361 fprintf(stderr, "%s:%d: location of the '%s'\n",
2362 current_menu->file->name, current_menu->lineno,
2363 zconf_tokenname(starttoken));
2364 zconfnerrs++;
2365 return false;
2366 }
2367 return true;
2368 }
2369
2370 static void zconfprint(const char *err, ...)
2371 {
2372 va_list ap;
2373
2374 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
2375 va_start(ap, err);
2376 vfprintf(stderr, err, ap);
2377 va_end(ap);
2378 fprintf(stderr, "\n");
2379 }
2380
2381 static void zconf_error(const char *err, ...)
2382 {
2383 va_list ap;
2384
2385 zconfnerrs++;
2386 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
2387 va_start(ap, err);
2388 vfprintf(stderr, err, ap);
2389 va_end(ap);
2390 fprintf(stderr, "\n");
2391 }
2392
2393 static void zconferror(const char *err)
2394 {
2395 fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
2396 }
2397
2398 static void print_quoted_string(FILE *out, const char *str)
2399 {
2400 const char *p;
2401 int len;
2402
2403 putc('"', out);
2404 while ((p = strchr(str, '"'))) {
2405 len = p - str;
2406 if (len)
2407 fprintf(out, "%.*s", len, str);
2408 fputs("\\\"", out);
2409 str = p + 1;
2410 }
2411 fputs(str, out);
2412 putc('"', out);
2413 }
2414
2415 static void print_symbol(FILE *out, struct menu *menu)
2416 {
2417 struct symbol *sym = menu->sym;
2418 struct property *prop;
2419
2420 if (sym_is_choice(sym))
2421 fprintf(out, "\nchoice\n");
2422 else
2423 fprintf(out, "\nconfig %s\n", sym->name);
2424 switch (sym->type) {
2425 case S_BOOLEAN:
2426 fputs(" boolean\n", out);
2427 break;
2428 case S_TRISTATE:
2429 fputs(" tristate\n", out);
2430 break;
2431 case S_STRING:
2432 fputs(" string\n", out);
2433 break;
2434 case S_INT:
2435 fputs(" integer\n", out);
2436 break;
2437 case S_HEX:
2438 fputs(" hex\n", out);
2439 break;
2440 default:
2441 fputs(" ???\n", out);
2442 break;
2443 }
2444 for (prop = sym->prop; prop; prop = prop->next) {
2445 if (prop->menu != menu)
2446 continue;
2447 switch (prop->type) {
2448 case P_PROMPT:
2449 fputs(" prompt ", out);
2450 print_quoted_string(out, prop->text);
2451 if (!expr_is_yes(prop->visible.expr)) {
2452 fputs(" if ", out);
2453 expr_fprint(prop->visible.expr, out);
2454 }
2455 fputc('\n', out);
2456 break;
2457 case P_DEFAULT:
2458 fputs( " default ", out);
2459 expr_fprint(prop->expr, out);
2460 if (!expr_is_yes(prop->visible.expr)) {
2461 fputs(" if ", out);
2462 expr_fprint(prop->visible.expr, out);
2463 }
2464 fputc('\n', out);
2465 break;
2466 case P_CHOICE:
2467 fputs(" #choice value\n", out);
2468 break;
2469 case P_SELECT:
2470 fputs( " select ", out);
2471 expr_fprint(prop->expr, out);
2472 fputc('\n', out);
2473 break;
2474 case P_RANGE:
2475 fputs( " range ", out);
2476 expr_fprint(prop->expr, out);
2477 fputc('\n', out);
2478 break;
2479 case P_MENU:
2480 fputs( " menu ", out);
2481 print_quoted_string(out, prop->text);
2482 fputc('\n', out);
2483 break;
2484 default:
2485 fprintf(out, " unknown prop %d!\n", prop->type);
2486 break;
2487 }
2488 }
2489 if (menu->help) {
2490 int len = strlen(menu->help);
2491 while (menu->help[--len] == '\n')
2492 menu->help[len] = 0;
2493 fprintf(out, " help\n%s\n", menu->help);
2494 }
2495 }
2496
2497 void zconfdump(FILE *out)
2498 {
2499 struct property *prop;
2500 struct symbol *sym;
2501 struct menu *menu;
2502
2503 menu = rootmenu.list;
2504 while (menu) {
2505 if ((sym = menu->sym))
2506 print_symbol(out, menu);
2507 else if ((prop = menu->prompt)) {
2508 switch (prop->type) {
2509 case P_COMMENT:
2510 fputs("\ncomment ", out);
2511 print_quoted_string(out, prop->text);
2512 fputs("\n", out);
2513 break;
2514 case P_MENU:
2515 fputs("\nmenu ", out);
2516 print_quoted_string(out, prop->text);
2517 fputs("\n", out);
2518 break;
2519 default:
2520 ;
2521 }
2522 if (!expr_is_yes(prop->visible.expr)) {
2523 fputs(" depends ", out);
2524 expr_fprint(prop->visible.expr, out);
2525 fputc('\n', out);
2526 }
2527 }
2528
2529 if (menu->list)
2530 menu = menu->list;
2531 else if (menu->next)
2532 menu = menu->next;
2533 else while ((menu = menu->parent)) {
2534 if (menu->prompt && menu->prompt->type == P_MENU)
2535 fputs("\nendmenu\n", out);
2536 if (menu->next) {
2537 menu = menu->next;
2538 break;
2539 }
2540 }
2541 }
2542 }
2543
2544 #include "zconf.lex.c"
2545 #include "util.c"
2546 #include "confdata.c"
2547 #include "expr.c"
2548 #include "symbol.c"
2549 #include "menu.c"
2550
OpenWrt Source Repository