| blob | 9b529ae2d3b3245edfcb762d7a56d42d82ca43b5 |
1 /* A Bison parser, made from zconf.y, by GNU bison 1.75. */
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
26 /* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
29 /* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
36 /* Identify Bison output. */
37 #define YYBISON 1
39 /* Pure parsers. */
40 #define YYPURE 0
42 /* Using locations. */
43 #define YYLSP_NEEDED 0
45 /* If NAME_PREFIX is specified substitute the variables and functions
46 names. */
47 #define yyparse zconfparse
48 #define yylex zconflex
49 #define yyerror zconferror
50 #define yylval zconflval
51 #define yychar zconfchar
52 #define yydebug zconfdebug
53 #define yynerrs zconfnerrs
56 /* Tokens. */
57 #ifndef YYTOKENTYPE
58 # define YYTOKENTYPE
59 /* Put the tokens into the symbol table, so that GDB and other debuggers
60 know about them. */
61 enum yytokentype {
62 T_MAINMENU = 258,
63 T_MENU = 259,
64 T_ENDMENU = 260,
65 T_SOURCE = 261,
66 T_CHOICE = 262,
67 T_ENDCHOICE = 263,
68 T_COMMENT = 264,
69 T_CONFIG = 265,
70 T_HELP = 266,
71 T_HELPTEXT = 267,
72 T_IF = 268,
73 T_ENDIF = 269,
74 T_DEPENDS = 270,
75 T_REQUIRES = 271,
76 T_OPTIONAL = 272,
77 T_PROMPT = 273,
78 T_DEFAULT = 274,
79 T_TRISTATE = 275,
80 T_BOOLEAN = 276,
81 T_INT = 277,
82 T_HEX = 278,
83 T_WORD = 279,
84 T_STRING = 280,
85 T_UNEQUAL = 281,
86 T_EOF = 282,
87 T_EOL = 283,
88 T_CLOSE_PAREN = 284,
89 T_OPEN_PAREN = 285,
90 T_ON = 286,
91 T_OR = 287,
92 T_AND = 288,
93 T_EQUAL = 289,
94 T_NOT = 290
95 };
96 #endif
97 #define T_MAINMENU 258
98 #define T_MENU 259
99 #define T_ENDMENU 260
100 #define T_SOURCE 261
101 #define T_CHOICE 262
102 #define T_ENDCHOICE 263
103 #define T_COMMENT 264
104 #define T_CONFIG 265
105 #define T_HELP 266
106 #define T_HELPTEXT 267
107 #define T_IF 268
108 #define T_ENDIF 269
109 #define T_DEPENDS 270
110 #define T_REQUIRES 271
111 #define T_OPTIONAL 272
112 #define T_PROMPT 273
113 #define T_DEFAULT 274
114 #define T_TRISTATE 275
115 #define T_BOOLEAN 276
116 #define T_INT 277
117 #define T_HEX 278
118 #define T_WORD 279
119 #define T_STRING 280
120 #define T_UNEQUAL 281
121 #define T_EOF 282
122 #define T_EOL 283
123 #define T_CLOSE_PAREN 284
124 #define T_OPEN_PAREN 285
125 #define T_ON 286
126 #define T_OR 287
127 #define T_AND 288
128 #define T_EQUAL 289
129 #define T_NOT 290
134 /* Copy the first part of user declarations. */
135 #line 1 "zconf.y"
137 /*
138 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
139 * Released under the terms of the GNU GPL v2.0.
140 */
142 #include <ctype.h>
143 #include <stdarg.h>
144 #include <stdio.h>
145 #include <stdlib.h>
146 #include <string.h>
147 #include <stdbool.h>
149 #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
151 #define PRINTD 0x0001
152 #define DEBUG_PARSE 0x0002
154 int cdebug = PRINTD;
156 extern int zconflex(void);
157 static void zconfprint(const char *err, ...);
158 static void zconferror(const char *err);
159 static bool zconf_endtoken(int token, int starttoken, int endtoken);
161 struct symbol *symbol_hash[257];
163 #define YYERROR_VERBOSE
166 /* Enabling traces. */
167 #ifndef YYDEBUG
168 # define YYDEBUG 1
169 #endif
171 /* Enabling verbose error messages. */
172 #ifdef YYERROR_VERBOSE
173 # undef YYERROR_VERBOSE
174 # define YYERROR_VERBOSE 1
175 #else
176 # define YYERROR_VERBOSE 0
177 #endif
179 #ifndef YYSTYPE
180 #line 33 "zconf.y"
181 typedef union {
182 int token;
183 char *string;
184 struct symbol *symbol;
185 struct expr *expr;
186 struct menu *menu;
187 } yystype;
188 /* Line 193 of /usr/share/bison/yacc.c. */
189 #line 190 "zconf.tab.c"
190 # define YYSTYPE yystype
191 # define YYSTYPE_IS_TRIVIAL 1
192 #endif
194 #ifndef YYLTYPE
195 typedef struct yyltype
196 {
197 int first_line;
198 int first_column;
199 int last_line;
200 int last_column;
201 } yyltype;
202 # define YYLTYPE yyltype
203 # define YYLTYPE_IS_TRIVIAL 1
204 #endif
206 /* Copy the second part of user declarations. */
207 #line 83 "zconf.y"
209 #define LKC_DIRECT_LINK
210 #include "lkc.h"
213 /* Line 213 of /usr/share/bison/yacc.c. */
214 #line 215 "zconf.tab.c"
216 #if !defined(yyoverflow) || YYERROR_VERBOSE
218 /* The parser invokes alloca or malloc; define the necessary symbols. */
220 # if YYSTACK_USE_ALLOCA
221 # define YYSTACK_ALLOC alloca
222 # else
223 # ifndef YYSTACK_USE_ALLOCA
224 # if defined (alloca) || defined (_ALLOCA_H)
225 # define YYSTACK_ALLOC alloca
226 # else
227 # ifdef __GNUC__
228 # define YYSTACK_ALLOC __builtin_alloca
229 # endif
230 # endif
231 # endif
232 # endif
234 # ifdef YYSTACK_ALLOC
235 /* Pacify GCC's `empty if-body' warning. */
236 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
237 # else
238 # if defined (__STDC__) || defined (__cplusplus)
239 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
240 # define YYSIZE_T size_t
241 # endif
242 # define YYSTACK_ALLOC malloc
243 # define YYSTACK_FREE free
244 # endif
245 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
248 #if (!defined(yyoverflow) \
249 && (! defined (__cplusplus) \
250 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
252 /* A type that is properly aligned for any stack member. */
253 union yyalloc
254 {
255 short yyss;
256 YYSTYPE yyvs;
257 };
259 /* The size of the maximum gap between one aligned stack and the next. */
260 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
262 /* The size of an array large to enough to hold all stacks, each with
263 N elements. */
264 # define YYSTACK_BYTES(N) \
265 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
266 + YYSTACK_GAP_MAX)
268 /* Copy COUNT objects from FROM to TO. The source and destination do
269 not overlap. */
270 # ifndef YYCOPY
271 # if 1 < __GNUC__
272 # define YYCOPY(To, From, Count) \
273 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
274 # else
275 # define YYCOPY(To, From, Count) \
276 do \
277 { \
278 register YYSIZE_T yyi; \
279 for (yyi = 0; yyi < (Count); yyi++) \
280 (To)[yyi] = (From)[yyi]; \
281 } \
282 while (0)
283 # endif
284 # endif
286 /* Relocate STACK from its old location to the new one. The
287 local variables YYSIZE and YYSTACKSIZE give the old and new number of
288 elements in the stack, and YYPTR gives the new location of the
289 stack. Advance YYPTR to a properly aligned location for the next
290 stack. */
291 # define YYSTACK_RELOCATE(Stack) \
292 do \
293 { \
294 YYSIZE_T yynewbytes; \
295 YYCOPY (&yyptr->Stack, Stack, yysize); \
296 Stack = &yyptr->Stack; \
297 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
298 yyptr += yynewbytes / sizeof (*yyptr); \
299 } \
300 while (0)
302 #endif
304 #if defined(__STDC__) || defined(__cplusplus)
305 typedef signed char yysigned_char;
306 #else
307 typedef short yysigned_char;
308 #endif
310 /* YYFINAL -- State number of the termination state. */
311 #define YYFINAL 2
312 #define YYLAST 151
314 /* YYNTOKENS -- Number of terminals. */
315 #define YYNTOKENS 36
316 /* YYNNTS -- Number of nonterminals. */
317 #define YYNNTS 39
318 /* YYNRULES -- Number of rules. */
319 #define YYNRULES 96
320 /* YYNRULES -- Number of states. */
321 #define YYNSTATES 145
323 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
324 #define YYUNDEFTOK 2
325 #define YYMAXUTOK 290
327 #define YYTRANSLATE(X) \
328 ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
330 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
331 static const unsigned char yytranslate[] =
332 {
333 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
334 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
335 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
336 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
337 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
338 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
339 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
340 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
341 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
342 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
343 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
344 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
345 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
346 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
347 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
348 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
349 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
350 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
351 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
352 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
353 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
354 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
355 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
356 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
357 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
358 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
359 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
360 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
361 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
362 35
363 };
365 #if YYDEBUG
366 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
367 YYRHS. */
368 static const unsigned short yyprhs[] =
369 {
370 0, 0, 3, 4, 7, 9, 11, 13, 17, 19,
371 21, 23, 26, 28, 30, 32, 34, 36, 39, 43,
372 44, 48, 52, 55, 58, 61, 64, 67, 70, 73,
373 77, 81, 83, 87, 89, 94, 97, 98, 102, 106,
374 109, 112, 116, 118, 121, 122, 125, 128, 130, 136,
375 140, 141, 144, 147, 150, 153, 157, 159, 164, 167,
376 168, 171, 174, 177, 181, 184, 187, 190, 194, 197,
377 200, 201, 205, 208, 212, 215, 218, 219, 221, 225,
378 227, 229, 231, 233, 235, 237, 239, 240, 243, 245,
379 249, 253, 257, 260, 264, 268, 270
380 };
382 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
383 static const yysigned_char yyrhs[] =
384 {
385 37, 0, -1, -1, 37, 38, -1, 39, -1, 47,
386 -1, 58, -1, 3, 69, 71, -1, 5, -1, 14,
387 -1, 8, -1, 1, 71, -1, 53, -1, 63, -1,
388 41, -1, 61, -1, 71, -1, 10, 24, -1, 40,
389 28, 42, -1, -1, 42, 43, 28, -1, 42, 67,
390 28, -1, 42, 65, -1, 42, 28, -1, 20, 68,
391 -1, 21, 68, -1, 22, 68, -1, 23, 68, -1,
392 25, 68, -1, 18, 69, 72, -1, 19, 74, 72,
393 -1, 7, -1, 44, 28, 48, -1, 70, -1, 45,
394 50, 46, 28, -1, 45, 50, -1, -1, 48, 49,
395 28, -1, 48, 67, 28, -1, 48, 65, -1, 48,
396 28, -1, 18, 69, 72, -1, 17, -1, 19, 74,
397 -1, -1, 50, 39, -1, 13, 73, -1, 70, -1,
398 51, 28, 54, 52, 28, -1, 51, 28, 54, -1,
399 -1, 54, 39, -1, 54, 58, -1, 54, 47, -1,
400 4, 69, -1, 55, 28, 66, -1, 70, -1, 56,
401 59, 57, 28, -1, 56, 59, -1, -1, 59, 39,
402 -1, 59, 58, -1, 59, 47, -1, 59, 1, 28,
403 -1, 6, 69, -1, 60, 28, -1, 9, 69, -1,
404 62, 28, 66, -1, 11, 28, -1, 64, 12, -1,
405 -1, 66, 67, 28, -1, 66, 28, -1, 15, 31,
406 73, -1, 15, 73, -1, 16, 73, -1, -1, 69,
407 -1, 69, 13, 73, -1, 24, -1, 25, -1, 5,
408 -1, 8, -1, 14, -1, 28, -1, 27, -1, -1,
409 13, 73, -1, 74, -1, 74, 34, 74, -1, 74,
410 26, 74, -1, 30, 73, 29, -1, 35, 73, -1,
411 73, 32, 73, -1, 73, 33, 73, -1, 24, -1,
412 25, -1
413 };
415 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
416 static const unsigned short yyrline[] =
417 {
418 0, 88, 88, 89, 92, 93, 94, 95, 96, 97,
419 98, 99, 102, 104, 105, 106, 107, 113, 121, 127,
420 129, 130, 131, 132, 135, 141, 147, 153, 159, 165,
421 171, 179, 188, 194, 202, 204, 210, 212, 213, 214,
422 215, 218, 224, 230, 237, 239, 244, 254, 262, 264,
423 270, 272, 273, 274, 279, 286, 292, 300, 302, 308,
424 310, 311, 312, 313, 316, 322, 329, 336, 343, 349,
425 356, 357, 358, 361, 366, 371, 379, 381, 385, 390,
426 391, 394, 395, 396, 399, 400, 402, 403, 406, 407,
427 408, 409, 410, 411, 412, 415, 416
428 };
429 #endif
431 #if YYDEBUG || YYERROR_VERBOSE
432 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
433 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
434 static const char *const yytname[] =
435 {
436 "$end", "error", "$undefined", "T_MAINMENU", "T_MENU", "T_ENDMENU",
437 "T_SOURCE", "T_CHOICE", "T_ENDCHOICE", "T_COMMENT", "T_CONFIG",
438 "T_HELP", "T_HELPTEXT", "T_IF", "T_ENDIF", "T_DEPENDS", "T_REQUIRES",
439 "T_OPTIONAL", "T_PROMPT", "T_DEFAULT", "T_TRISTATE", "T_BOOLEAN",
440 "T_INT", "T_HEX", "T_WORD", "T_STRING", "T_UNEQUAL", "T_EOF", "T_EOL",
441 "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_ON", "T_OR", "T_AND", "T_EQUAL",
442 "T_NOT", "$accept", "input", "block", "common_block",
443 "config_entry_start", "config_stmt", "config_option_list",
444 "config_option", "choice", "choice_entry", "choice_end", "choice_stmt",
445 "choice_option_list", "choice_option", "choice_block", "if", "if_end",
446 "if_stmt", "if_block", "menu", "menu_entry", "menu_end", "menu_stmt",
447 "menu_block", "source", "source_stmt", "comment", "comment_stmt",
448 "help_start", "help", "depends_list", "depends", "prompt_stmt_opt",
449 "prompt", "end", "nl_or_eof", "if_expr", "expr", "symbol", 0
450 };
451 #endif
453 # ifdef YYPRINT
454 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
455 token YYLEX-NUM. */
456 static const unsigned short yytoknum[] =
457 {
458 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
459 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
460 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
461 285, 286, 287, 288, 289, 290
462 };
463 # endif
465 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
466 static const unsigned char yyr1[] =
467 {
468 0, 36, 37, 37, 38, 38, 38, 38, 38, 38,
469 38, 38, 39, 39, 39, 39, 39, 40, 41, 42,
470 42, 42, 42, 42, 43, 43, 43, 43, 43, 43,
471 43, 44, 45, 46, 47, 47, 48, 48, 48, 48,
472 48, 49, 49, 49, 50, 50, 51, 52, 53, 53,
473 54, 54, 54, 54, 55, 56, 57, 58, 58, 59,
474 59, 59, 59, 59, 60, 61, 62, 63, 64, 65,
475 66, 66, 66, 67, 67, 67, 68, 68, 68, 69,
476 69, 70, 70, 70, 71, 71, 72, 72, 73, 73,
477 73, 73, 73, 73, 73, 74, 74
478 };
480 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
481 static const unsigned char yyr2[] =
482 {
483 0, 2, 0, 2, 1, 1, 1, 3, 1, 1,
484 1, 2, 1, 1, 1, 1, 1, 2, 3, 0,
485 3, 3, 2, 2, 2, 2, 2, 2, 2, 3,
486 3, 1, 3, 1, 4, 2, 0, 3, 3, 2,
487 2, 3, 1, 2, 0, 2, 2, 1, 5, 3,
488 0, 2, 2, 2, 2, 3, 1, 4, 2, 0,
489 2, 2, 2, 3, 2, 2, 2, 3, 2, 2,
490 0, 3, 2, 3, 2, 2, 0, 1, 3, 1,
491 1, 1, 1, 1, 1, 1, 0, 2, 1, 3,
492 3, 3, 2, 3, 3, 1, 1
493 };
495 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
496 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
497 means the default is an error. */
498 static const unsigned char yydefact[] =
499 {
500 2, 0, 1, 0, 0, 0, 8, 0, 31, 10,
501 0, 0, 0, 9, 85, 84, 3, 4, 0, 14,
502 0, 44, 5, 0, 12, 0, 59, 6, 0, 15,
503 0, 13, 16, 11, 79, 80, 0, 54, 64, 66,
504 17, 95, 96, 0, 0, 46, 88, 19, 36, 35,
505 50, 70, 0, 65, 70, 7, 0, 92, 0, 0,
506 0, 0, 18, 32, 81, 82, 83, 45, 0, 33,
507 49, 55, 0, 60, 62, 0, 61, 56, 67, 91,
508 93, 94, 90, 89, 0, 0, 0, 0, 0, 76,
509 76, 76, 76, 76, 23, 0, 0, 22, 0, 42,
510 0, 0, 40, 0, 39, 0, 34, 51, 53, 0,
511 52, 47, 72, 0, 63, 57, 68, 0, 74, 75,
512 86, 86, 24, 77, 25, 26, 27, 28, 20, 69,
513 21, 86, 43, 37, 38, 48, 71, 73, 0, 29,
514 30, 0, 41, 87, 78
515 };
517 /* YYDEFGOTO[NTERM-NUM]. */
518 static const short yydefgoto[] =
519 {
520 -1, 1, 16, 17, 18, 19, 62, 95, 20, 21,
521 68, 22, 63, 103, 49, 23, 109, 24, 70, 25,
522 26, 75, 27, 52, 28, 29, 30, 31, 96, 97,
523 71, 113, 122, 123, 69, 32, 139, 45, 46
524 };
526 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
527 STATE-NUM. */
528 #define YYPACT_NINF -120
529 static const short yypact[] =
530 {
531 -120, 17, -120, 41, 48, 48, -120, 48, -120, -120,
532 48, -11, 40, -120, -120, -120, -120, -120, 13, -120,
533 23, -120, -120, 66, -120, 72, -120, -120, 77, -120,
534 81, -120, -120, -120, -120, -120, 41, -120, -120, -120,
535 -120, -120, -120, 40, 40, 57, 59, -120, -120, 98,
536 -120, -120, 49, -120, -120, -120, 7, -120, 40, 40,
537 67, 67, 99, 117, -120, -120, -120, -120, 85, -120,
538 74, 18, 88, -120, -120, 95, -120, -120, 18, -120,
539 96, -120, -120, -120, 102, 36, 40, 48, 67, 48,
540 48, 48, 48, 48, -120, 103, 129, -120, 114, -120,
541 48, 67, -120, 115, -120, 116, -120, -120, -120, 118,
542 -120, -120, -120, 119, -120, -120, -120, 40, 57, 57,
543 135, 135, -120, 136, -120, -120, -120, -120, -120, -120,
544 -120, 135, -120, -120, -120, -120, -120, 57, 40, -120,
545 -120, 40, -120, 57, 57
546 };
548 /* YYPGOTO[NTERM-NUM]. */
549 static const yysigned_char yypgoto[] =
550 {
551 -120, -120, -120, -38, -120, -120, -120, -120, -120, -120,
552 -120, -42, -120, -120, -120, -120, -120, -120, -120, -120,
553 -120, -120, -33, -120, -120, -120, -120, -120, -120, 87,
554 97, 34, 47, -1, -23, 2, -119, -43, -53
555 };
557 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
558 positive, shift that token. If negative, reduce the rule which
559 number is the opposite. If zero, do what YYDEFACT says.
560 If YYTABLE_NINF, parse error. */
561 #define YYTABLE_NINF -59
562 static const short yytable[] =
563 {
564 56, 57, 140, 36, 37, 33, 38, 82, 83, 39,
565 74, 67, 142, 40, 73, 80, 81, 2, 3, 76,
566 4, 5, 6, 7, 8, 9, 10, 11, 108, 77,
567 12, 13, 107, 85, 86, 121, 79, 110, 55, 58,
568 59, 47, 118, 119, 14, 15, 112, 111, 132, -58,
569 72, 48, -58, 5, 64, 7, 8, 65, 10, 11,
570 41, 42, 12, 66, 41, 42, 43, 117, 14, 15,
571 43, 44, 34, 35, 137, 44, 14, 15, 5, 64,
572 7, 8, 65, 10, 11, 60, 120, 12, 66, 58,
573 59, 41, 42, 61, 50, 143, 98, 105, 144, 131,
574 51, 14, 15, 64, 7, 53, 65, 10, 11, 54,
575 84, 12, 66, 106, 85, 86, 114, 87, 88, 89,
576 90, 91, 92, 115, 93, 14, 15, 94, 84, 59,
577 116, 128, 85, 86, 99, 100, 101, 124, 125, 126,
578 127, 129, 130, 133, 134, 102, 135, 136, 138, 141,
579 104, 78
580 };
582 static const unsigned char yycheck[] =
583 {
584 43, 44, 121, 4, 5, 3, 7, 60, 61, 10,
585 52, 49, 131, 24, 52, 58, 59, 0, 1, 52,
586 3, 4, 5, 6, 7, 8, 9, 10, 70, 52,
587 13, 14, 70, 15, 16, 88, 29, 70, 36, 32,
588 33, 28, 85, 86, 27, 28, 28, 70, 101, 0,
589 1, 28, 3, 4, 5, 6, 7, 8, 9, 10,
590 24, 25, 13, 14, 24, 25, 30, 31, 27, 28,
591 30, 35, 24, 25, 117, 35, 27, 28, 4, 5,
592 6, 7, 8, 9, 10, 26, 87, 13, 14, 32,
593 33, 24, 25, 34, 28, 138, 62, 63, 141, 100,
594 28, 27, 28, 5, 6, 28, 8, 9, 10, 28,
595 11, 13, 14, 28, 15, 16, 28, 18, 19, 20,
596 21, 22, 23, 28, 25, 27, 28, 28, 11, 33,
597 28, 28, 15, 16, 17, 18, 19, 90, 91, 92,
598 93, 12, 28, 28, 28, 28, 28, 28, 13, 13,
599 63, 54
600 };
602 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
603 symbol of state STATE-NUM. */
604 static const unsigned char yystos[] =
605 {
606 0, 37, 0, 1, 3, 4, 5, 6, 7, 8,
607 9, 10, 13, 14, 27, 28, 38, 39, 40, 41,
608 44, 45, 47, 51, 53, 55, 56, 58, 60, 61,
609 62, 63, 71, 71, 24, 25, 69, 69, 69, 69,
610 24, 24, 25, 30, 35, 73, 74, 28, 28, 50,
611 28, 28, 59, 28, 28, 71, 73, 73, 32, 33,
612 26, 34, 42, 48, 5, 8, 14, 39, 46, 70,
613 54, 66, 1, 39, 47, 57, 58, 70, 66, 29,
614 73, 73, 74, 74, 11, 15, 16, 18, 19, 20,
615 21, 22, 23, 25, 28, 43, 64, 65, 67, 17,
616 18, 19, 28, 49, 65, 67, 28, 39, 47, 52,
617 58, 70, 28, 67, 28, 28, 28, 31, 73, 73,
618 69, 74, 68, 69, 68, 68, 68, 68, 28, 12,
619 28, 69, 74, 28, 28, 28, 28, 73, 13, 72,
620 72, 13, 72, 73, 73
621 };
623 #if !defined(YYSIZE_T) && defined(__SIZE_TYPE__)
624 # define YYSIZE_T __SIZE_TYPE__
625 #endif
626 #if !defined(YYSIZE_T) && defined(size_t)
627 # define YYSIZE_T size_t
628 #endif
629 #if !defined(YYSIZE_T)
630 # if defined (__STDC__) || defined (__cplusplus)
631 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
632 # define YYSIZE_T size_t
633 # endif
634 #endif
635 #if !defined(YYSIZE_T)
636 # define YYSIZE_T unsigned int
637 #endif
639 #define yyerrok (yyerrstatus = 0)
640 #define yyclearin (yychar = YYEMPTY)
641 #define YYEMPTY -2
642 #define YYEOF 0
644 #define YYACCEPT goto yyacceptlab
645 #define YYABORT goto yyabortlab
646 #define YYERROR goto yyerrlab1
648 /* Like YYERROR except do call yyerror. This remains here temporarily
649 to ease the transition to the new meaning of YYERROR, for GCC.
650 Once GCC version 2 has supplanted version 1, this can go. */
652 #define YYFAIL goto yyerrlab
654 #define YYRECOVERING() (!!yyerrstatus)
656 #define YYBACKUP(Token, Value) \
657 do \
658 if (yychar == YYEMPTY && yylen == 1) \
659 { \
660 yychar = (Token); \
661 yylval = (Value); \
662 yychar1 = YYTRANSLATE (yychar); \
663 YYPOPSTACK; \
664 goto yybackup; \
665 } \
666 else \
667 { \
668 yyerror ("syntax error: cannot back up"); \
669 YYERROR; \
670 } \
671 while (0)
673 #define YYTERROR 1
674 #define YYERRCODE 256
676 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
677 are run). */
679 #ifndef YYLLOC_DEFAULT
680 # define YYLLOC_DEFAULT(Current, Rhs, N) \
681 Current.first_line = Rhs[1].first_line; \
682 Current.first_column = Rhs[1].first_column; \
683 Current.last_line = Rhs[N].last_line; \
684 Current.last_column = Rhs[N].last_column;
685 #endif
687 /* YYLEX -- calling `yylex' with the right arguments. */
689 #define YYLEX yylex ()
691 /* Enable debugging if requested. */
692 #if YYDEBUG
694 # ifndef YYFPRINTF
695 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
696 # define YYFPRINTF fprintf
697 # endif
699 # define YYDPRINTF(Args) \
700 do { \
701 if (yydebug) \
702 YYFPRINTF Args; \
703 } while (0)
704 # define YYDSYMPRINT(Args) \
705 do { \
706 if (yydebug) \
707 yysymprint Args; \
708 } while (0)
709 /* Nonzero means print parse trace. It is left uninitialized so that
710 multiple parsers can coexist. */
711 int yydebug;
712 #else /* !YYDEBUG */
713 # define YYDPRINTF(Args)
714 # define YYDSYMPRINT(Args)
715 #endif /* !YYDEBUG */
717 /* YYINITDEPTH -- initial size of the parser's stacks. */
718 #ifndef YYINITDEPTH
719 # define YYINITDEPTH 200
720 #endif
722 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
723 if the built-in stack extension method is used).
725 Do not make this value too large; the results are undefined if
726 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
727 evaluated with infinite-precision integer arithmetic. */
729 #if YYMAXDEPTH == 0
730 # undef YYMAXDEPTH
731 #endif
733 #ifndef YYMAXDEPTH
734 # define YYMAXDEPTH 10000
735 #endif
737 \f
739 #if YYERROR_VERBOSE
741 # ifndef yystrlen
742 # if defined (__GLIBC__) && defined (_STRING_H)
743 # define yystrlen strlen
744 # else
745 /* Return the length of YYSTR. */
746 static YYSIZE_T
747 # if defined (__STDC__) || defined (__cplusplus)
748 yystrlen (const char *yystr)
749 # else
750 yystrlen (yystr)
751 const char *yystr;
752 # endif
753 {
754 register const char *yys = yystr;
756 while (*yys++ != '\0')
757 continue;
759 return yys - yystr - 1;
760 }
761 # endif
762 # endif
764 # ifndef yystpcpy
765 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
766 # define yystpcpy stpcpy
767 # else
768 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
769 YYDEST. */
770 static char *
771 # if defined (__STDC__) || defined (__cplusplus)
772 yystpcpy (char *yydest, const char *yysrc)
773 # else
774 yystpcpy (yydest, yysrc)
775 char *yydest;
776 const char *yysrc;
777 # endif
778 {
779 register char *yyd = yydest;
780 register const char *yys = yysrc;
782 while ((*yyd++ = *yys++) != '\0')
783 continue;
785 return yyd - 1;
786 }
787 # endif
788 # endif
790 #endif /* !YYERROR_VERBOSE */
792 \f
794 #if YYDEBUG
795 /*-----------------------------.
796 | Print this symbol on YYOUT. |
797 `-----------------------------*/
799 static void
800 #if defined(__STDC__) || defined(__cplusplus)
801 yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
802 #else
803 yysymprint (yyout, yytype, yyvalue)
804 FILE* yyout;
805 int yytype;
806 YYSTYPE yyvalue;
807 #endif
808 {
809 /* Pacify ``unused variable'' warnings. */
810 (void) yyvalue;
812 if (yytype < YYNTOKENS)
813 {
814 YYFPRINTF (yyout, "token %s (", yytname[yytype]);
815 # ifdef YYPRINT
816 YYPRINT (yyout, yytoknum[yytype], yyvalue);
817 # endif
818 }
819 else
820 YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
822 switch (yytype)
823 {
824 default:
825 break;
826 }
827 YYFPRINTF (yyout, ")");
828 }
829 #endif /* YYDEBUG. */
832 /*-----------------------------------------------.
833 | Release the memory associated to this symbol. |
834 `-----------------------------------------------*/
836 static void
837 #if defined(__STDC__) || defined(__cplusplus)
838 yydestruct (int yytype, YYSTYPE yyvalue)
839 #else
840 yydestruct (yytype, yyvalue)
841 int yytype;
842 YYSTYPE yyvalue;
843 #endif
844 {
845 /* Pacify ``unused variable'' warnings. */
846 (void) yyvalue;
848 switch (yytype)
849 {
850 default:
851 break;
852 }
853 }
855 \f
857 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
858 into yyparse. The argument should have type void *.
859 It should actually point to an object.
860 Grammar actions can access the variable by casting it
861 to the proper pointer type. */
863 #ifdef YYPARSE_PARAM
864 # if defined (__STDC__) || defined (__cplusplus)
865 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
866 # define YYPARSE_PARAM_DECL
867 # else
868 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
869 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
870 # endif
871 #else /* !YYPARSE_PARAM */
872 # define YYPARSE_PARAM_ARG
873 # define YYPARSE_PARAM_DECL
874 #endif /* !YYPARSE_PARAM */
876 /* Prevent warning if -Wstrict-prototypes. */
877 #ifdef __GNUC__
878 # ifdef YYPARSE_PARAM
879 int yyparse (void *);
880 # else
881 int yyparse (void);
882 # endif
883 #endif
886 /* The lookahead symbol. */
887 int yychar;
889 /* The semantic value of the lookahead symbol. */
890 YYSTYPE yylval;
892 /* Number of parse errors so far. */
893 int yynerrs;
896 int
897 yyparse (YYPARSE_PARAM_ARG)
898 YYPARSE_PARAM_DECL
899 {
901 register int yystate;
902 register int yyn;
903 int yyresult;
904 /* Number of tokens to shift before error messages enabled. */
905 int yyerrstatus;
906 /* Lookahead token as an internal (translated) token number. */
907 int yychar1 = 0;
909 /* Three stacks and their tools:
910 `yyss': related to states,
911 `yyvs': related to semantic values,
912 `yyls': related to locations.
914 Refer to the stacks thru separate pointers, to allow yyoverflow
915 to reallocate them elsewhere. */
917 /* The state stack. */
918 short yyssa[YYINITDEPTH];
919 short *yyss = yyssa;
920 register short *yyssp;
922 /* The semantic value stack. */
923 YYSTYPE yyvsa[YYINITDEPTH];
924 YYSTYPE *yyvs = yyvsa;
925 register YYSTYPE *yyvsp;
929 #define YYPOPSTACK (yyvsp--, yyssp--)
931 YYSIZE_T yystacksize = YYINITDEPTH;
933 /* The variables used to return semantic value and location from the
934 action routines. */
935 YYSTYPE yyval;
938 /* When reducing, the number of symbols on the RHS of the reduced
939 rule. */
940 int yylen;
942 YYDPRINTF ((stderr, "Starting parse\n"));
944 yystate = 0;
945 yyerrstatus = 0;
946 yynerrs = 0;
947 yychar = YYEMPTY; /* Cause a token to be read. */
949 /* Initialize stack pointers.
950 Waste one element of value and location stack
951 so that they stay on the same level as the state stack.
952 The wasted elements are never initialized. */
954 yyssp = yyss;
955 yyvsp = yyvs;
957 goto yysetstate;
959 /*------------------------------------------------------------.
960 | yynewstate -- Push a new state, which is found in yystate. |
961 `------------------------------------------------------------*/
962 yynewstate:
963 /* In all cases, when you get here, the value and location stacks
964 have just been pushed. so pushing a state here evens the stacks.
965 */
966 yyssp++;
968 yysetstate:
969 *yyssp = yystate;
971 if (yyssp >= yyss + yystacksize - 1)
972 {
973 /* Get the current used size of the three stacks, in elements. */
974 YYSIZE_T yysize = yyssp - yyss + 1;
976 #ifdef yyoverflow
977 {
978 /* Give user a chance to reallocate the stack. Use copies of
979 these so that the &'s don't force the real ones into
980 memory. */
981 YYSTYPE *yyvs1 = yyvs;
982 short *yyss1 = yyss;
985 /* Each stack pointer address is followed by the size of the
986 data in use in that stack, in bytes. This used to be a
987 conditional around just the two extra args, but that might
988 be undefined if yyoverflow is a macro. */
989 yyoverflow ("parser stack overflow",
990 &yyss1, yysize * sizeof (*yyssp),
991 &yyvs1, yysize * sizeof (*yyvsp),
993 &yystacksize);
995 yyss = yyss1;
996 yyvs = yyvs1;
997 }
998 #else /* no yyoverflow */
999 # ifndef YYSTACK_RELOCATE
1000 goto yyoverflowlab;
1001 # else
1002 /* Extend the stack our own way. */
1003 if (yystacksize >= YYMAXDEPTH)
1004 goto yyoverflowlab;
1005 yystacksize *= 2;
1006 if (yystacksize > YYMAXDEPTH)
1007 yystacksize = YYMAXDEPTH;
1009 {
1010 short *yyss1 = yyss;
1011 union yyalloc *yyptr =
1012 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1013 if (! yyptr)
1014 goto yyoverflowlab;
1015 YYSTACK_RELOCATE (yyss);
1016 YYSTACK_RELOCATE (yyvs);
1018 # undef YYSTACK_RELOCATE
1019 if (yyss1 != yyssa)
1020 YYSTACK_FREE (yyss1);
1021 }
1022 # endif
1023 #endif /* no yyoverflow */
1025 yyssp = yyss + yysize - 1;
1026 yyvsp = yyvs + yysize - 1;
1029 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1030 (unsigned long int) yystacksize));
1032 if (yyssp >= yyss + yystacksize - 1)
1033 YYABORT;
1034 }
1036 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1038 goto yybackup;
1040 /*-----------.
1041 | yybackup. |
1042 `-----------*/
1043 yybackup:
1045 /* Do appropriate processing given the current state. */
1046 /* Read a lookahead token if we need one and don't already have one. */
1047 /* yyresume: */
1049 /* First try to decide what to do without reference to lookahead token. */
1051 yyn = yypact[yystate];
1052 if (yyn == YYPACT_NINF)
1053 goto yydefault;
1055 /* Not known => get a lookahead token if don't already have one. */
1057 /* yychar is either YYEMPTY or YYEOF
1058 or a valid token in external form. */
1060 if (yychar == YYEMPTY)
1061 {
1062 YYDPRINTF ((stderr, "Reading a token: "));
1063 yychar = YYLEX;
1064 }
1066 /* Convert token to internal form (in yychar1) for indexing tables with. */
1068 if (yychar <= 0) /* This means end of input. */
1069 {
1070 yychar1 = 0;
1071 yychar = YYEOF; /* Don't call YYLEX any more. */
1073 YYDPRINTF ((stderr, "Now at end of input.\n"));
1074 }
1075 else
1076 {
1077 yychar1 = YYTRANSLATE (yychar);
1079 /* We have to keep this `#if YYDEBUG', since we use variables
1080 which are defined only if `YYDEBUG' is set. */
1081 YYDPRINTF ((stderr, "Next token is "));
1082 YYDSYMPRINT ((stderr, yychar1, yylval));
1083 YYDPRINTF ((stderr, "\n"));
1084 }
1086 /* If the proper action on seeing token YYCHAR1 is to reduce or to
1087 detect an error, take that action. */
1088 yyn += yychar1;
1089 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
1090 goto yydefault;
1091 yyn = yytable[yyn];
1092 if (yyn <= 0)
1093 {
1094 if (yyn == 0 || yyn == YYTABLE_NINF)
1095 goto yyerrlab;
1096 yyn = -yyn;
1097 goto yyreduce;
1098 }
1100 if (yyn == YYFINAL)
1101 YYACCEPT;
1103 /* Shift the lookahead token. */
1104 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
1105 yychar, yytname[yychar1]));
1107 /* Discard the token being shifted unless it is eof. */
1108 if (yychar != YYEOF)
1109 yychar = YYEMPTY;
1111 *++yyvsp = yylval;
1114 /* Count tokens shifted since error; after three, turn off error
1115 status. */
1116 if (yyerrstatus)
1117 yyerrstatus--;
1119 yystate = yyn;
1120 goto yynewstate;
1123 /*-----------------------------------------------------------.
1124 | yydefault -- do the default action for the current state. |
1125 `-----------------------------------------------------------*/
1126 yydefault:
1127 yyn = yydefact[yystate];
1128 if (yyn == 0)
1129 goto yyerrlab;
1130 goto yyreduce;
1133 /*-----------------------------.
1134 | yyreduce -- Do a reduction. |
1135 `-----------------------------*/
1136 yyreduce:
1137 /* yyn is the number of a rule to reduce with. */
1138 yylen = yyr2[yyn];
1140 /* If YYLEN is nonzero, implement the default value of the action:
1141 `$$ = $1'.
1143 Otherwise, the following line sets YYVAL to garbage.
1144 This behavior is undocumented and Bison
1145 users should not rely upon it. Assigning to YYVAL
1146 unconditionally makes the parser a bit smaller, and it avoids a
1147 GCC warning that YYVAL may be used uninitialized. */
1148 yyval = yyvsp[1-yylen];
1152 #if YYDEBUG
1153 /* We have to keep this `#if YYDEBUG', since we use variables which
1154 are defined only if `YYDEBUG' is set. */
1155 if (yydebug)
1156 {
1157 int yyi;
1159 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1160 yyn - 1, yyrline[yyn]);
1162 /* Print the symbols being reduced, and their result. */
1163 for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
1164 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1165 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1166 }
1167 #endif
1168 switch (yyn)
1169 {
1170 case 8:
1171 #line 96 "zconf.y"
1172 { zconfprint("unexpected 'endmenu' statement"); }
1173 break;
1175 case 9:
1176 #line 97 "zconf.y"
1177 { zconfprint("unexpected 'endif' statement"); }
1178 break;
1180 case 10:
1181 #line 98 "zconf.y"
1182 { zconfprint("unexpected 'endchoice' statement"); }
1183 break;
1185 case 11:
1186 #line 99 "zconf.y"
1187 { zconfprint("syntax error"); yyerrok; }
1188 break;
1190 case 17:
1191 #line 114 "zconf.y"
1192 {
1193 struct symbol *sym = sym_lookup(yyvsp[0].string, 0);
1194 sym->flags |= SYMBOL_OPTIONAL;
1195 menu_add_entry(sym);
1196 printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), yyvsp[0].string);
1197 }
1198 break;
1200 case 18:
1201 #line 122 "zconf.y"
1202 {
1203 menu_end_entry();
1204 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1205 }
1206 break;
1208 case 23:
1209 #line 133 "zconf.y"
1210 { }
1211 break;
1213 case 24:
1214 #line 136 "zconf.y"
1215 {
1216 menu_set_type(S_TRISTATE);
1217 printd(DEBUG_PARSE, "%s:%d:tristate\n", zconf_curname(), zconf_lineno());
1218 }
1219 break;
1221 case 25:
1222 #line 142 "zconf.y"
1223 {
1224 menu_set_type(S_BOOLEAN);
1225 printd(DEBUG_PARSE, "%s:%d:boolean\n", zconf_curname(), zconf_lineno());
1226 }
1227 break;
1229 case 26:
1230 #line 148 "zconf.y"
1231 {
1232 menu_set_type(S_INT);
1233 printd(DEBUG_PARSE, "%s:%d:int\n", zconf_curname(), zconf_lineno());
1234 }
1235 break;
1237 case 27:
1238 #line 154 "zconf.y"
1239 {
1240 menu_set_type(S_HEX);
1241 printd(DEBUG_PARSE, "%s:%d:hex\n", zconf_curname(), zconf_lineno());
1242 }
1243 break;
1245 case 28:
1246 #line 160 "zconf.y"
1247 {
1248 menu_set_type(S_STRING);
1249 printd(DEBUG_PARSE, "%s:%d:string\n", zconf_curname(), zconf_lineno());
1250 }
1251 break;
1253 case 29:
1254 #line 166 "zconf.y"
1255 {
1256 menu_add_prop(P_PROMPT, yyvsp[-1].string, NULL, yyvsp[0].expr);
1257 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1258 }
1259 break;
1261 case 30:
1262 #line 172 "zconf.y"
1263 {
1264 menu_add_prop(P_DEFAULT, NULL, yyvsp[-1].symbol, yyvsp[0].expr);
1265 printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno());
1266 }
1267 break;
1269 case 31:
1270 #line 180 "zconf.y"
1271 {
1272 struct symbol *sym = sym_lookup(NULL, 0);
1273 sym->flags |= SYMBOL_CHOICE;
1274 menu_add_entry(sym);
1275 menu_add_prop(P_CHOICE, NULL, NULL, NULL);
1276 printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
1277 }
1278 break;
1280 case 32:
1281 #line 189 "zconf.y"
1282 {
1283 menu_end_entry();
1284 menu_add_menu();
1285 }
1286 break;
1288 case 33:
1289 #line 195 "zconf.y"
1290 {
1291 if (zconf_endtoken(yyvsp[0].token, T_CHOICE, T_ENDCHOICE)) {
1292 menu_end_menu();
1293 printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
1294 }
1295 }
1296 break;
1298 case 35:
1299 #line 205 "zconf.y"
1300 {
1301 printf("%s:%d: missing 'endchoice' for this 'choice' statement\n", current_menu->file->name, current_menu->lineno);
1302 zconfnerrs++;
1303 }
1304 break;
1306 case 41:
1307 #line 219 "zconf.y"
1308 {
1309 menu_add_prop(P_PROMPT, yyvsp[-1].string, NULL, yyvsp[0].expr);
1310 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1311 }
1312 break;
1314 case 42:
1315 #line 225 "zconf.y"
1316 {
1317 current_entry->sym->flags |= SYMBOL_OPTIONAL;
1318 printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
1319 }
1320 break;
1322 case 43:
1323 #line 231 "zconf.y"
1324 {
1325 menu_add_prop(P_DEFAULT, NULL, yyvsp[0].symbol, NULL);
1326 //current_choice->prop->def = ;
1327 printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno());
1328 }
1329 break;
1331 case 46:
1332 #line 245 "zconf.y"
1333 {
1334 printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
1335 menu_add_entry(NULL);
1336 //current_entry->prompt = menu_add_prop(T_IF, NULL, NULL, );
1337 menu_add_dep(yyvsp[0].expr);
1338 menu_end_entry();
1339 menu_add_menu();
1340 }
1341 break;
1343 case 47:
1344 #line 255 "zconf.y"
1345 {
1346 if (zconf_endtoken(yyvsp[0].token, T_IF, T_ENDIF)) {
1347 menu_end_menu();
1348 printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
1349 }
1350 }
1351 break;
1353 case 49:
1354 #line 265 "zconf.y"
1355 {
1356 printf("%s:%d: missing 'endif' for this 'if' statement\n", current_menu->file->name, current_menu->lineno);
1357 zconfnerrs++;
1358 }
1359 break;
1361 case 54:
1362 #line 280 "zconf.y"
1363 {
1364 menu_add_entry(NULL);
1365 menu_add_prop(P_MENU, yyvsp[0].string, NULL, NULL);
1366 printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
1367 }
1368 break;
1370 case 55:
1371 #line 287 "zconf.y"
1372 {
1373 menu_end_entry();
1374 menu_add_menu();
1375 }
1376 break;
1378 case 56:
1379 #line 293 "zconf.y"
1380 {
1381 if (zconf_endtoken(yyvsp[0].token, T_MENU, T_ENDMENU)) {
1382 menu_end_menu();
1383 printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
1384 }
1385 }
1386 break;
1388 case 58:
1389 #line 303 "zconf.y"
1390 {
1391 printf("%s:%d: missing 'endmenu' for this 'menu' statement\n", current_menu->file->name, current_menu->lineno);
1392 zconfnerrs++;
1393 }
1394 break;
1396 case 63:
1397 #line 313 "zconf.y"
1398 { zconfprint("invalid menu option"); yyerrok; }
1399 break;
1401 case 64:
1402 #line 317 "zconf.y"
1403 {
1404 yyval.string = yyvsp[0].string;
1405 printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), yyvsp[0].string);
1406 }
1407 break;
1409 case 65:
1410 #line 323 "zconf.y"
1411 {
1412 zconf_nextfile(yyvsp[-1].string);
1413 }
1414 break;
1416 case 66:
1417 #line 330 "zconf.y"
1418 {
1419 menu_add_entry(NULL);
1420 menu_add_prop(P_COMMENT, yyvsp[0].string, NULL, NULL);
1421 printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
1422 }
1423 break;
1425 case 67:
1426 #line 337 "zconf.y"
1427 {
1428 menu_end_entry();
1429 }
1430 break;
1432 case 68:
1433 #line 344 "zconf.y"
1434 {
1435 printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
1436 zconf_starthelp();
1437 }
1438 break;
1440 case 69:
1441 #line 350 "zconf.y"
1442 {
1443 current_entry->sym->help = yyvsp[0].string;
1444 }
1445 break;
1447 case 72:
1448 #line 359 "zconf.y"
1449 { }
1450 break;
1452 case 73:
1453 #line 362 "zconf.y"
1454 {
1455 menu_add_dep(yyvsp[0].expr);
1456 printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
1457 }
1458 break;
1460 case 74:
1461 #line 367 "zconf.y"
1462 {
1463 menu_add_dep(yyvsp[0].expr);
1464 printd(DEBUG_PARSE, "%s:%d:depends\n", zconf_curname(), zconf_lineno());
1465 }
1466 break;
1468 case 75:
1469 #line 372 "zconf.y"
1470 {
1471 menu_add_dep(yyvsp[0].expr);
1472 printd(DEBUG_PARSE, "%s:%d:requires\n", zconf_curname(), zconf_lineno());
1473 }
1474 break;
1476 case 77:
1477 #line 382 "zconf.y"
1478 {
1479 menu_add_prop(P_PROMPT, yyvsp[0].string, NULL, NULL);
1480 }
1481 break;
1483 case 78:
1484 #line 386 "zconf.y"
1485 {
1486 menu_add_prop(P_PROMPT, yyvsp[-2].string, NULL, yyvsp[0].expr);
1487 }
1488 break;
1490 case 81:
1491 #line 394 "zconf.y"
1492 { yyval.token = T_ENDMENU; }
1493 break;
1495 case 82:
1496 #line 395 "zconf.y"
1497 { yyval.token = T_ENDCHOICE; }
1498 break;
1500 case 83:
1501 #line 396 "zconf.y"
1502 { yyval.token = T_ENDIF; }
1503 break;
1505 case 86:
1506 #line 402 "zconf.y"
1507 { yyval.expr = NULL; }
1508 break;
1510 case 87:
1511 #line 403 "zconf.y"
1512 { yyval.expr = yyvsp[0].expr; }
1513 break;
1515 case 88:
1516 #line 406 "zconf.y"
1517 { yyval.expr = expr_alloc_symbol(yyvsp[0].symbol); }
1518 break;
1520 case 89:
1521 #line 407 "zconf.y"
1522 { yyval.expr = expr_alloc_comp(E_EQUAL, yyvsp[-2].symbol, yyvsp[0].symbol); }
1523 break;
1525 case 90:
1526 #line 408 "zconf.y"
1527 { yyval.expr = expr_alloc_comp(E_UNEQUAL, yyvsp[-2].symbol, yyvsp[0].symbol); }
1528 break;
1530 case 91:
1531 #line 409 "zconf.y"
1532 { yyval.expr = yyvsp[-1].expr; }
1533 break;
1535 case 92:
1536 #line 410 "zconf.y"
1537 { yyval.expr = expr_alloc_one(E_NOT, yyvsp[0].expr); }
1538 break;
1540 case 93:
1541 #line 411 "zconf.y"
1542 { yyval.expr = expr_alloc_two(E_OR, yyvsp[-2].expr, yyvsp[0].expr); }
1543 break;
1545 case 94:
1546 #line 412 "zconf.y"
1547 { yyval.expr = expr_alloc_two(E_AND, yyvsp[-2].expr, yyvsp[0].expr); }
1548 break;
1550 case 95:
1551 #line 415 "zconf.y"
1552 { yyval.symbol = sym_lookup(yyvsp[0].string, 0); free(yyvsp[0].string); }
1553 break;
1555 case 96:
1556 #line 416 "zconf.y"
1557 { yyval.symbol = sym_lookup(yyvsp[0].string, 1); free(yyvsp[0].string); }
1558 break;
1561 }
1563 /* Line 1016 of /usr/share/bison/yacc.c. */
1564 #line 1565 "zconf.tab.c"
1565 \f
1566 yyvsp -= yylen;
1567 yyssp -= yylen;
1570 #if YYDEBUG
1571 if (yydebug)
1572 {
1573 short *yyssp1 = yyss - 1;
1574 YYFPRINTF (stderr, "state stack now");
1575 while (yyssp1 != yyssp)
1576 YYFPRINTF (stderr, " %d", *++yyssp1);
1577 YYFPRINTF (stderr, "\n");
1578 }
1579 #endif
1581 *++yyvsp = yyval;
1584 /* Now `shift' the result of the reduction. Determine what state
1585 that goes to, based on the state we popped back to and the rule
1586 number reduced by. */
1588 yyn = yyr1[yyn];
1590 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1591 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1592 yystate = yytable[yystate];
1593 else
1594 yystate = yydefgoto[yyn - YYNTOKENS];
1596 goto yynewstate;
1599 /*------------------------------------.
1600 | yyerrlab -- here on detecting error |
1601 `------------------------------------*/
1602 yyerrlab:
1603 /* If not already recovering from an error, report this error. */
1604 if (!yyerrstatus)
1605 {
1606 ++yynerrs;
1607 #if YYERROR_VERBOSE
1608 yyn = yypact[yystate];
1610 if (YYPACT_NINF < yyn && yyn < YYLAST)
1611 {
1612 YYSIZE_T yysize = 0;
1613 int yytype = YYTRANSLATE (yychar);
1614 char *yymsg;
1615 int yyx, yycount;
1617 yycount = 0;
1618 /* Start YYX at -YYN if negative to avoid negative indexes in
1619 YYCHECK. */
1620 for (yyx = yyn < 0 ? -yyn : 0;
1621 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1622 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1623 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1624 yysize += yystrlen ("parse error, unexpected ") + 1;
1625 yysize += yystrlen (yytname[yytype]);
1626 yymsg = (char *) YYSTACK_ALLOC (yysize);
1627 if (yymsg != 0)
1628 {
1629 char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1630 yyp = yystpcpy (yyp, yytname[yytype]);
1632 if (yycount < 5)
1633 {
1634 yycount = 0;
1635 for (yyx = yyn < 0 ? -yyn : 0;
1636 yyx < (int) (sizeof (yytname) / sizeof (char *));
1637 yyx++)
1638 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1639 {
1640 const char *yyq = ! yycount ? ", expecting " : " or ";
1641 yyp = yystpcpy (yyp, yyq);
1642 yyp = yystpcpy (yyp, yytname[yyx]);
1643 yycount++;
1644 }
1645 }
1646 yyerror (yymsg);
1647 YYSTACK_FREE (yymsg);
1648 }
1649 else
1650 yyerror ("parse error; also virtual memory exhausted");
1651 }
1652 else
1653 #endif /* YYERROR_VERBOSE */
1654 yyerror ("parse error");
1655 }
1656 goto yyerrlab1;
1659 /*----------------------------------------------------.
1660 | yyerrlab1 -- error raised explicitly by an action. |
1661 `----------------------------------------------------*/
1662 yyerrlab1:
1663 if (yyerrstatus == 3)
1664 {
1665 /* If just tried and failed to reuse lookahead token after an
1666 error, discard it. */
1668 /* Return failure if at end of input. */
1669 if (yychar == YYEOF)
1670 {
1671 /* Pop the error token. */
1672 YYPOPSTACK;
1673 /* Pop the rest of the stack. */
1674 while (yyssp > yyss)
1675 {
1676 YYDPRINTF ((stderr, "Error: popping "));
1677 YYDSYMPRINT ((stderr,
1678 yystos[*yyssp],
1679 *yyvsp));
1680 YYDPRINTF ((stderr, "\n"));
1681 yydestruct (yystos[*yyssp], *yyvsp);
1682 YYPOPSTACK;
1683 }
1684 YYABORT;
1685 }
1687 YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1688 yychar, yytname[yychar1]));
1689 yydestruct (yychar1, yylval);
1690 yychar = YYEMPTY;
1691 }
1693 /* Else will try to reuse lookahead token after shifting the error
1694 token. */
1696 yyerrstatus = 3; /* Each real token shifted decrements this. */
1698 for (;;)
1699 {
1700 yyn = yypact[yystate];
1701 if (yyn != YYPACT_NINF)
1702 {
1703 yyn += YYTERROR;
1704 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1705 {
1706 yyn = yytable[yyn];
1707 if (0 < yyn)
1708 break;
1709 }
1710 }
1712 /* Pop the current state because it cannot handle the error token. */
1713 if (yyssp == yyss)
1714 YYABORT;
1716 YYDPRINTF ((stderr, "Error: popping "));
1717 YYDSYMPRINT ((stderr,
1718 yystos[*yyssp], *yyvsp));
1719 YYDPRINTF ((stderr, "\n"));
1721 yydestruct (yystos[yystate], *yyvsp);
1722 yyvsp--;
1723 yystate = *--yyssp;
1726 #if YYDEBUG
1727 if (yydebug)
1728 {
1729 short *yyssp1 = yyss - 1;
1730 YYFPRINTF (stderr, "Error: state stack now");
1731 while (yyssp1 != yyssp)
1732 YYFPRINTF (stderr, " %d", *++yyssp1);
1733 YYFPRINTF (stderr, "\n");
1734 }
1735 #endif
1736 }
1738 if (yyn == YYFINAL)
1739 YYACCEPT;
1741 YYDPRINTF ((stderr, "Shifting error token, "));
1743 *++yyvsp = yylval;
1746 yystate = yyn;
1747 goto yynewstate;
1750 /*-------------------------------------.
1751 | yyacceptlab -- YYACCEPT comes here. |
1752 `-------------------------------------*/
1753 yyacceptlab:
1754 yyresult = 0;
1755 goto yyreturn;
1757 /*-----------------------------------.
1758 | yyabortlab -- YYABORT comes here. |
1759 `-----------------------------------*/
1760 yyabortlab:
1761 yyresult = 1;
1762 goto yyreturn;
1764 #ifndef yyoverflow
1765 /*----------------------------------------------.
1766 | yyoverflowlab -- parser overflow comes here. |
1767 `----------------------------------------------*/
1768 yyoverflowlab:
1769 yyerror ("parser stack overflow");
1770 yyresult = 2;
1771 /* Fall through. */
1772 #endif
1774 yyreturn:
1775 #ifndef yyoverflow
1776 if (yyss != yyssa)
1777 YYSTACK_FREE (yyss);
1778 #endif
1779 return yyresult;
1780 }
1783 #line 419 "zconf.y"
1786 void conf_parse(const char *name)
1787 {
1788 zconf_initscan(name);
1790 sym_init();
1791 menu_init();
1792 rootmenu.prompt = menu_add_prop(P_MENU, "Broadcom Linux Router Configuration", NULL, NULL);
1794 //zconfdebug = 1;
1795 zconfparse();
1796 if (zconfnerrs)
1797 exit(1);
1798 menu_finalize(&rootmenu);
1800 modules_sym = sym_lookup("MODULES", 0);
1802 sym_change_count = 1;
1803 }
1805 const char *zconf_tokenname(int token)
1806 {
1807 switch (token) {
1808 case T_MENU: return "menu";
1809 case T_ENDMENU: return "endmenu";
1810 case T_CHOICE: return "choice";
1811 case T_ENDCHOICE: return "endchoice";
1812 case T_IF: return "if";
1813 case T_ENDIF: return "endif";
1814 }
1815 return "<token>";
1816 }
1818 static bool zconf_endtoken(int token, int starttoken, int endtoken)
1819 {
1820 if (token != endtoken) {
1821 zconfprint("unexpected '%s' within %s block", zconf_tokenname(token), zconf_tokenname(starttoken));
1822 zconfnerrs++;
1823 return false;
1824 }
1825 if (current_menu->file != current_file) {
1826 zconfprint("'%s' in different file than '%s'", zconf_tokenname(token), zconf_tokenname(starttoken));
1827 zconfprint("location of the '%s'", zconf_tokenname(starttoken));
1828 zconfnerrs++;
1829 return false;
1830 }
1831 return true;
1832 }
1834 static void zconfprint(const char *err, ...)
1835 {
1836 va_list ap;
1838 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
1839 va_start(ap, err);
1840 vfprintf(stderr, err, ap);
1841 va_end(ap);
1842 fprintf(stderr, "\n");
1843 }
1845 static void zconferror(const char *err)
1846 {
1847 fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno(), err);
1848 }
1850 void print_quoted_string(FILE *out, const char *str)
1851 {
1852 const char *p;
1853 int len;
1855 putc('"', out);
1856 while ((p = strchr(str, '"'))) {
1857 len = p - str;
1858 if (len)
1859 fprintf(out, "%.*s", len, str);
1860 fputs("\\\"", out);
1861 str = p + 1;
1862 }
1863 fputs(str, out);
1864 putc('"', out);
1865 }
1867 void print_symbol(FILE *out, struct menu *menu)
1868 {
1869 struct symbol *sym = menu->sym;
1870 struct property *prop;
1872 //sym->flags |= SYMBOL_PRINTED;
1874 if (sym_is_choice(sym))
1875 fprintf(out, "choice\n");
1876 else
1877 fprintf(out, "config %s\n", sym->name);
1878 switch (sym->type) {
1879 case S_BOOLEAN:
1880 fputs(" boolean\n", out);
1881 break;
1882 case S_TRISTATE:
1883 fputs(" tristate\n", out);
1884 break;
1885 case S_STRING:
1886 fputs(" string\n", out);
1887 break;
1888 case S_INT:
1889 fputs(" integer\n", out);
1890 break;
1891 case S_HEX:
1892 fputs(" hex\n", out);
1893 break;
1894 default:
1895 fputs(" ???\n", out);
1896 break;
1897 }
1898 for (prop = sym->prop; prop; prop = prop->next) {
1899 if (prop->menu != menu)
1900 continue;
1901 switch (prop->type) {
1902 case P_PROMPT:
1903 fputs(" prompt ", out);
1904 print_quoted_string(out, prop->text);
1905 if (prop->def) {
1906 fputc(' ', out);
1907 if (prop->def->flags & SYMBOL_CONST)
1908 print_quoted_string(out, prop->def->name);
1909 else
1910 fputs(prop->def->name, out);
1911 }
1912 if (!expr_is_yes(E_EXPR(prop->visible))) {
1913 fputs(" if ", out);
1914 expr_fprint(E_EXPR(prop->visible), out);
1915 }
1916 fputc('\n', out);
1917 break;
1918 case P_DEFAULT:
1919 fputs( " default ", out);
1920 print_quoted_string(out, prop->def->name);
1921 if (!expr_is_yes(E_EXPR(prop->visible))) {
1922 fputs(" if ", out);
1923 expr_fprint(E_EXPR(prop->visible), out);
1924 }
1925 fputc('\n', out);
1926 break;
1927 case P_CHOICE:
1928 fputs(" #choice value\n", out);
1929 break;
1930 default:
1931 fprintf(out, " unknown prop %d!\n", prop->type);
1932 break;
1933 }
1934 }
1935 if (sym->help) {
1936 int len = strlen(sym->help);
1937 while (sym->help[--len] == '\n')
1938 sym->help[len] = 0;
1939 fprintf(out, " help\n%s\n", sym->help);
1940 }
1941 fputc('\n', out);
1942 }
1944 void zconfdump(FILE *out)
1945 {
1946 //struct file *file;
1947 struct property *prop;
1948 struct symbol *sym;
1949 struct menu *menu;
1951 menu = rootmenu.list;
1952 while (menu) {
1953 if ((sym = menu->sym))
1954 print_symbol(out, menu);
1955 else if ((prop = menu->prompt)) {
1956 switch (prop->type) {
1957 //case T_MAINMENU:
1958 // fputs("\nmainmenu ", out);
1959 // print_quoted_string(out, prop->text);
1960 // fputs("\n", out);
1961 // break;
1962 case P_COMMENT:
1963 fputs("\ncomment ", out);
1964 print_quoted_string(out, prop->text);
1965 fputs("\n", out);
1966 break;
1967 case P_MENU:
1968 fputs("\nmenu ", out);
1969 print_quoted_string(out, prop->text);
1970 fputs("\n", out);
1971 break;
1972 //case T_SOURCE:
1973 // fputs("\nsource ", out);
1974 // print_quoted_string(out, prop->text);
1975 // fputs("\n", out);
1976 // break;
1977 //case T_IF:
1978 // fputs("\nif\n", out);
1979 default:
1980 ;
1981 }
1982 if (!expr_is_yes(E_EXPR(prop->visible))) {
1983 fputs(" depends ", out);
1984 expr_fprint(E_EXPR(prop->visible), out);
1985 fputc('\n', out);
1986 }
1987 fputs("\n", out);
1988 }
1990 if (menu->list)
1991 menu = menu->list;
1992 else if (menu->next)
1993 menu = menu->next;
1994 else while ((menu = menu->parent)) {
1995 if (menu->prompt && menu->prompt->type == P_MENU)
1996 fputs("\nendmenu\n", out);
1997 if (menu->next) {
1998 menu = menu->next;
1999 break;
2000 }
2001 }
2002 }
2003 }
2005 #include "lex.zconf.c"
2006 #include "confdata.c"
2007 #include "expr.c"
2008 #include "symbol.c"
2009 #include "menu.c"