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