1 /* A Bison parser, made by GNU Bison 2.4.3. */
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2009, 2010 Free Software Foundation, Inc.
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
37 /* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
44 /* Identify Bison output. */
48 #define YYBISON_VERSION "2.4.3"
51 #define YYSKELETON_NAME "yacc.c"
62 /* Using locations. */
63 #define YYLSP_NEEDED 0
65 /* Substitute the variable and function names. */
66 #define yyparse zconfparse
67 #define yylex zconflex
68 #define yyerror zconferror
69 #define yylval zconflval
70 #define yychar zconfchar
71 #define yydebug zconfdebug
72 #define yynerrs zconfnerrs
75 /* Copy the first part of user declarations. */
79 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
80 * Released under the terms of the GNU GPL v2.0.
93 # define PATH_MAX 4096
98 #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
100 #define PRINTD 0x0001
101 #define DEBUG_PARSE 0x0002
105 extern int zconflex(void);
106 static void zconfprint(const char *err, ...);
107 static void zconf_error(const char *err, ...);
108 static void zconferror(const char *err);
109 static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken);
111 struct symbol *symbol_hash[SYMBOL_HASHSIZE];
113 static struct menu *current_menu, *current_entry;
118 /* Enabling traces. */
123 /* Enabling verbose error messages. */
124 #ifdef YYERROR_VERBOSE
125 # undef YYERROR_VERBOSE
126 # define YYERROR_VERBOSE 1
128 # define YYERROR_VERBOSE 0
131 /* Enabling the token table. */
132 #ifndef YYTOKEN_TABLE
133 # define YYTOKEN_TABLE 0
140 /* Put the tokens into the symbol table, so that GDB and other debuggers
181 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
182 typedef union YYSTYPE
188 struct symbol *symbol;
191 const struct kconf_id *id;
196 # define YYSTYPE_IS_TRIVIAL 1
197 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
198 # define YYSTYPE_IS_DECLARED 1
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"
215 typedef YYTYPE_UINT8 yytype_uint8;
217 typedef unsigned char yytype_uint8;
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;
226 typedef short int yytype_int8;
230 typedef YYTYPE_UINT16 yytype_uint16;
232 typedef unsigned short int yytype_uint16;
236 typedef YYTYPE_INT16 yytype_int16;
238 typedef short int yytype_int16;
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
251 # define YYSIZE_T unsigned int
255 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
258 # if defined YYENABLE_NLS && YYENABLE_NLS
260 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
261 # define YY_(msgid) dgettext ("bison-runtime", msgid)
265 # define YY_(msgid) msgid
269 /* Suppress unused-variable warnings by "using" E. */
270 #if ! defined lint || defined __GNUC__
271 # define YYUSE(e) ((void) (e))
273 # define YYUSE(e) /* empty */
276 /* Identity function, used to suppress warnings about constant conditions. */
280 #if (defined __STDC__ || defined __C99__FUNC__ \
281 || defined __cplusplus || defined _MSC_VER)
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
301 # define YYSTACK_ALLOC __builtin_alloca
302 # elif defined __BUILTIN_VA_ARG_INCR
303 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
305 # define YYSTACK_ALLOC __alloca
306 # elif defined _MSC_VER
307 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
308 # define alloca _alloca
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 */
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 */
333 # define YYSTACK_ALLOC YYMALLOC
334 # define YYSTACK_FREE YYFREE
335 # ifndef YYSTACK_ALLOC_MAXIMUM
336 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
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 */
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 */
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 */
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. */
371 yytype_int16 yyss_alloc;
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
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
387 # if defined __GNUC__ && 1 < __GNUC__
388 # define YYCOPY(To, From, Count) \
389 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
391 # define YYCOPY(To, From, Count) \
395 for (yyi = 0; yyi < (Count); yyi++) \
396 (To)[yyi] = (From)[yyi]; \
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
407 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
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); \
420 /* YYFINAL -- State number of the termination state. */
422 /* YYLAST -- Last index in YYTABLE. */
425 /* YYNTOKENS -- Number of terminals. */
427 /* YYNNTS -- Number of nonterminals. */
429 /* YYNRULES -- Number of rules. */
431 /* YYNRULES -- Number of states. */
432 #define YYNSTATES 191
434 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
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[] =
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,
477 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
479 static const yytype_uint16 yyprhs[] =
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
495 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
496 static const yytype_int8 yyrhs[] =
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,
535 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
536 static const yytype_uint16 yyrline[] =
538 0, 104, 104, 104, 106, 106, 108, 110, 111, 112,
539 113, 114, 115, 119, 123, 123, 123, 123, 123, 123,
540 123, 123, 127, 128, 129, 130, 131, 132, 136, 137,
541 143, 151, 157, 165, 175, 177, 178, 179, 180, 181,
542 182, 185, 193, 199, 209, 215, 221, 224, 226, 237,
543 238, 243, 252, 257, 265, 268, 270, 271, 272, 273,
544 274, 277, 283, 294, 300, 310, 312, 317, 325, 333,
545 336, 338, 339, 340, 345, 352, 359, 364, 372, 375,
546 377, 378, 379, 382, 390, 397, 404, 410, 417, 419,
547 420, 421, 424, 432, 434, 435, 438, 445, 447, 452,
548 453, 456, 457, 458, 462, 463, 466, 467, 470, 471,
549 472, 473, 474, 475, 476, 479, 480, 483, 484
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[] =
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
579 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
581 static const yytype_uint16 yytoknum[] =
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
590 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
591 static const yytype_uint8 yyr1[] =
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
607 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
608 static const yytype_uint8 yyr2[] =
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
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[] =
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,
651 /* YYDEFGOTO[NTERM-NUM]. */
652 static const yytype_int16 yydefgoto[] =
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
661 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
663 #define YYPACT_NINF -90
664 static const yytype_int16 yypact[] =
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,
688 /* YYPGOTO[NTERM-NUM]. */
689 static const yytype_int16 yypgoto[] =
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
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[] =
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,
737 static const yytype_int16 yycheck[] =
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,
771 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
772 symbol of state STATE-NUM. */
773 static const yytype_uint8 yystos[] =
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,
797 #define yyerrok (yyerrstatus = 0)
798 #define yyclearin (yychar = YYEMPTY)
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. However,
810 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
811 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
814 #define YYFAIL goto yyerrlab
816 /* This is here to suppress warnings from the GCC cpp's
817 -Wunused-macros. Normally we don't worry about that warning, but
818 some users do, and we want to make it easy for users to remove
819 YYFAIL uses, which will produce warnings from Bison 2.5. */
822 #define YYRECOVERING() (!!yyerrstatus)
824 #define YYBACKUP(Token, Value) \
826 if (yychar == YYEMPTY && yylen == 1) \
830 yytoken = YYTRANSLATE (yychar); \
836 yyerror (YY_("syntax error: cannot back up")); \
843 #define YYERRCODE 256
846 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
847 If N is 0, then set CURRENT to the empty location which ends
848 the previous symbol: RHS[0] (always defined). */
850 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
851 #ifndef YYLLOC_DEFAULT
852 # define YYLLOC_DEFAULT(Current, Rhs, N) \
856 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
857 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
858 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
859 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
863 (Current).first_line = (Current).last_line = \
864 YYRHSLOC (Rhs, 0).last_line; \
865 (Current).first_column = (Current).last_column = \
866 YYRHSLOC (Rhs, 0).last_column; \
872 /* YY_LOCATION_PRINT -- Print the location on the stream.
873 This macro was not mandated originally: define only if we know
874 we won't break user code: when these are the locations we know. */
876 #ifndef YY_LOCATION_PRINT
877 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
878 # define YY_LOCATION_PRINT(File, Loc) \
879 fprintf (File, "%d.%d-%d.%d", \
880 (Loc).first_line, (Loc).first_column, \
881 (Loc).last_line, (Loc).last_column)
883 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
888 /* YYLEX -- calling `yylex' with the right arguments. */
891 # define YYLEX yylex (YYLEX_PARAM)
893 # define YYLEX yylex ()
896 /* Enable debugging if requested. */
900 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
901 # define YYFPRINTF fprintf
904 # define YYDPRINTF(Args) \
910 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
914 YYFPRINTF (stderr, "%s ", Title); \
915 yy_symbol_print (stderr, \
917 YYFPRINTF (stderr, "\n"); \
922 /*--------------------------------.
923 | Print this symbol on YYOUTPUT. |
924 `--------------------------------*/
927 #if (defined __STDC__ || defined __C99__FUNC__ \
928 || defined __cplusplus || defined _MSC_VER)
930 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
933 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
936 YYSTYPE const * const yyvaluep;
942 if (yytype < YYNTOKENS)
943 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
955 /*--------------------------------.
956 | Print this symbol on YYOUTPUT. |
957 `--------------------------------*/
959 #if (defined __STDC__ || defined __C99__FUNC__ \
960 || defined __cplusplus || defined _MSC_VER)
962 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
965 yy_symbol_print (yyoutput, yytype, yyvaluep)
968 YYSTYPE const * const yyvaluep;
971 if (yytype < YYNTOKENS)
972 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
974 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
976 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
977 YYFPRINTF (yyoutput, ")");
980 /*------------------------------------------------------------------.
981 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
983 `------------------------------------------------------------------*/
985 #if (defined __STDC__ || defined __C99__FUNC__ \
986 || defined __cplusplus || defined _MSC_VER)
988 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
991 yy_stack_print (yybottom, yytop)
992 yytype_int16 *yybottom;
996 YYFPRINTF (stderr, "Stack now");
997 for (; yybottom <= yytop; yybottom++)
999 int yybot = *yybottom;
1000 YYFPRINTF (stderr, " %d", yybot);
1002 YYFPRINTF (stderr, "\n");
1005 # define YY_STACK_PRINT(Bottom, Top) \
1008 yy_stack_print ((Bottom), (Top)); \
1012 /*------------------------------------------------.
1013 | Report that the YYRULE is going to be reduced. |
1014 `------------------------------------------------*/
1016 #if (defined __STDC__ || defined __C99__FUNC__ \
1017 || defined __cplusplus || defined _MSC_VER)
1019 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1022 yy_reduce_print (yyvsp, yyrule)
1027 int yynrhs = yyr2[yyrule];
1029 unsigned long int yylno = yyrline[yyrule];
1030 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1032 /* The symbols being reduced. */
1033 for (yyi = 0; yyi < yynrhs; yyi++)
1035 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1036 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1037 &(yyvsp[(yyi + 1) - (yynrhs)])
1039 YYFPRINTF (stderr, "\n");
1043 # define YY_REDUCE_PRINT(Rule) \
1046 yy_reduce_print (yyvsp, Rule); \
1049 /* Nonzero means print parse trace. It is left uninitialized so that
1050 multiple parsers can coexist. */
1052 #else /* !YYDEBUG */
1053 # define YYDPRINTF(Args)
1054 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1055 # define YY_STACK_PRINT(Bottom, Top)
1056 # define YY_REDUCE_PRINT(Rule)
1057 #endif /* !YYDEBUG */
1060 /* YYINITDEPTH -- initial size of the parser's stacks. */
1062 # define YYINITDEPTH 200
1065 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1066 if the built-in stack extension method is used).
1068 Do not make this value too large; the results are undefined if
1069 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1070 evaluated with infinite-precision integer arithmetic. */
1073 # define YYMAXDEPTH 10000
1081 # if defined __GLIBC__ && defined _STRING_H
1082 # define yystrlen strlen
1084 /* Return the length of YYSTR. */
1085 #if (defined __STDC__ || defined __C99__FUNC__ \
1086 || defined __cplusplus || defined _MSC_VER)
1088 yystrlen (const char *yystr)
1096 for (yylen = 0; yystr[yylen]; yylen++)
1104 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1105 # define yystpcpy stpcpy
1107 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1109 #if (defined __STDC__ || defined __C99__FUNC__ \
1110 || defined __cplusplus || defined _MSC_VER)
1112 yystpcpy (char *yydest, const char *yysrc)
1115 yystpcpy (yydest, yysrc)
1121 const char *yys = yysrc;
1123 while ((*yyd++ = *yys++) != '\0')
1132 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1133 quotes and backslashes, so that it's suitable for yyerror. The
1134 heuristic is that double-quoting is unnecessary unless the string
1135 contains an apostrophe, a comma, or backslash (other than
1136 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1137 null, do not copy; instead, return the length of what the result
1140 yytnamerr (char *yyres, const char *yystr)
1145 char const *yyp = yystr;
1152 goto do_not_strip_quotes;
1156 goto do_not_strip_quotes;
1169 do_not_strip_quotes: ;
1173 return yystrlen (yystr);
1175 return yystpcpy (yyres, yystr) - yyres;
1179 /* Copy into YYRESULT an error message about the unexpected token
1180 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1181 including the terminating null byte. If YYRESULT is null, do not
1182 copy anything; just return the number of bytes that would be
1183 copied. As a special case, return 0 if an ordinary "syntax error"
1184 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1185 size calculation. */
1187 yysyntax_error (char *yyresult, int yystate, int yychar)
1189 int yyn = yypact[yystate];
1191 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1195 int yytype = YYTRANSLATE (yychar);
1196 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1197 YYSIZE_T yysize = yysize0;
1199 int yysize_overflow = 0;
1200 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1201 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1205 /* This is so xgettext sees the translatable formats that are
1206 constructed on the fly. */
1207 YY_("syntax error, unexpected %s");
1208 YY_("syntax error, unexpected %s, expecting %s");
1209 YY_("syntax error, unexpected %s, expecting %s or %s");
1210 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1211 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1215 static char const yyunexpected[] = "syntax error, unexpected %s";
1216 static char const yyexpecting[] = ", expecting %s";
1217 static char const yyor[] = " or %s";
1218 char yyformat[sizeof yyunexpected
1219 + sizeof yyexpecting - 1
1220 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1221 * (sizeof yyor - 1))];
1222 char const *yyprefix = yyexpecting;
1224 /* Start YYX at -YYN if negative to avoid negative indexes in
1226 int yyxbegin = yyn < 0 ? -yyn : 0;
1228 /* Stay within bounds of both yycheck and yytname. */
1229 int yychecklim = YYLAST - yyn + 1;
1230 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1233 yyarg[0] = yytname[yytype];
1234 yyfmt = yystpcpy (yyformat, yyunexpected);
1236 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1237 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1239 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1243 yyformat[sizeof yyunexpected - 1] = '\0';
1246 yyarg[yycount++] = yytname[yyx];
1247 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1248 yysize_overflow |= (yysize1 < yysize);
1250 yyfmt = yystpcpy (yyfmt, yyprefix);
1254 yyf = YY_(yyformat);
1255 yysize1 = yysize + yystrlen (yyf);
1256 yysize_overflow |= (yysize1 < yysize);
1259 if (yysize_overflow)
1260 return YYSIZE_MAXIMUM;
1264 /* Avoid sprintf, as that infringes on the user's name space.
1265 Don't have undefined behavior even if the translation
1266 produced a string with the wrong number of "%s"s. */
1267 char *yyp = yyresult;
1269 while ((*yyp = *yyf) != '\0')
1271 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1273 yyp += yytnamerr (yyp, yyarg[yyi++]);
1286 #endif /* YYERROR_VERBOSE */
1289 /*-----------------------------------------------.
1290 | Release the memory associated to this symbol. |
1291 `-----------------------------------------------*/
1294 #if (defined __STDC__ || defined __C99__FUNC__ \
1295 || defined __cplusplus || defined _MSC_VER)
1297 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1300 yydestruct (yymsg, yytype, yyvaluep)
1310 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1314 case 53: /* "choice_entry" */
1317 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1318 (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
1319 if (current_menu == (yyvaluep->menu))
1324 case 59: /* "if_entry" */
1327 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1328 (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
1329 if (current_menu == (yyvaluep->menu))
1334 case 65: /* "menu_entry" */
1337 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1338 (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
1339 if (current_menu == (yyvaluep->menu))
1350 /* Prevent warnings from -Wmissing-prototypes. */
1351 #ifdef YYPARSE_PARAM
1352 #if defined __STDC__ || defined __cplusplus
1353 int yyparse (void *YYPARSE_PARAM);
1357 #else /* ! YYPARSE_PARAM */
1358 #if defined __STDC__ || defined __cplusplus
1363 #endif /* ! YYPARSE_PARAM */
1366 /* The lookahead symbol. */
1369 /* The semantic value of the lookahead symbol. */
1372 /* Number of syntax errors so far. */
1377 /*-------------------------.
1378 | yyparse or yypush_parse. |
1379 `-------------------------*/
1381 #ifdef YYPARSE_PARAM
1382 #if (defined __STDC__ || defined __C99__FUNC__ \
1383 || defined __cplusplus || defined _MSC_VER)
1385 yyparse (void *YYPARSE_PARAM)
1388 yyparse (YYPARSE_PARAM)
1389 void *YYPARSE_PARAM;
1391 #else /* ! YYPARSE_PARAM */
1392 #if (defined __STDC__ || defined __C99__FUNC__ \
1393 || defined __cplusplus || defined _MSC_VER)
1406 /* Number of tokens to shift before error messages enabled. */
1409 /* The stacks and their tools:
1410 `yyss': related to states.
1411 `yyvs': related to semantic values.
1413 Refer to the stacks thru separate pointers, to allow yyoverflow
1414 to reallocate them elsewhere. */
1416 /* The state stack. */
1417 yytype_int16 yyssa[YYINITDEPTH];
1419 yytype_int16 *yyssp;
1421 /* The semantic value stack. */
1422 YYSTYPE yyvsa[YYINITDEPTH];
1426 YYSIZE_T yystacksize;
1427 char abs_path[PATH_MAX];
1428 const char *path, *base;
1432 /* Lookahead token as an internal (translated) token number. */
1434 /* The variables used to return semantic value and location from the
1439 /* Buffer for error messages, and its allocated size. */
1441 char *yymsg = yymsgbuf;
1442 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1445 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1447 /* The number of symbols on the RHS of the reduced rule.
1448 Keep to zero when no symbol should be popped. */
1454 yystacksize = YYINITDEPTH;
1456 YYDPRINTF ((stderr, "Starting parse\n"));
1461 yychar = YYEMPTY; /* Cause a token to be read. */
1463 /* Initialize stack pointers.
1464 Waste one element of value and location stack
1465 so that they stay on the same level as the state stack.
1466 The wasted elements are never initialized. */
1472 /*------------------------------------------------------------.
1473 | yynewstate -- Push a new state, which is found in yystate. |
1474 `------------------------------------------------------------*/
1476 /* In all cases, when you get here, the value and location stacks
1477 have just been pushed. So pushing a state here evens the stacks. */
1483 if (yyss + yystacksize - 1 <= yyssp)
1485 /* Get the current used size of the three stacks, in elements. */
1486 YYSIZE_T yysize = yyssp - yyss + 1;
1490 /* Give user a chance to reallocate the stack. Use copies of
1491 these so that the &'s don't force the real ones into
1493 YYSTYPE *yyvs1 = yyvs;
1494 yytype_int16 *yyss1 = yyss;
1496 /* Each stack pointer address is followed by the size of the
1497 data in use in that stack, in bytes. This used to be a
1498 conditional around just the two extra args, but that might
1499 be undefined if yyoverflow is a macro. */
1500 yyoverflow (YY_("memory exhausted"),
1501 &yyss1, yysize * sizeof (*yyssp),
1502 &yyvs1, yysize * sizeof (*yyvsp),
1508 #else /* no yyoverflow */
1509 # ifndef YYSTACK_RELOCATE
1510 goto yyexhaustedlab;
1512 /* Extend the stack our own way. */
1513 if (YYMAXDEPTH <= yystacksize)
1514 goto yyexhaustedlab;
1516 if (YYMAXDEPTH < yystacksize)
1517 yystacksize = YYMAXDEPTH;
1520 yytype_int16 *yyss1 = yyss;
1521 union yyalloc *yyptr =
1522 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1524 goto yyexhaustedlab;
1525 YYSTACK_RELOCATE (yyss_alloc, yyss);
1526 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1527 # undef YYSTACK_RELOCATE
1529 YYSTACK_FREE (yyss1);
1532 #endif /* no yyoverflow */
1534 yyssp = yyss + yysize - 1;
1535 yyvsp = yyvs + yysize - 1;
1537 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1538 (unsigned long int) yystacksize));
1540 if (yyss + yystacksize - 1 <= yyssp)
1544 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1546 if (yystate == YYFINAL)
1556 /* Do appropriate processing given the current state. Read a
1557 lookahead token if we need one and don't already have one. */
1559 /* First try to decide what to do without reference to lookahead token. */
1560 yyn = yypact[yystate];
1561 if (yyn == YYPACT_NINF)
1564 /* Not known => get a lookahead token if don't already have one. */
1566 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1567 if (yychar == YYEMPTY)
1569 YYDPRINTF ((stderr, "Reading a token: "));
1573 if (yychar <= YYEOF)
1575 yychar = yytoken = YYEOF;
1576 YYDPRINTF ((stderr, "Now at end of input.\n"));
1580 yytoken = YYTRANSLATE (yychar);
1581 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1584 /* If the proper action on seeing token YYTOKEN is to reduce or to
1585 detect an error, take that action. */
1587 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1592 if (yyn == 0 || yyn == YYTABLE_NINF)
1598 /* Count tokens shifted since error; after three, turn off error
1603 /* Shift the lookahead token. */
1604 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1606 /* Discard the shifted token. */
1615 /*-----------------------------------------------------------.
1616 | yydefault -- do the default action for the current state. |
1617 `-----------------------------------------------------------*/
1619 yyn = yydefact[yystate];
1625 /*-----------------------------.
1626 | yyreduce -- Do a reduction. |
1627 `-----------------------------*/
1629 /* yyn is the number of a rule to reduce with. */
1632 /* If YYLEN is nonzero, implement the default value of the action:
1635 Otherwise, the following line sets YYVAL to garbage.
1636 This behavior is undocumented and Bison
1637 users should not rely upon it. Assigning to YYVAL
1638 unconditionally makes the parser a bit smaller, and it avoids a
1639 GCC warning that YYVAL may be used uninitialized. */
1640 yyval = yyvsp[1-yylen];
1643 YY_REDUCE_PRINT (yyn);
1648 { zconf_error("unexpected end statement"); ;}
1653 { zconf_error("unknown statement \"%s\"", (yyvsp[(2) - (4)].string)); ;}
1659 zconf_error("unexpected option \"%s\"", kconf_id_strings + (yyvsp[(2) - (4)].id)->name);
1665 { zconf_error("invalid statement"); ;}
1670 { zconf_error("unknown option \"%s\"", (yyvsp[(1) - (3)].string)); ;}
1675 { zconf_error("invalid option"); ;}
1681 struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0);
1682 sym->flags |= SYMBOL_OPTIONAL;
1683 menu_add_entry(sym);
1684 printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
1692 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1699 struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0);
1700 sym->flags |= SYMBOL_OPTIONAL;
1701 menu_add_entry(sym);
1702 printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
1709 if (current_entry->prompt)
1710 current_entry->prompt->type = P_MENU;
1712 zconfprint("warning: menuconfig statement without prompt");
1714 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1721 menu_set_type((yyvsp[(1) - (3)].id)->stype);
1722 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1723 zconf_curname(), zconf_lineno(),
1724 (yyvsp[(1) - (3)].id)->stype);
1731 menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr));
1732 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1739 menu_add_expr(P_DEFAULT, (yyvsp[(2) - (4)].expr), (yyvsp[(3) - (4)].expr));
1740 if ((yyvsp[(1) - (4)].id)->stype != S_UNKNOWN)
1741 menu_set_type((yyvsp[(1) - (4)].id)->stype);
1742 printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
1743 zconf_curname(), zconf_lineno(),
1744 (yyvsp[(1) - (4)].id)->stype);
1751 menu_add_symbol(P_SELECT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr));
1752 printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
1759 menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[(2) - (5)].symbol), (yyvsp[(3) - (5)].symbol)), (yyvsp[(4) - (5)].expr));
1760 printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
1767 const struct kconf_id *id = kconf_id_lookup((yyvsp[(2) - (3)].string), strlen((yyvsp[(2) - (3)].string)));
1768 if (id && id->flags & TF_OPTION)
1769 menu_add_option(id->token, (yyvsp[(3) - (3)].string));
1771 zconfprint("warning: ignoring unknown option %s", (yyvsp[(2) - (3)].string));
1772 free((yyvsp[(2) - (3)].string));
1778 { (yyval.string) = NULL; ;}
1783 { (yyval.string) = (yyvsp[(2) - (2)].string); ;}
1789 struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), SYMBOL_CHOICE);
1790 sym->flags |= SYMBOL_AUTO;
1791 menu_add_entry(sym);
1792 menu_add_expr(P_CHOICE, NULL, NULL);
1793 printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
1800 (yyval.menu) = menu_add_menu();
1807 if (zconf_endtoken((yyvsp[(1) - (1)].id), T_CHOICE, T_ENDCHOICE)) {
1809 printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
1817 menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr));
1818 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1825 if ((yyvsp[(1) - (3)].id)->stype == S_BOOLEAN || (yyvsp[(1) - (3)].id)->stype == S_TRISTATE) {
1826 menu_set_type((yyvsp[(1) - (3)].id)->stype);
1827 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1828 zconf_curname(), zconf_lineno(),
1829 (yyvsp[(1) - (3)].id)->stype);
1838 current_entry->sym->flags |= SYMBOL_OPTIONAL;
1839 printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
1846 if ((yyvsp[(1) - (4)].id)->stype == S_UNKNOWN) {
1847 menu_add_symbol(P_DEFAULT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr));
1848 printd(DEBUG_PARSE, "%s:%d:default\n",
1849 zconf_curname(), zconf_lineno());
1858 printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
1859 menu_add_entry(NULL);
1860 menu_add_dep((yyvsp[(2) - (3)].expr));
1861 (yyval.menu) = menu_add_menu();
1868 if (zconf_endtoken((yyvsp[(1) - (1)].id), T_IF, T_ENDIF)) {
1870 printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
1878 menu_add_prompt(P_MENU, (yyvsp[(2) - (3)].string), NULL);
1885 menu_add_entry(NULL);
1886 menu_add_prompt(P_MENU, (yyvsp[(2) - (3)].string), NULL);
1887 printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
1894 (yyval.menu) = menu_add_menu();
1901 if (zconf_endtoken((yyvsp[(1) - (1)].id), T_MENU, T_ENDMENU)) {
1903 printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
1911 char tmp_abs_name[256];
1912 path = yyvsp[(2) - (3)].string;
1913 strncpy(tmp_abs_name, current_file->abs_name, 255);
1914 base = dirname(tmp_abs_name);
1915 snprintf(abs_path, sizeof(abs_path), "%s/%s", base, path);
1916 printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), path);
1917 zconf_nextfile(abs_path);
1924 menu_add_entry(NULL);
1925 menu_add_prompt(P_COMMENT, (yyvsp[(2) - (3)].string), NULL);
1926 printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
1940 printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
1948 current_entry->help = (yyvsp[(2) - (2)].string);
1955 menu_add_dep((yyvsp[(3) - (4)].expr));
1956 printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
1963 menu_add_visibility((yyvsp[(2) - (2)].expr));
1970 menu_add_prompt(P_PROMPT, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].expr));
1976 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
1981 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
1986 { (yyval.id) = (yyvsp[(1) - (2)].id); ;}
1991 { (yyval.expr) = NULL; ;}
1996 { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;}
2001 { (yyval.expr) = expr_alloc_symbol((yyvsp[(1) - (1)].symbol)); ;}
2006 { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
2011 { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
2016 { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
2021 { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[(2) - (2)].expr)); ;}
2026 { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
2031 { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
2036 { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), 0); free((yyvsp[(1) - (1)].string)); ;}
2041 { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), SYMBOL_CONST); free((yyvsp[(1) - (1)].string)); ;}
2046 { (yyval.string) = NULL; ;}
2053 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2057 YY_STACK_PRINT (yyss, yyssp);
2061 /* Now `shift' the result of the reduction. Determine what state
2062 that goes to, based on the state we popped back to and the rule
2063 number reduced by. */
2067 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2068 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2069 yystate = yytable[yystate];
2071 yystate = yydefgoto[yyn - YYNTOKENS];
2076 /*------------------------------------.
2077 | yyerrlab -- here on detecting error |
2078 `------------------------------------*/
2080 /* If not already recovering from an error, report this error. */
2084 #if ! YYERROR_VERBOSE
2085 yyerror (YY_("syntax error"));
2088 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2089 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2091 YYSIZE_T yyalloc = 2 * yysize;
2092 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2093 yyalloc = YYSTACK_ALLOC_MAXIMUM;
2094 if (yymsg != yymsgbuf)
2095 YYSTACK_FREE (yymsg);
2096 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2098 yymsg_alloc = yyalloc;
2102 yymsg_alloc = sizeof yymsgbuf;
2106 if (0 < yysize && yysize <= yymsg_alloc)
2108 (void) yysyntax_error (yymsg, yystate, yychar);
2113 yyerror (YY_("syntax error"));
2115 goto yyexhaustedlab;
2123 if (yyerrstatus == 3)
2125 /* If just tried and failed to reuse lookahead token after an
2126 error, discard it. */
2128 if (yychar <= YYEOF)
2130 /* Return failure if at end of input. */
2131 if (yychar == YYEOF)
2136 yydestruct ("Error: discarding",
2142 /* Else will try to reuse lookahead token after shifting the error
2147 /*---------------------------------------------------.
2148 | yyerrorlab -- error raised explicitly by YYERROR. |
2149 `---------------------------------------------------*/
2152 /* Pacify compilers like GCC when the user code never invokes
2153 YYERROR and the label yyerrorlab therefore never appears in user
2155 if (/*CONSTCOND*/ 0)
2158 /* Do not reclaim the symbols of the rule which action triggered
2162 YY_STACK_PRINT (yyss, yyssp);
2167 /*-------------------------------------------------------------.
2168 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2169 `-------------------------------------------------------------*/
2171 yyerrstatus = 3; /* Each real token shifted decrements this. */
2175 yyn = yypact[yystate];
2176 if (yyn != YYPACT_NINF)
2179 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2187 /* Pop the current state because it cannot handle the error token. */
2192 yydestruct ("Error: popping",
2193 yystos[yystate], yyvsp);
2196 YY_STACK_PRINT (yyss, yyssp);
2202 /* Shift the error token. */
2203 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2209 /*-------------------------------------.
2210 | yyacceptlab -- YYACCEPT comes here. |
2211 `-------------------------------------*/
2216 /*-----------------------------------.
2217 | yyabortlab -- YYABORT comes here. |
2218 `-----------------------------------*/
2223 #if !defined(yyoverflow) || YYERROR_VERBOSE
2224 /*-------------------------------------------------.
2225 | yyexhaustedlab -- memory exhaustion comes here. |
2226 `-------------------------------------------------*/
2228 yyerror (YY_("memory exhausted"));
2234 if (yychar != YYEMPTY)
2235 yydestruct ("Cleanup: discarding lookahead",
2237 /* Do not reclaim the symbols of the rule which action triggered
2238 this YYABORT or YYACCEPT. */
2240 YY_STACK_PRINT (yyss, yyssp);
2241 while (yyssp != yyss)
2243 yydestruct ("Cleanup: popping",
2244 yystos[*yyssp], yyvsp);
2249 YYSTACK_FREE (yyss);
2252 if (yymsg != yymsgbuf)
2253 YYSTACK_FREE (yymsg);
2255 /* Make sure YYID is used. */
2256 return YYID (yyresult);
2263 void conf_parse(const char *name)
2268 zconf_initscan(name);
2272 modules_sym = sym_lookup(NULL, 0);
2273 modules_sym->type = S_BOOLEAN;
2274 modules_sym->flags |= SYMBOL_AUTO;
2275 rootmenu.prompt = menu_add_prompt(P_MENU, "Linux Kernel Configuration", NULL);
2277 if (getenv("ZCONF_DEBUG"))
2282 if (!modules_sym->prop) {
2283 struct property *prop;
2285 prop = prop_alloc(P_DEFAULT, modules_sym);
2286 prop->expr = expr_alloc_symbol(sym_lookup("MODULES", 0));
2289 rootmenu.prompt->text = _(rootmenu.prompt->text);
2290 rootmenu.prompt->text = sym_expand_string_value(rootmenu.prompt->text);
2292 menu_finalize(&rootmenu);
2293 for_all_symbols(i, sym) {
2294 if (sym_check_deps(sym))
2299 sym_set_change_count(1);
2302 static const char *zconf_tokenname(int token)
2305 case T_MENU: return "menu";
2306 case T_ENDMENU: return "endmenu";
2307 case T_CHOICE: return "choice";
2308 case T_ENDCHOICE: return "endchoice";
2309 case T_IF: return "if";
2310 case T_ENDIF: return "endif";
2311 case T_DEPENDS: return "depends";
2312 case T_VISIBLE: return "visible";
2317 static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken)
2319 if (id->token != endtoken) {
2320 zconf_error("unexpected '%s' within %s block",
2321 kconf_id_strings + id->name, zconf_tokenname(starttoken));
2325 if (current_menu->file != current_file) {
2326 zconf_error("'%s' in different file than '%s'",
2327 kconf_id_strings + id->name, zconf_tokenname(starttoken));
2328 fprintf(stderr, "%s:%d: location of the '%s'\n",
2329 current_menu->file->name, current_menu->lineno,
2330 zconf_tokenname(starttoken));
2337 static void zconfprint(const char *err, ...)
2341 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
2343 vfprintf(stderr, err, ap);
2345 fprintf(stderr, "\n");
2348 static void zconf_error(const char *err, ...)
2353 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
2355 vfprintf(stderr, err, ap);
2357 fprintf(stderr, "\n");
2360 static void zconferror(const char *err)
2362 fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
2365 static void print_quoted_string(FILE *out, const char *str)
2371 while ((p = strchr(str, '"'))) {
2374 fprintf(out, "%.*s", len, str);
2382 static void print_symbol(FILE *out, struct menu *menu)
2384 struct symbol *sym = menu->sym;
2385 struct property *prop;
2387 if (sym_is_choice(sym))
2388 fprintf(out, "\nchoice\n");
2390 fprintf(out, "\nconfig %s\n", sym->name);
2391 switch (sym->type) {
2393 fputs(" boolean\n", out);
2396 fputs(" tristate\n", out);
2399 fputs(" string\n", out);
2402 fputs(" integer\n", out);
2405 fputs(" hex\n", out);
2408 fputs(" ???\n", out);
2411 for (prop = sym->prop; prop; prop = prop->next) {
2412 if (prop->menu != menu)
2414 switch (prop->type) {
2416 fputs(" prompt ", out);
2417 print_quoted_string(out, prop->text);
2418 if (!expr_is_yes(prop->visible.expr)) {
2420 expr_fprint(prop->visible.expr, out);
2425 fputs( " default ", out);
2426 expr_fprint(prop->expr, out);
2427 if (!expr_is_yes(prop->visible.expr)) {
2429 expr_fprint(prop->visible.expr, out);
2434 fputs(" #choice value\n", out);
2437 fputs( " select ", out);
2438 expr_fprint(prop->expr, out);
2442 fputs( " range ", out);
2443 expr_fprint(prop->expr, out);
2447 fputs( " menu ", out);
2448 print_quoted_string(out, prop->text);
2452 fprintf(out, " unknown prop %d!\n", prop->type);
2457 int len = strlen(menu->help);
2458 while (menu->help[--len] == '\n')
2459 menu->help[len] = 0;
2460 fprintf(out, " help\n%s\n", menu->help);
2464 void zconfdump(FILE *out)
2466 struct property *prop;
2470 menu = rootmenu.list;
2472 if ((sym = menu->sym))
2473 print_symbol(out, menu);
2474 else if ((prop = menu->prompt)) {
2475 switch (prop->type) {
2477 fputs("\ncomment ", out);
2478 print_quoted_string(out, prop->text);
2482 fputs("\nmenu ", out);
2483 print_quoted_string(out, prop->text);
2489 if (!expr_is_yes(prop->visible.expr)) {
2490 fputs(" depends ", out);
2491 expr_fprint(prop->visible.expr, out);
2498 else if (menu->next)
2500 else while ((menu = menu->parent)) {
2501 if (menu->prompt && menu->prompt->type == P_MENU)
2502 fputs("\nendmenu\n", out);
2511 #include "zconf.lex.c"
2513 #include "confdata.c"