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 <zippel@linux-m68k.org>
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
YYID(int yyi)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
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)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
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)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
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)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
yy_reduce_print(YYSTYPE * yyvsp,int yyrule)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
yystrlen(const char * yystr)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 *
yystpcpy(char * yydest,const char * yysrc)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
yytnamerr(char * yyres,const char * yystr)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
yysyntax_error(char * yyresult,int yystate,int yychar)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
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)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
yyparse(void * YYPARSE_PARAM)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
conf_parse(const char * name)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
zconf_tokenname(int token)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
zconf_endtoken(struct kconf_id * id,int starttoken,int endtoken)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
zconfprint(const char * err,...)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
zconf_error(const char * err,...)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
zconferror(const char * err)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
print_quoted_string(FILE * out,const char * str)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
print_symbol(FILE * out,struct menu * menu)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
zconfdump(FILE * out)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
2506