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