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