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