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