| blob | 4c5495ea205e646ef9c4efff923dd6a678dbda4b |
2 /* A Bison parser, made by GNU Bison 2.4.1. */
4 /* Skeleton implementation for Bison's Yacc-like parsers in C
6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7 Free Software Foundation, Inc.
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.
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.
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/>. */
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.
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
35 /* C LALR(1) parser skeleton written by Richard Stallman, by
36 simplifying the original so-called "semantic" parser. */
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. */
45 /* Identify Bison output. */
46 #define YYBISON 1
48 /* Bison version. */
49 #define YYBISON_VERSION "2.4.1"
51 /* Skeleton name. */
52 #define YYSKELETON_NAME "yacc.c"
54 /* Pure parsers. */
55 #define YYPURE 0
57 /* Push parsers. */
58 #define YYPUSH 0
60 /* Pull parsers. */
61 #define YYPULL 1
63 /* Using locations. */
64 #define YYLSP_NEEDED 0
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
76 /* Copy the first part of user declarations. */
79 /*
80 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
81 * Released under the terms of the GNU GPL v2.0.
82 */
84 #include <ctype.h>
85 #include <stdarg.h>
86 #include <stdio.h>
87 #include <stdlib.h>
88 #include <string.h>
89 #include <stdbool.h>
91 #define LKC_DIRECT_LINK
92 #include "lkc.h"
94 #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
96 #define PRINTD 0x0001
97 #define DEBUG_PARSE 0x0002
99 int cdebug = PRINTD;
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);
107 struct symbol *symbol_hash[SYMBOL_HASHSIZE];
109 static struct menu *current_menu, *current_entry;
111 #define YYDEBUG 0
112 #if YYDEBUG
113 #define YYERROR_VERBOSE
114 #endif
118 /* Enabling traces. */
119 #ifndef YYDEBUG
120 # define YYDEBUG 0
121 #endif
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
131 /* Enabling the token table. */
132 #ifndef YYTOKEN_TABLE
133 # define YYTOKEN_TABLE 0
134 #endif
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
181 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
182 typedef union YYSTYPE
183 {
186 char *string;
187 struct file *file;
188 struct symbol *symbol;
189 struct expr *expr;
190 struct menu *menu;
191 struct kconf_id *id;
195 } YYSTYPE;
196 # define YYSTYPE_IS_TRIVIAL 1
197 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
198 # define YYSTYPE_IS_DECLARED 1
199 #endif
202 /* Copy the second part of user declarations. */
205 /* Include zconf.hash.c here so it can see the token constants. */
206 #include "zconf.hash.c"
210 #ifdef short
211 # undef short
212 #endif
214 #ifdef YYTYPE_UINT8
215 typedef YYTYPE_UINT8 yytype_uint8;
216 #else
217 typedef unsigned char yytype_uint8;
218 #endif
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
229 #ifdef YYTYPE_UINT16
230 typedef YYTYPE_UINT16 yytype_uint16;
231 #else
232 typedef unsigned short int yytype_uint16;
233 #endif
235 #ifdef YYTYPE_INT16
236 typedef YYTYPE_INT16 yytype_int16;
237 #else
238 typedef short int yytype_int16;
239 #endif
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
255 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
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
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
276 /* Identity function, used to suppress warnings about constant conditions. */
277 #ifndef lint
278 # define YYID(n) (n)
279 #else
280 #if (defined __STDC__ || defined __C99__FUNC__ \
281 || defined __cplusplus || defined _MSC_VER)
282 static int
283 YYID (int yyi)
284 #else
285 static int
286 YYID (yyi)
287 int yyi;
288 #endif
289 {
290 return yyi;
291 }
292 #endif
294 #if ! defined yyoverflow || YYERROR_VERBOSE
296 /* The parser invokes alloca or malloc; define the necessary symbols. */
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
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 */
364 #if (! defined yyoverflow \
365 && (! defined __cplusplus \
366 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
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 };
375 /* The size of the maximum gap between one aligned stack and the next. */
376 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
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)
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
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))
418 #endif
420 /* YYFINAL -- State number of the termination state. */
421 #define YYFINAL 11
422 /* YYLAST -- Last index in YYTABLE. */
423 #define YYLAST 290
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
434 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
435 #define YYUNDEFTOK 2
436 #define YYMAXUTOK 290
438 #define YYTRANSLATE(YYX) \
439 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
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 };
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 };
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 };
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
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
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
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 };
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 };
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 };
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 };
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 };
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 };
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 };
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 };
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 };
797 #define yyerrok (yyerrstatus = 0)
798 #define yyclearin (yychar = YYEMPTY)
799 #define YYEMPTY (-2)
800 #define YYEOF 0
802 #define YYACCEPT goto yyacceptlab
803 #define YYABORT goto yyabortlab
804 #define YYERROR goto yyerrorlab
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. */
811 #define YYFAIL goto yyerrlab
813 #define YYRECOVERING() (!!yyerrstatus)
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))
833 #define YYTERROR 1
834 #define YYERRCODE 256
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). */
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
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. */
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
879 /* YYLEX -- calling `yylex' with the right arguments. */
881 #ifdef YYLEX_PARAM
882 # define YYLEX yylex (YYLEX_PARAM)
883 #else
884 # define YYLEX yylex ()
885 #endif
887 /* Enable debugging if requested. */
888 #if YYDEBUG
890 # ifndef YYFPRINTF
891 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
892 # define YYFPRINTF fprintf
893 # endif
895 # define YYDPRINTF(Args) \
896 do { \
897 if (yydebug) \
898 YYFPRINTF Args; \
899 } while (YYID (0))
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))
913 /*--------------------------------.
914 | Print this symbol on YYOUTPUT. |
915 `--------------------------------*/
917 /*ARGSUSED*/
918 #if (defined __STDC__ || defined __C99__FUNC__ \
919 || defined __cplusplus || defined _MSC_VER)
920 static void
921 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
922 #else
923 static void
924 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
925 FILE *yyoutput;
926 int yytype;
927 YYSTYPE const * const yyvaluep;
928 #endif
929 {
930 if (!yyvaluep)
931 return;
932 # ifdef YYPRINT
933 if (yytype < YYNTOKENS)
934 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
935 # else
936 YYUSE (yyoutput);
937 # endif
938 switch (yytype)
939 {
940 default:
941 break;
942 }
943 }
946 /*--------------------------------.
947 | Print this symbol on YYOUTPUT. |
948 `--------------------------------*/
950 #if (defined __STDC__ || defined __C99__FUNC__ \
951 || defined __cplusplus || defined _MSC_VER)
952 static void
953 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
954 #else
955 static void
956 yy_symbol_print (yyoutput, yytype, yyvaluep)
957 FILE *yyoutput;
958 int yytype;
959 YYSTYPE const * const yyvaluep;
960 #endif
961 {
962 if (yytype < YYNTOKENS)
963 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
964 else
965 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
967 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
968 YYFPRINTF (yyoutput, ")");
969 }
971 /*------------------------------------------------------------------.
972 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
973 | TOP (included). |
974 `------------------------------------------------------------------*/
976 #if (defined __STDC__ || defined __C99__FUNC__ \
977 || defined __cplusplus || defined _MSC_VER)
978 static void
979 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
980 #else
981 static void
982 yy_stack_print (yybottom, yytop)
983 yytype_int16 *yybottom;
984 yytype_int16 *yytop;
985 #endif
986 {
987 YYFPRINTF (stderr, "Stack now");
988 for (; yybottom <= yytop; yybottom++)
989 {
990 int yybot = *yybottom;
991 YYFPRINTF (stderr, " %d", yybot);
992 }
993 YYFPRINTF (stderr, "\n");
994 }
996 # define YY_STACK_PRINT(Bottom, Top) \
997 do { \
998 if (yydebug) \
999 yy_stack_print ((Bottom), (Top)); \
1000 } while (YYID (0))
1003 /*------------------------------------------------.
1004 | Report that the YYRULE is going to be reduced. |
1005 `------------------------------------------------*/
1007 #if (defined __STDC__ || defined __C99__FUNC__ \
1008 || defined __cplusplus || defined _MSC_VER)
1009 static void
1010 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1011 #else
1012 static void
1013 yy_reduce_print (yyvsp, yyrule)
1014 YYSTYPE *yyvsp;
1015 int yyrule;
1016 #endif
1017 {
1018 int yynrhs = yyr2[yyrule];
1019 int yyi;
1020 unsigned long int yylno = yyrline[yyrule];
1021 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1022 yyrule - 1, yylno);
1023 /* The symbols being reduced. */
1024 for (yyi = 0; yyi < yynrhs; yyi++)
1025 {
1026 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1027 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1028 &(yyvsp[(yyi + 1) - (yynrhs)])
1029 );
1030 YYFPRINTF (stderr, "\n");
1031 }
1032 }
1034 # define YY_REDUCE_PRINT(Rule) \
1035 do { \
1036 if (yydebug) \
1037 yy_reduce_print (yyvsp, Rule); \
1038 } while (YYID (0))
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 */
1051 /* YYINITDEPTH -- initial size of the parser's stacks. */
1052 #ifndef YYINITDEPTH
1053 # define YYINITDEPTH 200
1054 #endif
1056 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1057 if the built-in stack extension method is used).
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. */
1063 #ifndef YYMAXDEPTH
1064 # define YYMAXDEPTH 10000
1065 #endif
1067 \f
1069 #if YYERROR_VERBOSE
1071 # ifndef yystrlen
1072 # if defined __GLIBC__ && defined _STRING_H
1073 # define yystrlen strlen
1074 # else
1075 /* Return the length of YYSTR. */
1076 #if (defined __STDC__ || defined __C99__FUNC__ \
1077 || defined __cplusplus || defined _MSC_VER)
1078 static YYSIZE_T
1079 yystrlen (const char *yystr)
1080 #else
1081 static YYSIZE_T
1082 yystrlen (yystr)
1083 const char *yystr;
1084 #endif
1085 {
1086 YYSIZE_T yylen;
1087 for (yylen = 0; yystr[yylen]; yylen++)
1088 continue;
1089 return yylen;
1090 }
1091 # endif
1092 # endif
1094 # ifndef yystpcpy
1095 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1096 # define yystpcpy stpcpy
1097 # else
1098 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1099 YYDEST. */
1100 #if (defined __STDC__ || defined __C99__FUNC__ \
1101 || defined __cplusplus || defined _MSC_VER)
1102 static char *
1103 yystpcpy (char *yydest, const char *yysrc)
1104 #else
1105 static char *
1106 yystpcpy (yydest, yysrc)
1107 char *yydest;
1108 const char *yysrc;
1109 #endif
1110 {
1111 char *yyd = yydest;
1112 const char *yys = yysrc;
1114 while ((*yyd++ = *yys++) != '\0')
1115 continue;
1117 return yyd - 1;
1118 }
1119 # endif
1120 # endif
1122 # ifndef yytnamerr
1123 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1124 quotes and backslashes, so that it's suitable for yyerror. The
1125 heuristic is that double-quoting is unnecessary unless the string
1126 contains an apostrophe, a comma, or backslash (other than
1127 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1128 null, do not copy; instead, return the length of what the result
1129 would have been. */
1130 static YYSIZE_T
1131 yytnamerr (char *yyres, const char *yystr)
1132 {
1133 if (*yystr == '"')
1134 {
1135 YYSIZE_T yyn = 0;
1136 char const *yyp = yystr;
1138 for (;;)
1139 switch (*++yyp)
1140 {
1141 case '\'':
1142 case ',':
1143 goto do_not_strip_quotes;
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;
1155 case '"':
1156 if (yyres)
1157 yyres[yyn] = '\0';
1158 return yyn;
1159 }
1160 do_not_strip_quotes: ;
1161 }
1163 if (! yyres)
1164 return yystrlen (yystr);
1166 return yystpcpy (yyres, yystr) - yyres;
1167 }
1168 # endif
1170 /* Copy into YYRESULT an error message about the unexpected token
1171 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1172 including the terminating null byte. If YYRESULT is null, do not
1173 copy anything; just return the number of bytes that would be
1174 copied. As a special case, return 0 if an ordinary "syntax error"
1175 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1176 size calculation. */
1177 static YYSIZE_T
1178 yysyntax_error (char *yyresult, int yystate, int yychar)
1179 {
1180 int yyn = yypact[yystate];
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;
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;
1215 /* Start YYX at -YYN if negative to avoid negative indexes in
1216 YYCHECK. */
1217 int yyxbegin = yyn < 0 ? -yyn : 0;
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;
1224 yyarg[0] = yytname[yytype];
1225 yyfmt = yystpcpy (yyformat, yyunexpected);
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 }
1245 yyf = YY_(yyformat);
1246 yysize1 = yysize + yystrlen (yyf);
1247 yysize_overflow |= (yysize1 < yysize);
1248 yysize = yysize1;
1250 if (yysize_overflow)
1251 return YYSIZE_MAXIMUM;
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 \f
1280 /*-----------------------------------------------.
1281 | Release the memory associated to this symbol. |
1282 `-----------------------------------------------*/
1284 /*ARGSUSED*/
1285 #if (defined __STDC__ || defined __C99__FUNC__ \
1286 || defined __cplusplus || defined _MSC_VER)
1287 static void
1288 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1289 #else
1290 static void
1291 yydestruct (yymsg, yytype, yyvaluep)
1292 const char *yymsg;
1293 int yytype;
1294 YYSTYPE *yyvaluep;
1295 #endif
1296 {
1297 YYUSE (yyvaluep);
1299 if (!yymsg)
1300 yymsg = "Deleting";
1301 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1303 switch (yytype)
1304 {
1305 case 53: /* "choice_entry" */
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 };
1314 break;
1315 case 59: /* "if_entry" */
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 };
1324 break;
1325 case 65: /* "menu_entry" */
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 };
1334 break;
1336 default:
1337 break;
1338 }
1339 }
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 */
1357 /* The lookahead symbol. */
1358 int yychar;
1360 /* The semantic value of the lookahead symbol. */
1361 YYSTYPE yylval;
1363 /* Number of syntax errors so far. */
1364 int yynerrs;
1368 /*-------------------------.
1369 | yyparse or yypush_parse. |
1370 `-------------------------*/
1372 #ifdef YYPARSE_PARAM
1373 #if (defined __STDC__ || defined __C99__FUNC__ \
1374 || defined __cplusplus || defined _MSC_VER)
1375 int
1376 yyparse (void *YYPARSE_PARAM)
1377 #else
1378 int
1379 yyparse (YYPARSE_PARAM)
1380 void *YYPARSE_PARAM;
1381 #endif
1382 #else /* ! YYPARSE_PARAM */
1383 #if (defined __STDC__ || defined __C99__FUNC__ \
1384 || defined __cplusplus || defined _MSC_VER)
1385 int
1386 yyparse (void)
1387 #else
1388 int
1389 yyparse ()
1391 #endif
1392 #endif
1393 {
1396 int yystate;
1397 /* Number of tokens to shift before error messages enabled. */
1398 int yyerrstatus;
1400 /* The stacks and their tools:
1401 `yyss': related to states.
1402 `yyvs': related to semantic values.
1404 Refer to the stacks thru separate pointers, to allow yyoverflow
1405 to reallocate them elsewhere. */
1407 /* The state stack. */
1408 yytype_int16 yyssa[YYINITDEPTH];
1409 yytype_int16 *yyss;
1410 yytype_int16 *yyssp;
1412 /* The semantic value stack. */
1413 YYSTYPE yyvsa[YYINITDEPTH];
1414 YYSTYPE *yyvs;
1415 YYSTYPE *yyvsp;
1417 YYSIZE_T yystacksize;
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;
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
1434 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
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;
1440 yytoken = 0;
1441 yyss = yyssa;
1442 yyvs = yyvsa;
1443 yystacksize = YYINITDEPTH;
1445 YYDPRINTF ((stderr, "Starting parse\n"));
1447 yystate = 0;
1448 yyerrstatus = 0;
1449 yynerrs = 0;
1450 yychar = YYEMPTY; /* Cause a token to be read. */
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;
1459 goto yysetstate;
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++;
1469 yysetstate:
1470 *yyssp = yystate;
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;
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;
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);
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;
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 */
1523 yyssp = yyss + yysize - 1;
1524 yyvsp = yyvs + yysize - 1;
1526 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1527 (unsigned long int) yystacksize));
1529 if (yyss + yystacksize - 1 <= yyssp)
1530 YYABORT;
1531 }
1533 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1535 if (yystate == YYFINAL)
1536 YYACCEPT;
1538 goto yybackup;
1540 /*-----------.
1541 | yybackup. |
1542 `-----------*/
1543 yybackup:
1545 /* Do appropriate processing given the current state. Read a
1546 lookahead token if we need one and don't already have one. */
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;
1553 /* Not known => get a lookahead token if don't already have one. */
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 }
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 }
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 }
1587 /* Count tokens shifted since error; after three, turn off error
1588 status. */
1589 if (yyerrstatus)
1590 yyerrstatus--;
1592 /* Shift the lookahead token. */
1593 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1595 /* Discard the shifted token. */
1596 yychar = YYEMPTY;
1598 yystate = yyn;
1599 *++yyvsp = yylval;
1601 goto yynewstate;
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;
1614 /*-----------------------------.
1615 | yyreduce -- Do a reduction. |
1616 `-----------------------------*/
1617 yyreduce:
1618 /* yyn is the number of a rule to reduce with. */
1619 yylen = yyr2[yyn];
1621 /* If YYLEN is nonzero, implement the default value of the action:
1622 `$$ = $1'.
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];
1632 YY_REDUCE_PRINT (yyn);
1633 switch (yyn)
1634 {
1635 case 10:
1637 { zconf_error("unexpected end statement"); ;}
1638 break;
1640 case 11:
1642 { zconf_error("unknown statement \"%s\"", (yyvsp[(2) - (4)].string)); ;}
1643 break;
1645 case 12:
1647 {
1648 zconf_error("unexpected option \"%s\"", kconf_id_strings + (yyvsp[(2) - (4)].id)->name);
1649 ;}
1650 break;
1652 case 13:
1654 { zconf_error("invalid statement"); ;}
1655 break;
1657 case 28:
1659 { zconf_error("unknown option \"%s\"", (yyvsp[(1) - (3)].string)); ;}
1660 break;
1662 case 29:
1664 { zconf_error("invalid option"); ;}
1665 break;
1667 case 30:
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;
1677 case 31:
1679 {
1680 menu_end_entry();
1681 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1682 ;}
1683 break;
1685 case 32:
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;
1695 case 33:
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;
1707 case 41:
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;
1717 case 42:
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;
1725 case 43:
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;
1737 case 44:
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;
1745 case 45:
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;
1753 case 48:
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;
1765 case 49:
1767 { (yyval.string) = NULL; ;}
1768 break;
1770 case 50:
1772 { (yyval.string) = (yyvsp[(2) - (2)].string); ;}
1773 break;
1775 case 51:
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;
1786 case 52:
1788 {
1789 (yyval.menu) = menu_add_menu();
1790 ;}
1791 break;
1793 case 53:
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;
1803 case 61:
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;
1811 case 62:
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;
1824 case 63:
1826 {
1827 current_entry->sym->flags |= SYMBOL_OPTIONAL;
1828 printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
1829 ;}
1830 break;
1832 case 64:
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;
1844 case 67:
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;
1854 case 68:
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;
1864 case 74:
1866 {
1867 menu_add_prompt(P_MENU, (yyvsp[(2) - (3)].string), NULL);
1868 ;}
1869 break;
1871 case 75:
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;
1880 case 76:
1882 {
1883 (yyval.menu) = menu_add_menu();
1884 ;}
1885 break;
1887 case 77:
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;
1897 case 83:
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;
1905 case 84:
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;
1914 case 85:
1916 {
1917 menu_end_entry();
1918 ;}
1919 break;
1921 case 86:
1923 {
1924 printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
1925 zconf_starthelp();
1926 ;}
1927 break;
1929 case 87:
1931 {
1932 current_entry->help = (yyvsp[(2) - (2)].string);
1933 ;}
1934 break;
1936 case 92:
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;
1944 case 96:
1946 {
1947 menu_add_visibility((yyvsp[(2) - (2)].expr));
1948 ;}
1949 break;
1951 case 98:
1953 {
1954 menu_add_prompt(P_PROMPT, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].expr));
1955 ;}
1956 break;
1958 case 101:
1960 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
1961 break;
1963 case 102:
1965 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
1966 break;
1968 case 103:
1970 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
1971 break;
1973 case 106:
1975 { (yyval.expr) = NULL; ;}
1976 break;
1978 case 107:
1980 { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;}
1981 break;
1983 case 108:
1985 { (yyval.expr) = expr_alloc_symbol((yyvsp[(1) - (1)].symbol)); ;}
1986 break;
1988 case 109:
1990 { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
1991 break;
1993 case 110:
1995 { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
1996 break;
1998 case 111:
2000 { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
2001 break;
2003 case 112:
2005 { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[(2) - (2)].expr)); ;}
2006 break;
2008 case 113:
2010 { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
2011 break;
2013 case 114:
2015 { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
2016 break;
2018 case 115:
2020 { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), 0); free((yyvsp[(1) - (1)].string)); ;}
2021 break;
2023 case 116:
2025 { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), SYMBOL_CONST); free((yyvsp[(1) - (1)].string)); ;}
2026 break;
2028 case 117:
2030 { (yyval.string) = NULL; ;}
2031 break;
2035 default: break;
2036 }
2037 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2039 YYPOPSTACK (yylen);
2040 yylen = 0;
2041 YY_STACK_PRINT (yyss, yyssp);
2043 *++yyvsp = yyval;
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. */
2049 yyn = yyr1[yyn];
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];
2057 goto yynewstate;
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 }
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 }
2107 if (yyerrstatus == 3)
2108 {
2109 /* If just tried and failed to reuse lookahead token after an
2110 error, discard it. */
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 }
2126 /* Else will try to reuse lookahead token after shifting the error
2127 token. */
2128 goto yyerrlab1;
2131 /*---------------------------------------------------.
2132 | yyerrorlab -- error raised explicitly by YYERROR. |
2133 `---------------------------------------------------*/
2134 yyerrorlab:
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;
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;
2151 /*-------------------------------------------------------------.
2152 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2153 `-------------------------------------------------------------*/
2154 yyerrlab1:
2155 yyerrstatus = 3; /* Each real token shifted decrements this. */
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 }
2171 /* Pop the current state because it cannot handle the error token. */
2172 if (yyssp == yyss)
2173 YYABORT;
2176 yydestruct ("Error: popping",
2177 yystos[yystate], yyvsp);
2178 YYPOPSTACK (1);
2179 yystate = *yyssp;
2180 YY_STACK_PRINT (yyss, yyssp);
2181 }
2183 *++yyvsp = yylval;
2186 /* Shift the error token. */
2187 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2189 yystate = yyn;
2190 goto yynewstate;
2193 /*-------------------------------------.
2194 | yyacceptlab -- YYACCEPT comes here. |
2195 `-------------------------------------*/
2196 yyacceptlab:
2197 yyresult = 0;
2198 goto yyreturn;
2200 /*-----------------------------------.
2201 | yyabortlab -- YYABORT comes here. |
2202 `-----------------------------------*/
2203 yyabortlab:
2204 yyresult = 1;
2205 goto yyreturn;
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
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 }
2247 void conf_parse(const char *name)
2248 {
2249 struct symbol *sym;
2250 int i;
2252 zconf_initscan(name);
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);
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;
2271 prop = prop_alloc(P_DEFAULT, modules_sym);
2272 prop->expr = expr_alloc_symbol(sym_lookup("MODULES", 0));
2273 }
2275 rootmenu.prompt->text = _(rootmenu.prompt->text);
2276 rootmenu.prompt->text = sym_expand_string_value(rootmenu.prompt->text);
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 }
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 }
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 }
2323 static void zconfprint(const char *err, ...)
2324 {
2325 va_list ap;
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 }
2334 static void zconf_error(const char *err, ...)
2335 {
2336 va_list ap;
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 }
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 }
2353 static void print_quoted_string(FILE *out, const char *str)
2354 {
2355 const char *p;
2356 int len;
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 }
2370 static void print_symbol(FILE *out, struct menu *menu)
2371 {
2372 struct symbol *sym = menu->sym;
2373 struct property *prop;
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 }
2452 void zconfdump(FILE *out)
2453 {
2454 struct property *prop;
2455 struct symbol *sym;
2456 struct menu *menu;
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 }
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 }
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"