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