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