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