yann@943: /* A Bison parser, made by GNU Bison 2.3. */ yann@1: yann@943: /* Skeleton implementation for Bison's Yacc-like parsers in C yann@943: yann@943: Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 yann@943: Free Software Foundation, Inc. yann@1: yann@1: This program is free software; you can redistribute it and/or modify yann@1: it under the terms of the GNU General Public License as published by yann@1: the Free Software Foundation; either version 2, or (at your option) yann@1: any later version. yann@1: yann@1: This program is distributed in the hope that it will be useful, yann@1: but WITHOUT ANY WARRANTY; without even the implied warranty of yann@1: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the yann@1: GNU General Public License for more details. yann@1: yann@1: You should have received a copy of the GNU General Public License yann@1: along with this program; if not, write to the Free Software yann@1: Foundation, Inc., 51 Franklin Street, Fifth Floor, yann@1: Boston, MA 02110-1301, USA. */ yann@1: yann@943: /* As a special exception, you may create a larger work that contains yann@943: part or all of the Bison parser skeleton and distribute that work yann@943: under terms of your choice, so long as that work isn't itself a yann@943: parser generator using the skeleton or a modified version thereof yann@943: as a parser skeleton. Alternatively, if you modify or redistribute yann@943: the parser skeleton itself, you may (at your option) remove this yann@943: special exception, which will cause the skeleton and the resulting yann@943: Bison output files to be licensed under the GNU General Public yann@943: License without this special exception. yann@1: yann@943: This special exception was added by the Free Software Foundation in yann@943: version 2.2 of Bison. */ yann@943: yann@943: /* C LALR(1) parser skeleton written by Richard Stallman, by yann@943: simplifying the original so-called "semantic" parser. */ yann@1: yann@1: /* All symbols defined below should begin with yy or YY, to avoid yann@1: infringing on user name space. This should be done even for local yann@1: variables, as they might otherwise be expanded by user macros. yann@1: There are some unavoidable exceptions within include files to yann@1: define necessary library symbols; they are noted "INFRINGES ON yann@1: USER NAME SPACE" below. */ yann@1: yann@1: /* Identify Bison output. */ yann@1: #define YYBISON 1 yann@1: yann@1: /* Bison version. */ yann@943: #define YYBISON_VERSION "2.3" yann@1: yann@1: /* Skeleton name. */ yann@1: #define YYSKELETON_NAME "yacc.c" yann@1: yann@1: /* Pure parsers. */ yann@1: #define YYPURE 0 yann@1: yann@1: /* Using locations. */ yann@1: #define YYLSP_NEEDED 0 yann@1: yann@1: /* Substitute the variable and function names. */ yann@1: #define yyparse zconfparse yann@1: #define yylex zconflex yann@1: #define yyerror zconferror yann@1: #define yylval zconflval yann@1: #define yychar zconfchar yann@1: #define yydebug zconfdebug yann@1: #define yynerrs zconfnerrs yann@1: yann@1: yann@1: /* Tokens. */ yann@1: #ifndef YYTOKENTYPE yann@1: # define YYTOKENTYPE yann@1: /* Put the tokens into the symbol table, so that GDB and other debuggers yann@1: know about them. */ yann@1: enum yytokentype { yann@1: T_MAINMENU = 258, yann@1: T_MENU = 259, yann@1: T_ENDMENU = 260, yann@1: T_SOURCE = 261, yann@1: T_CHOICE = 262, yann@1: T_ENDCHOICE = 263, yann@1: T_COMMENT = 264, yann@1: T_CONFIG = 265, yann@1: T_MENUCONFIG = 266, yann@1: T_HELP = 267, yann@1: T_HELPTEXT = 268, yann@1: T_IF = 269, yann@1: T_ENDIF = 270, yann@1: T_DEPENDS = 271, yann@943: T_OPTIONAL = 272, yann@943: T_PROMPT = 273, yann@943: T_TYPE = 274, yann@943: T_DEFAULT = 275, yann@943: T_SELECT = 276, yann@943: T_RANGE = 277, yann@943: T_OPTION = 278, yann@943: T_ON = 279, yann@943: T_WORD = 280, yann@943: T_WORD_QUOTE = 281, yann@943: T_UNEQUAL = 282, yann@943: T_CLOSE_PAREN = 283, yann@943: T_OPEN_PAREN = 284, yann@943: T_EOL = 285, yann@943: T_OR = 286, yann@943: T_AND = 287, yann@943: T_EQUAL = 288, yann@943: T_NOT = 289 yann@1: }; yann@1: #endif yann@1: /* Tokens. */ yann@1: #define T_MAINMENU 258 yann@1: #define T_MENU 259 yann@1: #define T_ENDMENU 260 yann@1: #define T_SOURCE 261 yann@1: #define T_CHOICE 262 yann@1: #define T_ENDCHOICE 263 yann@1: #define T_COMMENT 264 yann@1: #define T_CONFIG 265 yann@1: #define T_MENUCONFIG 266 yann@1: #define T_HELP 267 yann@1: #define T_HELPTEXT 268 yann@1: #define T_IF 269 yann@1: #define T_ENDIF 270 yann@1: #define T_DEPENDS 271 yann@943: #define T_OPTIONAL 272 yann@943: #define T_PROMPT 273 yann@943: #define T_TYPE 274 yann@943: #define T_DEFAULT 275 yann@943: #define T_SELECT 276 yann@943: #define T_RANGE 277 yann@943: #define T_OPTION 278 yann@943: #define T_ON 279 yann@943: #define T_WORD 280 yann@943: #define T_WORD_QUOTE 281 yann@943: #define T_UNEQUAL 282 yann@943: #define T_CLOSE_PAREN 283 yann@943: #define T_OPEN_PAREN 284 yann@943: #define T_EOL 285 yann@943: #define T_OR 286 yann@943: #define T_AND 287 yann@943: #define T_EQUAL 288 yann@943: #define T_NOT 289 yann@1: yann@1: yann@1: yann@1: yann@1: /* Copy the first part of user declarations. */ yann@1: yann@1: yann@1: /* yann@1: * Copyright (C) 2002 Roman Zippel yann@1: * Released under the terms of the GNU GPL v2.0. yann@1: */ yann@1: yann@1: #include yann@1: #include yann@1: #include yann@1: #include yann@1: #include yann@1: #include yann@1: yann@1: #define LKC_DIRECT_LINK yann@1: #include "lkc.h" yann@1: yann@1: #include "zconf.hash.c" yann@1: yann@1: #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt) yann@1: yann@1: #define PRINTD 0x0001 yann@1: #define DEBUG_PARSE 0x0002 yann@1: yann@1: int cdebug = PRINTD; yann@1: yann@1: extern int zconflex(void); yann@1: static void zconfprint(const char *err, ...); yann@1: static void zconf_error(const char *err, ...); yann@1: static void zconferror(const char *err); yann@1: static bool zconf_endtoken(struct kconf_id *id, int starttoken, int endtoken); yann@1: yann@1: struct symbol *symbol_hash[257]; yann@1: yann@1: static struct menu *current_menu, *current_entry; yann@1: yann@1: #define YYDEBUG 0 yann@1: #if YYDEBUG yann@1: #define YYERROR_VERBOSE yann@1: #endif yann@1: yann@1: yann@1: /* Enabling traces. */ yann@1: #ifndef YYDEBUG yann@1: # define YYDEBUG 0 yann@1: #endif yann@1: yann@1: /* Enabling verbose error messages. */ yann@1: #ifdef YYERROR_VERBOSE yann@1: # undef YYERROR_VERBOSE yann@1: # define YYERROR_VERBOSE 1 yann@1: #else yann@1: # define YYERROR_VERBOSE 0 yann@1: #endif yann@1: yann@1: /* Enabling the token table. */ yann@1: #ifndef YYTOKEN_TABLE yann@1: # define YYTOKEN_TABLE 0 yann@1: #endif yann@1: yann@943: #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED yann@943: typedef union YYSTYPE yann@1: yann@943: { yann@1: char *string; yann@1: struct file *file; yann@1: struct symbol *symbol; yann@1: struct expr *expr; yann@1: struct menu *menu; yann@1: struct kconf_id *id; yann@943: } yann@943: /* Line 187 of yacc.c. */ yann@1: yann@943: YYSTYPE; yann@1: # define yystype YYSTYPE /* obsolescent; will be withdrawn */ yann@1: # define YYSTYPE_IS_DECLARED 1 yann@1: # define YYSTYPE_IS_TRIVIAL 1 yann@1: #endif yann@1: yann@1: yann@1: yann@1: /* Copy the second part of user declarations. */ yann@1: yann@1: yann@943: /* Line 216 of yacc.c. */ yann@1: yann@1: yann@943: #ifdef short yann@943: # undef short yann@1: #endif yann@943: yann@943: #ifdef YYTYPE_UINT8 yann@943: typedef YYTYPE_UINT8 yytype_uint8; yann@943: #else yann@943: typedef unsigned char yytype_uint8; yann@1: #endif yann@943: yann@943: #ifdef YYTYPE_INT8 yann@943: typedef YYTYPE_INT8 yytype_int8; yann@943: #elif (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@943: typedef signed char yytype_int8; yann@943: #else yann@943: typedef short int yytype_int8; yann@1: #endif yann@943: yann@943: #ifdef YYTYPE_UINT16 yann@943: typedef YYTYPE_UINT16 yytype_uint16; yann@943: #else yann@943: typedef unsigned short int yytype_uint16; yann@1: #endif yann@1: yann@943: #ifdef YYTYPE_INT16 yann@943: typedef YYTYPE_INT16 yytype_int16; yann@943: #else yann@943: typedef short int yytype_int16; yann@943: #endif yann@943: yann@943: #ifndef YYSIZE_T yann@943: # ifdef __SIZE_TYPE__ yann@943: # define YYSIZE_T __SIZE_TYPE__ yann@943: # elif defined size_t yann@943: # define YYSIZE_T size_t yann@943: # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@943: # include /* INFRINGES ON USER NAME SPACE */ yann@943: # define YYSIZE_T size_t yann@943: # else yann@943: # define YYSIZE_T unsigned int yann@943: # endif yann@943: #endif yann@943: yann@943: #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) yann@943: yann@1: #ifndef YY_ yann@1: # if YYENABLE_NLS yann@1: # if ENABLE_NLS yann@1: # include /* INFRINGES ON USER NAME SPACE */ yann@1: # define YY_(msgid) dgettext ("bison-runtime", msgid) yann@1: # endif yann@1: # endif yann@1: # ifndef YY_ yann@1: # define YY_(msgid) msgid yann@1: # endif yann@1: #endif yann@1: yann@943: /* Suppress unused-variable warnings by "using" E. */ yann@943: #if ! defined lint || defined __GNUC__ yann@943: # define YYUSE(e) ((void) (e)) yann@943: #else yann@943: # define YYUSE(e) /* empty */ yann@943: #endif yann@943: yann@943: /* Identity function, used to suppress warnings about constant conditions. */ yann@943: #ifndef lint yann@943: # define YYID(n) (n) yann@943: #else yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@943: static int yann@943: YYID (int i) yann@943: #else yann@943: static int yann@943: YYID (i) yann@943: int i; yann@943: #endif yann@943: { yann@943: return i; yann@943: } yann@943: #endif yann@943: yann@943: #if ! defined yyoverflow || YYERROR_VERBOSE yann@1: yann@1: /* The parser invokes alloca or malloc; define the necessary symbols. */ yann@1: yann@1: # ifdef YYSTACK_USE_ALLOCA yann@1: # if YYSTACK_USE_ALLOCA yann@1: # ifdef __GNUC__ yann@1: # define YYSTACK_ALLOC __builtin_alloca yann@943: # elif defined __BUILTIN_VA_ARG_INCR yann@943: # include /* INFRINGES ON USER NAME SPACE */ yann@943: # elif defined _AIX yann@943: # define YYSTACK_ALLOC __alloca yann@943: # elif defined _MSC_VER yann@943: # include /* INFRINGES ON USER NAME SPACE */ yann@943: # define alloca _alloca yann@1: # else yann@1: # define YYSTACK_ALLOC alloca yann@943: # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: # include /* INFRINGES ON USER NAME SPACE */ yann@943: # ifndef _STDLIB_H yann@943: # define _STDLIB_H 1 yann@943: # endif yann@1: # endif yann@1: # endif yann@1: # endif yann@1: # endif yann@1: yann@1: # ifdef YYSTACK_ALLOC yann@943: /* Pacify GCC's `empty if-body' warning. */ yann@943: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) yann@1: # ifndef YYSTACK_ALLOC_MAXIMUM yann@1: /* The OS might guarantee only one guard page at the bottom of the stack, yann@1: and a page size can be as small as 4096 bytes. So we cannot safely yann@1: invoke alloca (N) if N exceeds 4096. Use a slightly smaller number yann@1: to allow for a few compiler-allocated temporary stack slots. */ yann@943: # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ yann@1: # endif yann@1: # else yann@1: # define YYSTACK_ALLOC YYMALLOC yann@1: # define YYSTACK_FREE YYFREE yann@1: # ifndef YYSTACK_ALLOC_MAXIMUM yann@943: # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM yann@1: # endif yann@943: # if (defined __cplusplus && ! defined _STDLIB_H \ yann@943: && ! ((defined YYMALLOC || defined malloc) \ yann@943: && (defined YYFREE || defined free))) yann@943: # include /* INFRINGES ON USER NAME SPACE */ yann@943: # ifndef _STDLIB_H yann@943: # define _STDLIB_H 1 yann@943: # endif yann@1: # endif yann@1: # ifndef YYMALLOC yann@1: # define YYMALLOC malloc yann@943: # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ yann@1: # endif yann@1: # endif yann@1: # ifndef YYFREE yann@1: # define YYFREE free yann@943: # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: void free (void *); /* INFRINGES ON USER NAME SPACE */ yann@1: # endif yann@1: # endif yann@1: # endif yann@943: #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ yann@1: yann@1: yann@943: #if (! defined yyoverflow \ yann@943: && (! defined __cplusplus \ yann@943: || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) yann@1: yann@1: /* A type that is properly aligned for any stack member. */ yann@1: union yyalloc yann@1: { yann@943: yytype_int16 yyss; yann@1: YYSTYPE yyvs; yann@1: }; yann@1: yann@1: /* The size of the maximum gap between one aligned stack and the next. */ yann@1: # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) yann@1: yann@1: /* The size of an array large to enough to hold all stacks, each with yann@1: N elements. */ yann@1: # define YYSTACK_BYTES(N) \ yann@943: ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ yann@1: + YYSTACK_GAP_MAXIMUM) yann@1: yann@1: /* Copy COUNT objects from FROM to TO. The source and destination do yann@1: not overlap. */ yann@1: # ifndef YYCOPY yann@943: # if defined __GNUC__ && 1 < __GNUC__ yann@1: # define YYCOPY(To, From, Count) \ yann@1: __builtin_memcpy (To, From, (Count) * sizeof (*(From))) yann@1: # else yann@1: # define YYCOPY(To, From, Count) \ yann@1: do \ yann@1: { \ yann@1: YYSIZE_T yyi; \ yann@1: for (yyi = 0; yyi < (Count); yyi++) \ yann@1: (To)[yyi] = (From)[yyi]; \ yann@1: } \ yann@943: while (YYID (0)) yann@1: # endif yann@1: # endif yann@1: yann@1: /* Relocate STACK from its old location to the new one. The yann@1: local variables YYSIZE and YYSTACKSIZE give the old and new number of yann@1: elements in the stack, and YYPTR gives the new location of the yann@1: stack. Advance YYPTR to a properly aligned location for the next yann@1: stack. */ yann@1: # define YYSTACK_RELOCATE(Stack) \ yann@1: do \ yann@1: { \ yann@1: YYSIZE_T yynewbytes; \ yann@1: YYCOPY (&yyptr->Stack, Stack, yysize); \ yann@1: Stack = &yyptr->Stack; \ yann@1: yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yann@1: yyptr += yynewbytes / sizeof (*yyptr); \ yann@1: } \ yann@943: while (YYID (0)) yann@1: yann@1: #endif yann@1: yann@943: /* YYFINAL -- State number of the termination state. */ yann@1: #define YYFINAL 3 yann@1: /* YYLAST -- Last index in YYTABLE. */ yann@943: #define YYLAST 259 yann@1: yann@943: /* YYNTOKENS -- Number of terminals. */ yann@943: #define YYNTOKENS 35 yann@943: /* YYNNTS -- Number of nonterminals. */ yann@943: #define YYNNTS 46 yann@943: /* YYNRULES -- Number of rules. */ yann@1: #define YYNRULES 110 yann@943: /* YYNRULES -- Number of states. */ yann@943: #define YYNSTATES 180 yann@1: yann@1: /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ yann@1: #define YYUNDEFTOK 2 yann@943: #define YYMAXUTOK 289 yann@1: yann@1: #define YYTRANSLATE(YYX) \ yann@1: ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) yann@1: yann@1: /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ yann@943: static const yytype_uint8 yytranslate[] = yann@1: { yann@1: 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, yann@1: 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, yann@1: 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, yann@1: 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, yann@943: 25, 26, 27, 28, 29, 30, 31, 32, 33, 34 yann@1: }; yann@1: yann@1: #if YYDEBUG yann@1: /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in yann@1: YYRHS. */ yann@943: static const yytype_uint16 yyprhs[] = yann@1: { yann@1: 0, 0, 3, 5, 6, 9, 12, 15, 20, 23, yann@1: 28, 33, 37, 39, 41, 43, 45, 47, 49, 51, yann@1: 53, 55, 57, 59, 61, 63, 67, 70, 74, 77, yann@1: 81, 84, 85, 88, 91, 94, 97, 100, 103, 107, yann@943: 112, 117, 122, 128, 132, 133, 137, 138, 141, 145, yann@943: 148, 150, 154, 155, 158, 161, 164, 167, 170, 175, yann@943: 179, 182, 187, 188, 191, 195, 197, 201, 202, 205, yann@943: 208, 211, 215, 218, 220, 224, 225, 228, 231, 234, yann@943: 238, 242, 245, 248, 251, 252, 255, 258, 261, 266, yann@943: 267, 270, 272, 274, 277, 280, 283, 285, 288, 289, yann@943: 292, 294, 298, 302, 306, 309, 313, 317, 319, 321, yann@943: 322 yann@1: }; yann@1: yann@943: /* YYRHS -- A `-1'-separated list of the rules' RHS. */ yann@943: static const yytype_int8 yyrhs[] = yann@1: { yann@943: 36, 0, -1, 37, -1, -1, 37, 39, -1, 37, yann@943: 53, -1, 37, 64, -1, 37, 3, 74, 76, -1, yann@943: 37, 75, -1, 37, 25, 1, 30, -1, 37, 38, yann@943: 1, 30, -1, 37, 1, 30, -1, 16, -1, 18, yann@943: -1, 19, -1, 21, -1, 17, -1, 22, -1, 20, yann@943: -1, 30, -1, 59, -1, 68, -1, 42, -1, 44, yann@943: -1, 66, -1, 25, 1, 30, -1, 1, 30, -1, yann@943: 10, 25, 30, -1, 41, 45, -1, 11, 25, 30, yann@943: -1, 43, 45, -1, -1, 45, 46, -1, 45, 47, yann@943: -1, 45, 72, -1, 45, 70, -1, 45, 40, -1, yann@943: 45, 30, -1, 19, 73, 30, -1, 18, 74, 77, yann@943: 30, -1, 20, 78, 77, 30, -1, 21, 25, 77, yann@943: 30, -1, 22, 79, 79, 77, 30, -1, 23, 48, yann@943: 30, -1, -1, 48, 25, 49, -1, -1, 33, 74, yann@943: -1, 7, 80, 30, -1, 50, 54, -1, 75, -1, yann@943: 51, 56, 52, -1, -1, 54, 55, -1, 54, 72, yann@943: -1, 54, 70, -1, 54, 30, -1, 54, 40, -1, yann@943: 18, 74, 77, 30, -1, 19, 73, 30, -1, 17, yann@943: 30, -1, 20, 25, 77, 30, -1, -1, 56, 39, yann@943: -1, 14, 78, 76, -1, 75, -1, 57, 60, 58, yann@943: -1, -1, 60, 39, -1, 60, 64, -1, 60, 53, yann@943: -1, 4, 74, 30, -1, 61, 71, -1, 75, -1, yann@943: 62, 65, 63, -1, -1, 65, 39, -1, 65, 64, yann@943: -1, 65, 53, -1, 6, 74, 30, -1, 9, 74, yann@943: 30, -1, 67, 71, -1, 12, 30, -1, 69, 13, yann@943: -1, -1, 71, 72, -1, 71, 30, -1, 71, 40, yann@943: -1, 16, 24, 78, 30, -1, -1, 74, 77, -1, yann@943: 25, -1, 26, -1, 5, 30, -1, 8, 30, -1, yann@943: 15, 30, -1, 30, -1, 76, 30, -1, -1, 14, yann@943: 78, -1, 79, -1, 79, 33, 79, -1, 79, 27, yann@943: 79, -1, 29, 78, 28, -1, 34, 78, -1, 78, yann@943: 31, 78, -1, 78, 32, 78, -1, 25, -1, 26, yann@943: -1, -1, 25, -1 yann@1: }; yann@1: yann@1: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ yann@943: static const yytype_uint16 yyrline[] = yann@1: { yann@943: 0, 104, 104, 106, 108, 109, 110, 111, 112, 113, yann@943: 114, 118, 122, 122, 122, 122, 122, 122, 122, 126, yann@943: 127, 128, 129, 130, 131, 135, 136, 142, 150, 156, yann@943: 164, 174, 176, 177, 178, 179, 180, 181, 184, 192, yann@943: 198, 208, 214, 220, 223, 225, 236, 237, 242, 251, yann@943: 256, 264, 267, 269, 270, 271, 272, 273, 276, 282, yann@943: 293, 299, 309, 311, 316, 324, 332, 335, 337, 338, yann@943: 339, 344, 351, 356, 364, 367, 369, 370, 371, 374, yann@943: 382, 389, 396, 402, 409, 411, 412, 413, 416, 424, yann@943: 426, 431, 432, 435, 436, 437, 441, 442, 445, 446, yann@943: 449, 450, 451, 452, 453, 454, 455, 458, 459, 462, yann@943: 463 yann@1: }; yann@1: #endif yann@1: yann@1: #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE yann@1: /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. yann@943: First, the terminals, then, starting at YYNTOKENS, nonterminals. */ yann@1: static const char *const yytname[] = yann@1: { yann@1: "$end", "error", "$undefined", "T_MAINMENU", "T_MENU", "T_ENDMENU", yann@1: "T_SOURCE", "T_CHOICE", "T_ENDCHOICE", "T_COMMENT", "T_CONFIG", yann@1: "T_MENUCONFIG", "T_HELP", "T_HELPTEXT", "T_IF", "T_ENDIF", "T_DEPENDS", yann@943: "T_OPTIONAL", "T_PROMPT", "T_TYPE", "T_DEFAULT", "T_SELECT", "T_RANGE", yann@943: "T_OPTION", "T_ON", "T_WORD", "T_WORD_QUOTE", "T_UNEQUAL", yann@943: "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_EOL", "T_OR", "T_AND", "T_EQUAL", yann@943: "T_NOT", "$accept", "input", "stmt_list", "option_name", "common_stmt", yann@943: "option_error", "config_entry_start", "config_stmt", yann@1: "menuconfig_entry_start", "menuconfig_stmt", "config_option_list", yann@1: "config_option", "symbol_option", "symbol_option_list", yann@1: "symbol_option_arg", "choice", "choice_entry", "choice_end", yann@1: "choice_stmt", "choice_option_list", "choice_option", "choice_block", yann@1: "if_entry", "if_end", "if_stmt", "if_block", "menu", "menu_entry", yann@1: "menu_end", "menu_stmt", "menu_block", "source_stmt", "comment", yann@1: "comment_stmt", "help_start", "help", "depends_list", "depends", yann@943: "prompt_stmt_opt", "prompt", "end", "nl", "if_expr", "expr", "symbol", yann@943: "word_opt", 0 yann@1: }; yann@1: #endif yann@1: yann@1: # ifdef YYPRINT yann@1: /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to yann@1: token YYLEX-NUM. */ yann@943: static const yytype_uint16 yytoknum[] = yann@1: { yann@1: 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, yann@1: 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, yann@1: 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, yann@943: 285, 286, 287, 288, 289 yann@1: }; yann@1: # endif yann@1: yann@1: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ yann@943: static const yytype_uint8 yyr1[] = yann@1: { yann@943: 0, 35, 36, 37, 37, 37, 37, 37, 37, 37, yann@943: 37, 37, 38, 38, 38, 38, 38, 38, 38, 39, yann@943: 39, 39, 39, 39, 39, 40, 40, 41, 42, 43, yann@943: 44, 45, 45, 45, 45, 45, 45, 45, 46, 46, yann@943: 46, 46, 46, 47, 48, 48, 49, 49, 50, 51, yann@943: 52, 53, 54, 54, 54, 54, 54, 54, 55, 55, yann@943: 55, 55, 56, 56, 57, 58, 59, 60, 60, 60, yann@943: 60, 61, 62, 63, 64, 65, 65, 65, 65, 66, yann@943: 67, 68, 69, 70, 71, 71, 71, 71, 72, 73, yann@943: 73, 74, 74, 75, 75, 75, 76, 76, 77, 77, yann@943: 78, 78, 78, 78, 78, 78, 78, 79, 79, 80, yann@1: 80 yann@1: }; yann@1: yann@1: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ yann@943: static const yytype_uint8 yyr2[] = yann@1: { yann@1: 0, 2, 1, 0, 2, 2, 2, 4, 2, 4, yann@1: 4, 3, 1, 1, 1, 1, 1, 1, 1, 1, yann@1: 1, 1, 1, 1, 1, 3, 2, 3, 2, 3, yann@1: 2, 0, 2, 2, 2, 2, 2, 2, 3, 4, yann@943: 4, 4, 5, 3, 0, 3, 0, 2, 3, 2, yann@1: 1, 3, 0, 2, 2, 2, 2, 2, 4, 3, yann@1: 2, 4, 0, 2, 3, 1, 3, 0, 2, 2, yann@1: 2, 3, 2, 1, 3, 0, 2, 2, 2, 3, yann@943: 3, 2, 2, 2, 0, 2, 2, 2, 4, 0, yann@943: 2, 1, 1, 2, 2, 2, 1, 2, 0, 2, yann@943: 1, 3, 3, 3, 2, 3, 3, 1, 1, 0, yann@1: 1 yann@1: }; yann@1: yann@1: /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state yann@1: STATE-NUM when YYTABLE doesn't specify something else to do. Zero yann@1: means the default is an error. */ yann@943: static const yytype_uint8 yydefact[] = yann@1: { yann@943: 3, 0, 0, 1, 0, 0, 0, 0, 0, 109, yann@1: 0, 0, 0, 0, 0, 0, 12, 16, 13, 14, yann@1: 18, 15, 17, 0, 19, 0, 4, 31, 22, 31, yann@1: 23, 52, 62, 5, 67, 20, 84, 75, 6, 24, yann@943: 84, 21, 8, 11, 91, 92, 0, 0, 93, 0, yann@943: 110, 0, 94, 0, 0, 0, 107, 108, 0, 0, yann@943: 0, 100, 95, 0, 0, 0, 0, 0, 0, 0, yann@943: 0, 0, 0, 96, 7, 71, 79, 48, 80, 27, yann@943: 29, 0, 104, 0, 0, 64, 0, 0, 9, 10, yann@943: 0, 0, 0, 0, 89, 0, 0, 0, 44, 0, yann@943: 37, 36, 32, 33, 0, 35, 34, 0, 0, 89, yann@943: 0, 56, 57, 53, 55, 54, 63, 51, 50, 68, yann@943: 70, 66, 69, 65, 86, 87, 85, 76, 78, 74, yann@943: 77, 73, 97, 103, 105, 106, 102, 101, 26, 82, yann@943: 0, 98, 0, 98, 98, 98, 0, 0, 0, 83, yann@943: 60, 98, 0, 98, 0, 0, 0, 38, 90, 0, yann@943: 0, 98, 46, 43, 25, 0, 59, 0, 88, 99, yann@943: 39, 40, 41, 0, 0, 45, 58, 61, 42, 47 yann@1: }; yann@1: yann@943: /* YYDEFGOTO[NTERM-NUM]. */ yann@943: static const yytype_int16 yydefgoto[] = yann@1: { yann@943: -1, 1, 2, 25, 26, 101, 27, 28, 29, 30, yann@943: 65, 102, 103, 147, 175, 31, 32, 117, 33, 67, yann@943: 113, 68, 34, 121, 35, 69, 36, 37, 129, 38, yann@943: 71, 39, 40, 41, 104, 105, 70, 106, 142, 143, yann@943: 42, 74, 156, 60, 61, 51 yann@1: }; yann@1: yann@1: /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing yann@1: STATE-NUM. */ yann@943: #define YYPACT_NINF -80 yann@943: static const yytype_int16 yypact[] = yann@1: { yann@943: -80, 2, 132, -80, -13, -1, -1, -2, -1, 9, yann@943: 33, -1, 27, 40, -3, 38, -80, -80, -80, -80, yann@943: -80, -80, -80, 71, -80, 77, -80, -80, -80, -80, yann@943: -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, yann@943: -80, -80, -80, -80, -80, -80, 57, 61, -80, 63, yann@943: -80, 76, -80, 87, 101, 133, -80, -80, -3, -3, yann@943: 195, -6, -80, 136, 149, 39, 104, 65, 150, 5, yann@943: 194, 5, 167, -80, 176, -80, -80, -80, -80, -80, yann@943: -80, 68, -80, -3, -3, 176, 72, 72, -80, -80, yann@943: 177, 187, 78, -1, -1, -3, 196, 72, -80, 222, yann@943: -80, -80, -80, -80, 221, -80, -80, 205, -1, -1, yann@943: 211, -80, -80, -80, -80, -80, -80, -80, -80, -80, yann@943: -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, yann@943: -80, -80, -80, -80, 206, -80, -80, -80, -80, -80, yann@943: -3, 223, 209, 223, 197, 223, 72, 7, 210, -80, yann@943: -80, 223, 212, 223, 201, -3, 213, -80, -80, 214, yann@943: 215, 223, 208, -80, -80, 216, -80, 217, -80, 113, yann@943: -80, -80, -80, 218, -1, -80, -80, -80, -80, -80 yann@1: }; yann@1: yann@1: /* YYPGOTO[NTERM-NUM]. */ yann@943: static const yytype_int16 yypgoto[] = yann@1: { yann@943: -80, -80, -80, -80, 122, -34, -80, -80, -80, -80, yann@943: 220, -80, -80, -80, -80, -80, -80, -80, 59, -80, yann@943: -80, -80, -80, -80, -80, -80, -80, -80, -80, 125, yann@943: -80, -80, -80, -80, -80, 183, 219, 22, 142, -5, yann@943: 147, 192, 69, -54, -79, -80 yann@1: }; yann@1: yann@1: /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If yann@1: positive, shift that token. If negative, reduce the rule which yann@1: number is the opposite. If zero, do what YYDEFACT says. yann@1: If YYTABLE_NINF, syntax error. */ yann@1: #define YYTABLE_NINF -82 yann@943: static const yytype_int16 yytable[] = yann@1: { yann@943: 46, 47, 3, 49, 81, 82, 53, 136, 137, 6, yann@943: 7, 8, 9, 10, 11, 12, 13, 43, 146, 14, yann@943: 15, 86, 56, 57, 44, 45, 58, 87, 48, 134, yann@943: 135, 59, 162, 112, 50, 24, 125, 163, 125, -28, yann@943: 90, 144, -28, -28, -28, -28, -28, -28, -28, -28, yann@943: -28, 91, 54, -28, -28, 92, -28, 93, 94, 95, yann@943: 96, 97, 98, 52, 99, 55, 90, 161, 62, 100, yann@943: -49, -49, 63, -49, -49, -49, -49, 91, 64, -49, yann@943: -49, 92, 107, 108, 109, 110, 154, 73, 141, 115, yann@943: 99, 75, 126, 76, 126, 111, 133, 56, 57, 83, yann@943: 84, 169, 140, 151, -30, 90, 77, -30, -30, -30, yann@943: -30, -30, -30, -30, -30, -30, 91, 78, -30, -30, yann@943: 92, -30, 93, 94, 95, 96, 97, 98, 120, 99, yann@943: 128, 79, -2, 4, 100, 5, 6, 7, 8, 9, yann@943: 10, 11, 12, 13, 83, 84, 14, 15, 16, 17, yann@943: 18, 19, 20, 21, 22, 7, 8, 23, 10, 11, yann@943: 12, 13, 24, 80, 14, 15, 88, -81, 90, 179, yann@943: -81, -81, -81, -81, -81, -81, -81, -81, -81, 89, yann@943: 24, -81, -81, 92, -81, -81, -81, -81, -81, -81, yann@943: 116, 119, 99, 127, 122, 90, 130, 124, -72, -72, yann@943: -72, -72, -72, -72, -72, -72, 132, 138, -72, -72, yann@943: 92, 155, 158, 159, 160, 118, 123, 139, 131, 99, yann@943: 165, 145, 167, 148, 124, 73, 83, 84, 83, 84, yann@943: 173, 168, 83, 84, 149, 150, 153, 155, 84, 157, yann@943: 164, 174, 166, 170, 171, 172, 176, 177, 178, 66, yann@943: 114, 152, 85, 0, 0, 0, 0, 0, 0, 72 yann@1: }; yann@1: yann@943: static const yytype_int16 yycheck[] = yann@1: { yann@943: 5, 6, 0, 8, 58, 59, 11, 86, 87, 4, yann@943: 5, 6, 7, 8, 9, 10, 11, 30, 97, 14, yann@943: 15, 27, 25, 26, 25, 26, 29, 33, 30, 83, yann@943: 84, 34, 25, 67, 25, 30, 70, 30, 72, 0, yann@943: 1, 95, 3, 4, 5, 6, 7, 8, 9, 10, yann@943: 11, 12, 25, 14, 15, 16, 17, 18, 19, 20, yann@943: 21, 22, 23, 30, 25, 25, 1, 146, 30, 30, yann@943: 5, 6, 1, 8, 9, 10, 11, 12, 1, 14, yann@943: 15, 16, 17, 18, 19, 20, 140, 30, 93, 67, yann@943: 25, 30, 70, 30, 72, 30, 28, 25, 26, 31, yann@943: 32, 155, 24, 108, 0, 1, 30, 3, 4, 5, yann@943: 6, 7, 8, 9, 10, 11, 12, 30, 14, 15, yann@943: 16, 17, 18, 19, 20, 21, 22, 23, 69, 25, yann@943: 71, 30, 0, 1, 30, 3, 4, 5, 6, 7, yann@943: 8, 9, 10, 11, 31, 32, 14, 15, 16, 17, yann@943: 18, 19, 20, 21, 22, 5, 6, 25, 8, 9, yann@943: 10, 11, 30, 30, 14, 15, 30, 0, 1, 174, yann@943: 3, 4, 5, 6, 7, 8, 9, 10, 11, 30, yann@943: 30, 14, 15, 16, 17, 18, 19, 20, 21, 22, yann@943: 68, 69, 25, 71, 69, 1, 71, 30, 4, 5, yann@943: 6, 7, 8, 9, 10, 11, 30, 30, 14, 15, yann@943: 16, 14, 143, 144, 145, 68, 69, 30, 71, 25, yann@943: 151, 25, 153, 1, 30, 30, 31, 32, 31, 32, yann@943: 161, 30, 31, 32, 13, 30, 25, 14, 32, 30, yann@943: 30, 33, 30, 30, 30, 30, 30, 30, 30, 29, yann@943: 67, 109, 60, -1, -1, -1, -1, -1, -1, 40 yann@1: }; yann@1: yann@1: /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing yann@1: symbol of state STATE-NUM. */ yann@943: static const yytype_uint8 yystos[] = yann@1: { yann@943: 0, 36, 37, 0, 1, 3, 4, 5, 6, 7, yann@943: 8, 9, 10, 11, 14, 15, 16, 17, 18, 19, yann@943: 20, 21, 22, 25, 30, 38, 39, 41, 42, 43, yann@943: 44, 50, 51, 53, 57, 59, 61, 62, 64, 66, yann@943: 67, 68, 75, 30, 25, 26, 74, 74, 30, 74, yann@943: 25, 80, 30, 74, 25, 25, 25, 26, 29, 34, yann@943: 78, 79, 30, 1, 1, 45, 45, 54, 56, 60, yann@943: 71, 65, 71, 30, 76, 30, 30, 30, 30, 30, yann@943: 30, 78, 78, 31, 32, 76, 27, 33, 30, 30, yann@943: 1, 12, 16, 18, 19, 20, 21, 22, 23, 25, yann@943: 30, 40, 46, 47, 69, 70, 72, 17, 18, 19, yann@943: 20, 30, 40, 55, 70, 72, 39, 52, 75, 39, yann@943: 53, 58, 64, 75, 30, 40, 72, 39, 53, 63, yann@943: 64, 75, 30, 28, 78, 78, 79, 79, 30, 30, yann@943: 24, 74, 73, 74, 78, 25, 79, 48, 1, 13, yann@943: 30, 74, 73, 25, 78, 14, 77, 30, 77, 77, yann@943: 77, 79, 25, 30, 30, 77, 30, 77, 30, 78, yann@943: 30, 30, 30, 77, 33, 49, 30, 30, 30, 74 yann@1: }; yann@1: yann@1: #define yyerrok (yyerrstatus = 0) yann@1: #define yyclearin (yychar = YYEMPTY) yann@1: #define YYEMPTY (-2) yann@1: #define YYEOF 0 yann@1: yann@1: #define YYACCEPT goto yyacceptlab yann@1: #define YYABORT goto yyabortlab yann@1: #define YYERROR goto yyerrorlab yann@1: yann@1: yann@1: /* Like YYERROR except do call yyerror. This remains here temporarily yann@1: to ease the transition to the new meaning of YYERROR, for GCC. yann@1: Once GCC version 2 has supplanted version 1, this can go. */ yann@1: yann@1: #define YYFAIL goto yyerrlab yann@1: yann@1: #define YYRECOVERING() (!!yyerrstatus) yann@1: yann@1: #define YYBACKUP(Token, Value) \ yann@1: do \ yann@1: if (yychar == YYEMPTY && yylen == 1) \ yann@1: { \ yann@1: yychar = (Token); \ yann@1: yylval = (Value); \ yann@1: yytoken = YYTRANSLATE (yychar); \ yann@943: YYPOPSTACK (1); \ yann@1: goto yybackup; \ yann@1: } \ yann@1: else \ yann@1: { \ yann@1: yyerror (YY_("syntax error: cannot back up")); \ yann@1: YYERROR; \ yann@1: } \ yann@943: while (YYID (0)) yann@1: yann@1: yann@1: #define YYTERROR 1 yann@1: #define YYERRCODE 256 yann@1: yann@1: yann@1: /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. yann@1: If N is 0, then set CURRENT to the empty location which ends yann@1: the previous symbol: RHS[0] (always defined). */ yann@1: yann@1: #define YYRHSLOC(Rhs, K) ((Rhs)[K]) yann@1: #ifndef YYLLOC_DEFAULT yann@1: # define YYLLOC_DEFAULT(Current, Rhs, N) \ yann@1: do \ yann@943: if (YYID (N)) \ yann@1: { \ yann@1: (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ yann@1: (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ yann@1: (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ yann@1: (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ yann@1: } \ yann@1: else \ yann@1: { \ yann@1: (Current).first_line = (Current).last_line = \ yann@1: YYRHSLOC (Rhs, 0).last_line; \ yann@1: (Current).first_column = (Current).last_column = \ yann@1: YYRHSLOC (Rhs, 0).last_column; \ yann@1: } \ yann@943: while (YYID (0)) yann@1: #endif yann@1: yann@1: yann@1: /* YY_LOCATION_PRINT -- Print the location on the stream. yann@1: This macro was not mandated originally: define only if we know yann@1: we won't break user code: when these are the locations we know. */ yann@1: yann@1: #ifndef YY_LOCATION_PRINT yann@1: # if YYLTYPE_IS_TRIVIAL yann@1: # define YY_LOCATION_PRINT(File, Loc) \ yann@1: fprintf (File, "%d.%d-%d.%d", \ yann@943: (Loc).first_line, (Loc).first_column, \ yann@943: (Loc).last_line, (Loc).last_column) yann@1: # else yann@1: # define YY_LOCATION_PRINT(File, Loc) ((void) 0) yann@1: # endif yann@1: #endif yann@1: yann@1: yann@1: /* YYLEX -- calling `yylex' with the right arguments. */ yann@1: yann@1: #ifdef YYLEX_PARAM yann@1: # define YYLEX yylex (YYLEX_PARAM) yann@1: #else yann@1: # define YYLEX yylex () yann@1: #endif yann@1: yann@1: /* Enable debugging if requested. */ yann@1: #if YYDEBUG yann@1: yann@1: # ifndef YYFPRINTF yann@1: # include /* INFRINGES ON USER NAME SPACE */ yann@1: # define YYFPRINTF fprintf yann@1: # endif yann@1: yann@1: # define YYDPRINTF(Args) \ yann@1: do { \ yann@1: if (yydebug) \ yann@1: YYFPRINTF Args; \ yann@943: } while (YYID (0)) yann@1: yann@943: # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ yann@943: do { \ yann@943: if (yydebug) \ yann@943: { \ yann@943: YYFPRINTF (stderr, "%s ", Title); \ yann@943: yy_symbol_print (stderr, \ yann@943: Type, Value); \ yann@943: YYFPRINTF (stderr, "\n"); \ yann@943: } \ yann@943: } while (YYID (0)) yann@943: yann@943: yann@943: /*--------------------------------. yann@943: | Print this symbol on YYOUTPUT. | yann@943: `--------------------------------*/ yann@943: yann@943: /*ARGSUSED*/ yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@943: static void yann@943: yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) yann@943: #else yann@943: static void yann@943: yy_symbol_value_print (yyoutput, yytype, yyvaluep) yann@943: FILE *yyoutput; yann@943: int yytype; yann@943: YYSTYPE const * const yyvaluep; yann@943: #endif yann@943: { yann@943: if (!yyvaluep) yann@943: return; yann@943: # ifdef YYPRINT yann@943: if (yytype < YYNTOKENS) yann@943: YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); yann@943: # else yann@943: YYUSE (yyoutput); yann@943: # endif yann@943: switch (yytype) yann@943: { yann@943: default: yann@943: break; yann@943: } yann@943: } yann@943: yann@943: yann@943: /*--------------------------------. yann@943: | Print this symbol on YYOUTPUT. | yann@943: `--------------------------------*/ yann@943: yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@943: static void yann@943: yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) yann@943: #else yann@943: static void yann@943: yy_symbol_print (yyoutput, yytype, yyvaluep) yann@943: FILE *yyoutput; yann@943: int yytype; yann@943: YYSTYPE const * const yyvaluep; yann@943: #endif yann@943: { yann@943: if (yytype < YYNTOKENS) yann@943: YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); yann@943: else yann@943: YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); yann@943: yann@943: yy_symbol_value_print (yyoutput, yytype, yyvaluep); yann@943: YYFPRINTF (yyoutput, ")"); yann@943: } yann@1: yann@1: /*------------------------------------------------------------------. yann@1: | yy_stack_print -- Print the state stack from its BOTTOM up to its | yann@1: | TOP (included). | yann@1: `------------------------------------------------------------------*/ yann@1: yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: static void yann@943: yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) yann@1: #else yann@1: static void yann@1: yy_stack_print (bottom, top) yann@943: yytype_int16 *bottom; yann@943: yytype_int16 *top; yann@1: #endif yann@1: { yann@1: YYFPRINTF (stderr, "Stack now"); yann@943: for (; bottom <= top; ++bottom) yann@1: YYFPRINTF (stderr, " %d", *bottom); yann@1: YYFPRINTF (stderr, "\n"); yann@1: } yann@1: yann@1: # define YY_STACK_PRINT(Bottom, Top) \ yann@1: do { \ yann@1: if (yydebug) \ yann@1: yy_stack_print ((Bottom), (Top)); \ yann@943: } while (YYID (0)) yann@1: yann@1: yann@1: /*------------------------------------------------. yann@1: | Report that the YYRULE is going to be reduced. | yann@1: `------------------------------------------------*/ yann@1: yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: static void yann@943: yy_reduce_print (YYSTYPE *yyvsp, int yyrule) yann@1: #else yann@1: static void yann@943: yy_reduce_print (yyvsp, yyrule) yann@943: YYSTYPE *yyvsp; yann@1: int yyrule; yann@1: #endif yann@1: { yann@943: int yynrhs = yyr2[yyrule]; yann@1: int yyi; yann@1: unsigned long int yylno = yyrline[yyrule]; yann@943: YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", yann@943: yyrule - 1, yylno); yann@943: /* The symbols being reduced. */ yann@943: for (yyi = 0; yyi < yynrhs; yyi++) yann@943: { yann@943: fprintf (stderr, " $%d = ", yyi + 1); yann@943: yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], yann@943: &(yyvsp[(yyi + 1) - (yynrhs)]) yann@943: ); yann@943: fprintf (stderr, "\n"); yann@943: } yann@1: } yann@1: yann@1: # define YY_REDUCE_PRINT(Rule) \ yann@1: do { \ yann@1: if (yydebug) \ yann@943: yy_reduce_print (yyvsp, Rule); \ yann@943: } while (YYID (0)) yann@1: yann@1: /* Nonzero means print parse trace. It is left uninitialized so that yann@1: multiple parsers can coexist. */ yann@1: int yydebug; yann@1: #else /* !YYDEBUG */ yann@1: # define YYDPRINTF(Args) yann@1: # define YY_SYMBOL_PRINT(Title, Type, Value, Location) yann@1: # define YY_STACK_PRINT(Bottom, Top) yann@1: # define YY_REDUCE_PRINT(Rule) yann@1: #endif /* !YYDEBUG */ yann@1: yann@1: yann@1: /* YYINITDEPTH -- initial size of the parser's stacks. */ yann@1: #ifndef YYINITDEPTH yann@1: # define YYINITDEPTH 200 yann@1: #endif yann@1: yann@1: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only yann@1: if the built-in stack extension method is used). yann@1: yann@1: Do not make this value too large; the results are undefined if yann@1: YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) yann@1: evaluated with infinite-precision integer arithmetic. */ yann@1: yann@1: #ifndef YYMAXDEPTH yann@1: # define YYMAXDEPTH 10000 yann@1: #endif yann@1: yann@1: yann@1: yann@1: #if YYERROR_VERBOSE yann@1: yann@1: # ifndef yystrlen yann@943: # if defined __GLIBC__ && defined _STRING_H yann@1: # define yystrlen strlen yann@1: # else yann@1: /* Return the length of YYSTR. */ yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: static YYSIZE_T yann@1: yystrlen (const char *yystr) yann@943: #else yann@943: static YYSIZE_T yann@1: yystrlen (yystr) yann@943: const char *yystr; yann@943: #endif yann@1: { yann@943: YYSIZE_T yylen; yann@943: for (yylen = 0; yystr[yylen]; yylen++) yann@1: continue; yann@943: return yylen; yann@1: } yann@1: # endif yann@1: # endif yann@1: yann@1: # ifndef yystpcpy yann@943: # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE yann@1: # define yystpcpy stpcpy yann@1: # else yann@1: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in yann@1: YYDEST. */ yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: static char * yann@1: yystpcpy (char *yydest, const char *yysrc) yann@943: #else yann@943: static char * yann@1: yystpcpy (yydest, yysrc) yann@943: char *yydest; yann@943: const char *yysrc; yann@943: #endif yann@1: { yann@1: char *yyd = yydest; yann@1: const char *yys = yysrc; yann@1: yann@1: while ((*yyd++ = *yys++) != '\0') yann@1: continue; yann@1: yann@1: return yyd - 1; yann@1: } yann@1: # endif yann@1: # endif yann@1: yann@1: # ifndef yytnamerr yann@1: /* Copy to YYRES the contents of YYSTR after stripping away unnecessary yann@1: quotes and backslashes, so that it's suitable for yyerror. The yann@1: heuristic is that double-quoting is unnecessary unless the string yann@1: contains an apostrophe, a comma, or backslash (other than yann@1: backslash-backslash). YYSTR is taken from yytname. If YYRES is yann@1: null, do not copy; instead, return the length of what the result yann@1: would have been. */ yann@1: static YYSIZE_T yann@1: yytnamerr (char *yyres, const char *yystr) yann@1: { yann@1: if (*yystr == '"') yann@1: { yann@943: YYSIZE_T yyn = 0; yann@1: char const *yyp = yystr; yann@1: yann@1: for (;;) yann@1: switch (*++yyp) yann@1: { yann@1: case '\'': yann@1: case ',': yann@1: goto do_not_strip_quotes; yann@1: yann@1: case '\\': yann@1: if (*++yyp != '\\') yann@1: goto do_not_strip_quotes; yann@1: /* Fall through. */ yann@1: default: yann@1: if (yyres) yann@1: yyres[yyn] = *yyp; yann@1: yyn++; yann@1: break; yann@1: yann@1: case '"': yann@1: if (yyres) yann@1: yyres[yyn] = '\0'; yann@1: return yyn; yann@1: } yann@1: do_not_strip_quotes: ; yann@1: } yann@1: yann@1: if (! yyres) yann@1: return yystrlen (yystr); yann@1: yann@1: return yystpcpy (yyres, yystr) - yyres; yann@1: } yann@1: # endif yann@1: yann@943: /* Copy into YYRESULT an error message about the unexpected token yann@943: YYCHAR while in state YYSTATE. Return the number of bytes copied, yann@943: including the terminating null byte. If YYRESULT is null, do not yann@943: copy anything; just return the number of bytes that would be yann@943: copied. As a special case, return 0 if an ordinary "syntax error" yann@943: message will do. Return YYSIZE_MAXIMUM if overflow occurs during yann@943: size calculation. */ yann@943: static YYSIZE_T yann@943: yysyntax_error (char *yyresult, int yystate, int yychar) yann@943: { yann@943: int yyn = yypact[yystate]; yann@943: yann@943: if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) yann@943: return 0; yann@943: else yann@943: { yann@943: int yytype = YYTRANSLATE (yychar); yann@943: YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); yann@943: YYSIZE_T yysize = yysize0; yann@943: YYSIZE_T yysize1; yann@943: int yysize_overflow = 0; yann@943: enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; yann@943: char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; yann@943: int yyx; yann@943: yann@943: # if 0 yann@943: /* This is so xgettext sees the translatable formats that are yann@943: constructed on the fly. */ yann@943: YY_("syntax error, unexpected %s"); yann@943: YY_("syntax error, unexpected %s, expecting %s"); yann@943: YY_("syntax error, unexpected %s, expecting %s or %s"); yann@943: YY_("syntax error, unexpected %s, expecting %s or %s or %s"); yann@943: YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); yann@943: # endif yann@943: char *yyfmt; yann@943: char const *yyf; yann@943: static char const yyunexpected[] = "syntax error, unexpected %s"; yann@943: static char const yyexpecting[] = ", expecting %s"; yann@943: static char const yyor[] = " or %s"; yann@943: char yyformat[sizeof yyunexpected yann@943: + sizeof yyexpecting - 1 yann@943: + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) yann@943: * (sizeof yyor - 1))]; yann@943: char const *yyprefix = yyexpecting; yann@943: yann@943: /* Start YYX at -YYN if negative to avoid negative indexes in yann@943: YYCHECK. */ yann@943: int yyxbegin = yyn < 0 ? -yyn : 0; yann@943: yann@943: /* Stay within bounds of both yycheck and yytname. */ yann@943: int yychecklim = YYLAST - yyn + 1; yann@943: int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; yann@943: int yycount = 1; yann@943: yann@943: yyarg[0] = yytname[yytype]; yann@943: yyfmt = yystpcpy (yyformat, yyunexpected); yann@943: yann@943: for (yyx = yyxbegin; yyx < yyxend; ++yyx) yann@943: if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) yann@943: { yann@943: if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) yann@943: { yann@943: yycount = 1; yann@943: yysize = yysize0; yann@943: yyformat[sizeof yyunexpected - 1] = '\0'; yann@943: break; yann@943: } yann@943: yyarg[yycount++] = yytname[yyx]; yann@943: yysize1 = yysize + yytnamerr (0, yytname[yyx]); yann@943: yysize_overflow |= (yysize1 < yysize); yann@943: yysize = yysize1; yann@943: yyfmt = yystpcpy (yyfmt, yyprefix); yann@943: yyprefix = yyor; yann@943: } yann@943: yann@943: yyf = YY_(yyformat); yann@943: yysize1 = yysize + yystrlen (yyf); yann@943: yysize_overflow |= (yysize1 < yysize); yann@943: yysize = yysize1; yann@943: yann@943: if (yysize_overflow) yann@943: return YYSIZE_MAXIMUM; yann@943: yann@943: if (yyresult) yann@943: { yann@943: /* Avoid sprintf, as that infringes on the user's name space. yann@943: Don't have undefined behavior even if the translation yann@943: produced a string with the wrong number of "%s"s. */ yann@943: char *yyp = yyresult; yann@943: int yyi = 0; yann@943: while ((*yyp = *yyf) != '\0') yann@943: { yann@943: if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) yann@943: { yann@943: yyp += yytnamerr (yyp, yyarg[yyi++]); yann@943: yyf += 2; yann@943: } yann@943: else yann@943: { yann@943: yyp++; yann@943: yyf++; yann@943: } yann@943: } yann@943: } yann@943: return yysize; yann@943: } yann@943: } yann@1: #endif /* YYERROR_VERBOSE */ yann@1: yann@1: yann@1: /*-----------------------------------------------. yann@1: | Release the memory associated to this symbol. | yann@1: `-----------------------------------------------*/ yann@1: yann@943: /*ARGSUSED*/ yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: static void yann@1: yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) yann@1: #else yann@1: static void yann@1: yydestruct (yymsg, yytype, yyvaluep) yann@1: const char *yymsg; yann@1: int yytype; yann@1: YYSTYPE *yyvaluep; yann@1: #endif yann@1: { yann@943: YYUSE (yyvaluep); yann@1: yann@1: if (!yymsg) yann@1: yymsg = "Deleting"; yann@1: YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); yann@1: yann@1: switch (yytype) yann@1: { yann@943: case 51: /* "choice_entry" */ yann@1: yann@943: { yann@1: fprintf(stderr, "%s:%d: missing end statement for this entry\n", yann@1: (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno); yann@1: if (current_menu == (yyvaluep->menu)) yann@1: menu_end_menu(); yann@1: }; yann@1: yann@943: break; yann@943: case 57: /* "if_entry" */ yann@1: yann@943: { yann@1: fprintf(stderr, "%s:%d: missing end statement for this entry\n", yann@1: (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno); yann@1: if (current_menu == (yyvaluep->menu)) yann@1: menu_end_menu(); yann@1: }; yann@1: yann@943: break; yann@943: case 62: /* "menu_entry" */ yann@1: yann@943: { yann@1: fprintf(stderr, "%s:%d: missing end statement for this entry\n", yann@1: (yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno); yann@1: if (current_menu == (yyvaluep->menu)) yann@1: menu_end_menu(); yann@1: }; yann@1: yann@943: break; yann@1: yann@1: default: yann@943: break; yann@1: } yann@1: } yann@1: yann@1: yann@1: /* Prevent warnings from -Wmissing-prototypes. */ yann@1: yann@1: #ifdef YYPARSE_PARAM yann@943: #if defined __STDC__ || defined __cplusplus yann@1: int yyparse (void *YYPARSE_PARAM); yann@943: #else yann@1: int yyparse (); yann@943: #endif yann@1: #else /* ! YYPARSE_PARAM */ yann@943: #if defined __STDC__ || defined __cplusplus yann@1: int yyparse (void); yann@1: #else yann@1: int yyparse (); yann@1: #endif yann@1: #endif /* ! YYPARSE_PARAM */ yann@1: yann@1: yann@1: yann@1: /* The look-ahead symbol. */ yann@1: int yychar; yann@1: yann@1: /* The semantic value of the look-ahead symbol. */ yann@1: YYSTYPE yylval; yann@1: yann@1: /* Number of syntax errors so far. */ yann@1: int yynerrs; yann@1: yann@1: yann@1: yann@1: /*----------. yann@1: | yyparse. | yann@1: `----------*/ yann@1: yann@1: #ifdef YYPARSE_PARAM yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@943: int yann@943: yyparse (void *YYPARSE_PARAM) yann@943: #else yann@943: int yann@943: yyparse (YYPARSE_PARAM) yann@943: void *YYPARSE_PARAM; yann@943: #endif yann@1: #else /* ! YYPARSE_PARAM */ yann@943: #if (defined __STDC__ || defined __C99__FUNC__ \ yann@943: || defined __cplusplus || defined _MSC_VER) yann@1: int yann@1: yyparse (void) yann@1: #else yann@1: int yann@1: yyparse () yann@943: yann@1: #endif yann@1: #endif yann@1: { yann@1: yann@1: int yystate; yann@1: int yyn; yann@1: int yyresult; yann@1: /* Number of tokens to shift before error messages enabled. */ yann@1: int yyerrstatus; yann@1: /* Look-ahead token as an internal (translated) token number. */ yann@1: int yytoken = 0; yann@943: #if YYERROR_VERBOSE yann@943: /* Buffer for error messages, and its allocated size. */ yann@943: char yymsgbuf[128]; yann@943: char *yymsg = yymsgbuf; yann@943: YYSIZE_T yymsg_alloc = sizeof yymsgbuf; yann@943: #endif yann@1: yann@1: /* Three stacks and their tools: yann@1: `yyss': related to states, yann@1: `yyvs': related to semantic values, yann@1: `yyls': related to locations. yann@1: yann@1: Refer to the stacks thru separate pointers, to allow yyoverflow yann@1: to reallocate them elsewhere. */ yann@1: yann@1: /* The state stack. */ yann@943: yytype_int16 yyssa[YYINITDEPTH]; yann@943: yytype_int16 *yyss = yyssa; yann@943: yytype_int16 *yyssp; yann@1: yann@1: /* The semantic value stack. */ yann@1: YYSTYPE yyvsa[YYINITDEPTH]; yann@1: YYSTYPE *yyvs = yyvsa; yann@1: YYSTYPE *yyvsp; yann@1: yann@1: yann@1: yann@943: #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) yann@1: yann@1: YYSIZE_T yystacksize = YYINITDEPTH; yann@1: yann@1: /* The variables used to return semantic value and location from the yann@1: action routines. */ yann@1: YYSTYPE yyval; yann@1: yann@1: yann@943: /* The number of symbols on the RHS of the reduced rule. yann@943: Keep to zero when no symbol should be popped. */ yann@943: int yylen = 0; yann@1: yann@1: YYDPRINTF ((stderr, "Starting parse\n")); yann@1: yann@1: yystate = 0; yann@1: yyerrstatus = 0; yann@1: yynerrs = 0; yann@1: yychar = YYEMPTY; /* Cause a token to be read. */ yann@1: yann@1: /* Initialize stack pointers. yann@1: Waste one element of value and location stack yann@1: so that they stay on the same level as the state stack. yann@1: The wasted elements are never initialized. */ yann@1: yann@1: yyssp = yyss; yann@1: yyvsp = yyvs; yann@1: yann@1: goto yysetstate; yann@1: yann@1: /*------------------------------------------------------------. yann@1: | yynewstate -- Push a new state, which is found in yystate. | yann@1: `------------------------------------------------------------*/ yann@1: yynewstate: yann@1: /* In all cases, when you get here, the value and location stacks yann@943: have just been pushed. So pushing a state here evens the stacks. */ yann@1: yyssp++; yann@1: yann@1: yysetstate: yann@1: *yyssp = yystate; yann@1: yann@1: if (yyss + yystacksize - 1 <= yyssp) yann@1: { yann@1: /* Get the current used size of the three stacks, in elements. */ yann@1: YYSIZE_T yysize = yyssp - yyss + 1; yann@1: yann@1: #ifdef yyoverflow yann@1: { yann@943: /* Give user a chance to reallocate the stack. Use copies of yann@1: these so that the &'s don't force the real ones into yann@1: memory. */ yann@1: YYSTYPE *yyvs1 = yyvs; yann@943: yytype_int16 *yyss1 = yyss; yann@1: yann@1: yann@1: /* Each stack pointer address is followed by the size of the yann@1: data in use in that stack, in bytes. This used to be a yann@1: conditional around just the two extra args, but that might yann@1: be undefined if yyoverflow is a macro. */ yann@1: yyoverflow (YY_("memory exhausted"), yann@1: &yyss1, yysize * sizeof (*yyssp), yann@1: &yyvs1, yysize * sizeof (*yyvsp), yann@1: yann@1: &yystacksize); yann@1: yann@1: yyss = yyss1; yann@1: yyvs = yyvs1; yann@1: } yann@1: #else /* no yyoverflow */ yann@1: # ifndef YYSTACK_RELOCATE yann@1: goto yyexhaustedlab; yann@1: # else yann@1: /* Extend the stack our own way. */ yann@1: if (YYMAXDEPTH <= yystacksize) yann@1: goto yyexhaustedlab; yann@1: yystacksize *= 2; yann@1: if (YYMAXDEPTH < yystacksize) yann@1: yystacksize = YYMAXDEPTH; yann@1: yann@1: { yann@943: yytype_int16 *yyss1 = yyss; yann@1: union yyalloc *yyptr = yann@1: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); yann@1: if (! yyptr) yann@1: goto yyexhaustedlab; yann@1: YYSTACK_RELOCATE (yyss); yann@1: YYSTACK_RELOCATE (yyvs); yann@1: yann@1: # undef YYSTACK_RELOCATE yann@1: if (yyss1 != yyssa) yann@1: YYSTACK_FREE (yyss1); yann@1: } yann@1: # endif yann@1: #endif /* no yyoverflow */ yann@1: yann@1: yyssp = yyss + yysize - 1; yann@1: yyvsp = yyvs + yysize - 1; yann@1: yann@1: yann@1: YYDPRINTF ((stderr, "Stack size increased to %lu\n", yann@1: (unsigned long int) yystacksize)); yann@1: yann@1: if (yyss + yystacksize - 1 <= yyssp) yann@1: YYABORT; yann@1: } yann@1: yann@1: YYDPRINTF ((stderr, "Entering state %d\n", yystate)); yann@1: yann@1: goto yybackup; yann@1: yann@1: /*-----------. yann@1: | yybackup. | yann@1: `-----------*/ yann@1: yybackup: yann@1: yann@943: /* Do appropriate processing given the current state. Read a yann@943: look-ahead token if we need one and don't already have one. */ yann@1: yann@1: /* First try to decide what to do without reference to look-ahead token. */ yann@1: yyn = yypact[yystate]; yann@1: if (yyn == YYPACT_NINF) yann@1: goto yydefault; yann@1: yann@1: /* Not known => get a look-ahead token if don't already have one. */ yann@1: yann@1: /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ yann@1: if (yychar == YYEMPTY) yann@1: { yann@1: YYDPRINTF ((stderr, "Reading a token: ")); yann@1: yychar = YYLEX; yann@1: } yann@1: yann@1: if (yychar <= YYEOF) yann@1: { yann@1: yychar = yytoken = YYEOF; yann@1: YYDPRINTF ((stderr, "Now at end of input.\n")); yann@1: } yann@1: else yann@1: { yann@1: yytoken = YYTRANSLATE (yychar); yann@1: YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); yann@1: } yann@1: yann@1: /* If the proper action on seeing token YYTOKEN is to reduce or to yann@1: detect an error, take that action. */ yann@1: yyn += yytoken; yann@1: if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) yann@1: goto yydefault; yann@1: yyn = yytable[yyn]; yann@1: if (yyn <= 0) yann@1: { yann@1: if (yyn == 0 || yyn == YYTABLE_NINF) yann@1: goto yyerrlab; yann@1: yyn = -yyn; yann@1: goto yyreduce; yann@1: } yann@1: yann@1: if (yyn == YYFINAL) yann@1: YYACCEPT; yann@1: yann@1: /* Count tokens shifted since error; after three, turn off error yann@1: status. */ yann@1: if (yyerrstatus) yann@1: yyerrstatus--; yann@1: yann@943: /* Shift the look-ahead token. */ yann@943: YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); yann@943: yann@943: /* Discard the shifted token unless it is eof. */ yann@943: if (yychar != YYEOF) yann@943: yychar = YYEMPTY; yann@943: yann@1: yystate = yyn; yann@943: *++yyvsp = yylval; yann@943: yann@1: goto yynewstate; yann@1: yann@1: yann@1: /*-----------------------------------------------------------. yann@1: | yydefault -- do the default action for the current state. | yann@1: `-----------------------------------------------------------*/ yann@1: yydefault: yann@1: yyn = yydefact[yystate]; yann@1: if (yyn == 0) yann@1: goto yyerrlab; yann@1: goto yyreduce; yann@1: yann@1: yann@1: /*-----------------------------. yann@1: | yyreduce -- Do a reduction. | yann@1: `-----------------------------*/ yann@1: yyreduce: yann@1: /* yyn is the number of a rule to reduce with. */ yann@1: yylen = yyr2[yyn]; yann@1: yann@1: /* If YYLEN is nonzero, implement the default value of the action: yann@1: `$$ = $1'. yann@1: yann@1: Otherwise, the following line sets YYVAL to garbage. yann@1: This behavior is undocumented and Bison yann@1: users should not rely upon it. Assigning to YYVAL yann@1: unconditionally makes the parser a bit smaller, and it avoids a yann@1: GCC warning that YYVAL may be used uninitialized. */ yann@1: yyval = yyvsp[1-yylen]; yann@1: yann@1: yann@1: YY_REDUCE_PRINT (yyn); yann@1: switch (yyn) yann@1: { yann@1: case 8: yann@1: yann@1: { zconf_error("unexpected end statement"); ;} yann@1: break; yann@1: yann@1: case 9: yann@1: yann@943: { zconf_error("unknown statement \"%s\"", (yyvsp[(2) - (4)].string)); ;} yann@1: break; yann@1: yann@1: case 10: yann@1: yann@1: { yann@943: zconf_error("unexpected option \"%s\"", kconf_id_strings + (yyvsp[(2) - (4)].id)->name); yann@1: ;} yann@1: break; yann@1: yann@1: case 11: yann@1: yann@1: { zconf_error("invalid statement"); ;} yann@1: break; yann@1: yann@1: case 25: yann@1: yann@943: { zconf_error("unknown option \"%s\"", (yyvsp[(1) - (3)].string)); ;} yann@1: break; yann@1: yann@1: case 26: yann@1: yann@1: { zconf_error("invalid option"); ;} yann@1: break; yann@1: yann@1: case 27: yann@1: yann@1: { yann@943: struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0); yann@1: sym->flags |= SYMBOL_OPTIONAL; yann@1: menu_add_entry(sym); yann@943: printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string)); yann@1: ;} yann@1: break; yann@1: yann@1: case 28: yann@1: yann@1: { yann@1: menu_end_entry(); yann@1: printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 29: yann@1: yann@1: { yann@943: struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0); yann@1: sym->flags |= SYMBOL_OPTIONAL; yann@1: menu_add_entry(sym); yann@943: printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string)); yann@1: ;} yann@1: break; yann@1: yann@1: case 30: yann@1: yann@1: { yann@1: if (current_entry->prompt) yann@1: current_entry->prompt->type = P_MENU; yann@1: else yann@1: zconfprint("warning: menuconfig statement without prompt"); yann@1: menu_end_entry(); yann@1: printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 38: yann@1: yann@1: { yann@943: menu_set_type((yyvsp[(1) - (3)].id)->stype); yann@1: printd(DEBUG_PARSE, "%s:%d:type(%u)\n", yann@1: zconf_curname(), zconf_lineno(), yann@943: (yyvsp[(1) - (3)].id)->stype); yann@1: ;} yann@1: break; yann@1: yann@1: case 39: yann@1: yann@1: { yann@943: menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr)); yann@1: printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 40: yann@1: yann@1: { yann@943: menu_add_expr(P_DEFAULT, (yyvsp[(2) - (4)].expr), (yyvsp[(3) - (4)].expr)); yann@943: if ((yyvsp[(1) - (4)].id)->stype != S_UNKNOWN) yann@943: menu_set_type((yyvsp[(1) - (4)].id)->stype); yann@1: printd(DEBUG_PARSE, "%s:%d:default(%u)\n", yann@1: zconf_curname(), zconf_lineno(), yann@943: (yyvsp[(1) - (4)].id)->stype); yann@1: ;} yann@1: break; yann@1: yann@1: case 41: yann@1: yann@1: { yann@943: menu_add_symbol(P_SELECT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr)); yann@1: printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 42: yann@1: yann@1: { yann@943: menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[(2) - (5)].symbol), (yyvsp[(3) - (5)].symbol)), (yyvsp[(4) - (5)].expr)); yann@1: printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 45: yann@1: yann@1: { yann@943: struct kconf_id *id = kconf_id_lookup((yyvsp[(2) - (3)].string), strlen((yyvsp[(2) - (3)].string))); yann@1: if (id && id->flags & TF_OPTION) yann@943: menu_add_option(id->token, (yyvsp[(3) - (3)].string)); yann@1: else yann@943: zconfprint("warning: ignoring unknown option %s", (yyvsp[(2) - (3)].string)); yann@943: free((yyvsp[(2) - (3)].string)); yann@1: ;} yann@1: break; yann@1: yann@1: case 46: yann@1: yann@1: { (yyval.string) = NULL; ;} yann@1: break; yann@1: yann@1: case 47: yann@1: yann@943: { (yyval.string) = (yyvsp[(2) - (2)].string); ;} yann@1: break; yann@1: yann@1: case 48: yann@1: yann@1: { yann@943: struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), SYMBOL_CHOICE); yann@943: sym->flags |= SYMBOL_AUTO; yann@1: menu_add_entry(sym); yann@1: menu_add_expr(P_CHOICE, NULL, NULL); yann@1: printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 49: yann@1: yann@1: { yann@1: (yyval.menu) = menu_add_menu(); yann@1: ;} yann@1: break; yann@1: yann@1: case 50: yann@1: yann@1: { yann@943: if (zconf_endtoken((yyvsp[(1) - (1)].id), T_CHOICE, T_ENDCHOICE)) { yann@1: menu_end_menu(); yann@1: printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno()); yann@1: } yann@1: ;} yann@1: break; yann@1: yann@1: case 58: yann@1: yann@1: { yann@943: menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr)); yann@1: printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 59: yann@1: yann@1: { yann@943: if ((yyvsp[(1) - (3)].id)->stype == S_BOOLEAN || (yyvsp[(1) - (3)].id)->stype == S_TRISTATE) { yann@943: menu_set_type((yyvsp[(1) - (3)].id)->stype); yann@1: printd(DEBUG_PARSE, "%s:%d:type(%u)\n", yann@1: zconf_curname(), zconf_lineno(), yann@943: (yyvsp[(1) - (3)].id)->stype); yann@1: } else yann@1: YYERROR; yann@1: ;} yann@1: break; yann@1: yann@1: case 60: yann@1: yann@1: { yann@1: current_entry->sym->flags |= SYMBOL_OPTIONAL; yann@1: printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 61: yann@1: yann@1: { yann@943: if ((yyvsp[(1) - (4)].id)->stype == S_UNKNOWN) { yann@943: menu_add_symbol(P_DEFAULT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr)); yann@1: printd(DEBUG_PARSE, "%s:%d:default\n", yann@1: zconf_curname(), zconf_lineno()); yann@1: } else yann@1: YYERROR; yann@1: ;} yann@1: break; yann@1: yann@1: case 64: yann@1: yann@1: { yann@1: printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno()); yann@1: menu_add_entry(NULL); yann@943: menu_add_dep((yyvsp[(2) - (3)].expr)); yann@1: (yyval.menu) = menu_add_menu(); yann@1: ;} yann@1: break; yann@1: yann@1: case 65: yann@1: yann@1: { yann@943: if (zconf_endtoken((yyvsp[(1) - (1)].id), T_IF, T_ENDIF)) { yann@1: menu_end_menu(); yann@1: printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno()); yann@1: } yann@1: ;} yann@1: break; yann@1: yann@1: case 71: yann@1: yann@1: { yann@1: menu_add_entry(NULL); yann@943: menu_add_prompt(P_MENU, (yyvsp[(2) - (3)].string), NULL); yann@1: printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 72: yann@1: yann@1: { yann@1: (yyval.menu) = menu_add_menu(); yann@1: ;} yann@1: break; yann@1: yann@1: case 73: yann@1: yann@1: { yann@943: if (zconf_endtoken((yyvsp[(1) - (1)].id), T_MENU, T_ENDMENU)) { yann@1: menu_end_menu(); yann@1: printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno()); yann@1: } yann@1: ;} yann@1: break; yann@1: yann@1: case 79: yann@1: yann@1: { yann@943: printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string)); yann@943: zconf_nextfile((yyvsp[(2) - (3)].string)); yann@1: ;} yann@1: break; yann@1: yann@1: case 80: yann@1: yann@1: { yann@1: menu_add_entry(NULL); yann@943: menu_add_prompt(P_COMMENT, (yyvsp[(2) - (3)].string), NULL); yann@1: printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 81: yann@1: yann@1: { yann@1: menu_end_entry(); yann@1: ;} yann@1: break; yann@1: yann@1: case 82: yann@1: yann@1: { yann@1: printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno()); yann@1: zconf_starthelp(); yann@1: ;} yann@1: break; yann@1: yann@1: case 83: yann@1: yann@1: { yann@943: current_entry->help = (yyvsp[(2) - (2)].string); yann@1: ;} yann@1: break; yann@1: yann@1: case 88: yann@1: yann@1: { yann@943: menu_add_dep((yyvsp[(3) - (4)].expr)); yann@1: printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno()); yann@1: ;} yann@1: break; yann@1: yann@1: case 90: yann@1: yann@1: { yann@943: menu_add_prompt(P_PROMPT, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].expr)); yann@1: ;} yann@1: break; yann@1: yann@943: case 93: yann@1: yann@943: { (yyval.id) = (yyvsp[(1) - (2)].id); ;} yann@943: break; yann@943: yann@943: case 94: yann@943: yann@943: { (yyval.id) = (yyvsp[(1) - (2)].id); ;} yann@1: break; yann@1: yann@1: case 95: yann@1: yann@943: { (yyval.id) = (yyvsp[(1) - (2)].id); ;} yann@1: break; yann@1: yann@943: case 98: yann@1: yann@943: { (yyval.expr) = NULL; ;} yann@1: break; yann@1: yann@943: case 99: yann@1: yann@943: { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;} yann@1: break; yann@1: yann@1: case 100: yann@1: yann@943: { (yyval.expr) = expr_alloc_symbol((yyvsp[(1) - (1)].symbol)); ;} yann@1: break; yann@1: yann@1: case 101: yann@1: yann@943: { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;} yann@1: break; yann@1: yann@1: case 102: yann@1: yann@943: { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;} yann@1: break; yann@1: yann@1: case 103: yann@1: yann@943: { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;} yann@1: break; yann@1: yann@1: case 104: yann@1: yann@943: { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[(2) - (2)].expr)); ;} yann@1: break; yann@1: yann@1: case 105: yann@1: yann@943: { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} yann@1: break; yann@1: yann@1: case 106: yann@1: yann@943: { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} yann@1: break; yann@1: yann@1: case 107: yann@1: yann@943: { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), 0); free((yyvsp[(1) - (1)].string)); ;} yann@1: break; yann@1: yann@1: case 108: yann@1: yann@943: { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), SYMBOL_CONST); free((yyvsp[(1) - (1)].string)); ;} yann@1: break; yann@1: yann@1: case 109: yann@1: yann@943: { (yyval.string) = NULL; ;} yann@1: break; yann@1: yann@1: yann@943: /* Line 1267 of yacc.c. */ yann@1: yann@1: default: break; yann@1: } yann@943: YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); yann@1: yann@943: YYPOPSTACK (yylen); yann@943: yylen = 0; yann@1: YY_STACK_PRINT (yyss, yyssp); yann@1: yann@1: *++yyvsp = yyval; yann@1: yann@1: yann@1: /* Now `shift' the result of the reduction. Determine what state yann@1: that goes to, based on the state we popped back to and the rule yann@1: number reduced by. */ yann@1: yann@1: yyn = yyr1[yyn]; yann@1: yann@1: yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; yann@1: if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yann@1: yystate = yytable[yystate]; yann@1: else yann@1: yystate = yydefgoto[yyn - YYNTOKENS]; yann@1: yann@1: goto yynewstate; yann@1: yann@1: yann@1: /*------------------------------------. yann@1: | yyerrlab -- here on detecting error | yann@1: `------------------------------------*/ yann@1: yyerrlab: yann@1: /* If not already recovering from an error, report this error. */ yann@1: if (!yyerrstatus) yann@1: { yann@1: ++yynerrs; yann@943: #if ! YYERROR_VERBOSE yann@943: yyerror (YY_("syntax error")); yann@943: #else yann@943: { yann@943: YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); yann@943: if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) yann@943: { yann@943: YYSIZE_T yyalloc = 2 * yysize; yann@943: if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) yann@943: yyalloc = YYSTACK_ALLOC_MAXIMUM; yann@943: if (yymsg != yymsgbuf) yann@943: YYSTACK_FREE (yymsg); yann@943: yymsg = (char *) YYSTACK_ALLOC (yyalloc); yann@943: if (yymsg) yann@943: yymsg_alloc = yyalloc; yann@943: else yann@943: { yann@943: yymsg = yymsgbuf; yann@943: yymsg_alloc = sizeof yymsgbuf; yann@943: } yann@943: } yann@1: yann@943: if (0 < yysize && yysize <= yymsg_alloc) yann@943: { yann@943: (void) yysyntax_error (yymsg, yystate, yychar); yann@943: yyerror (yymsg); yann@943: } yann@943: else yann@943: { yann@943: yyerror (YY_("syntax error")); yann@943: if (yysize != 0) yann@943: goto yyexhaustedlab; yann@943: } yann@943: } yann@1: #endif yann@1: } yann@1: yann@1: yann@1: yann@1: if (yyerrstatus == 3) yann@1: { yann@1: /* If just tried and failed to reuse look-ahead token after an yann@1: error, discard it. */ yann@1: yann@1: if (yychar <= YYEOF) yann@943: { yann@1: /* Return failure if at end of input. */ yann@1: if (yychar == YYEOF) yann@1: YYABORT; yann@943: } yann@1: else yann@1: { yann@943: yydestruct ("Error: discarding", yann@943: yytoken, &yylval); yann@1: yychar = YYEMPTY; yann@1: } yann@1: } yann@1: yann@1: /* Else will try to reuse look-ahead token after shifting the error yann@1: token. */ yann@1: goto yyerrlab1; yann@1: yann@1: yann@1: /*---------------------------------------------------. yann@1: | yyerrorlab -- error raised explicitly by YYERROR. | yann@1: `---------------------------------------------------*/ yann@1: yyerrorlab: yann@1: yann@1: /* Pacify compilers like GCC when the user code never invokes yann@1: YYERROR and the label yyerrorlab therefore never appears in user yann@1: code. */ yann@943: if (/*CONSTCOND*/ 0) yann@1: goto yyerrorlab; yann@1: yann@943: /* Do not reclaim the symbols of the rule which action triggered yann@943: this YYERROR. */ yann@943: YYPOPSTACK (yylen); yann@943: yylen = 0; yann@943: YY_STACK_PRINT (yyss, yyssp); yann@1: yystate = *yyssp; yann@1: goto yyerrlab1; yann@1: yann@1: yann@1: /*-------------------------------------------------------------. yann@1: | yyerrlab1 -- common code for both syntax error and YYERROR. | yann@1: `-------------------------------------------------------------*/ yann@1: yyerrlab1: yann@1: yyerrstatus = 3; /* Each real token shifted decrements this. */ yann@1: yann@1: for (;;) yann@1: { yann@1: yyn = yypact[yystate]; yann@1: if (yyn != YYPACT_NINF) yann@1: { yann@1: yyn += YYTERROR; yann@1: if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) yann@1: { yann@1: yyn = yytable[yyn]; yann@1: if (0 < yyn) yann@1: break; yann@1: } yann@1: } yann@1: yann@1: /* Pop the current state because it cannot handle the error token. */ yann@1: if (yyssp == yyss) yann@1: YYABORT; yann@1: yann@1: yann@943: yydestruct ("Error: popping", yann@943: yystos[yystate], yyvsp); yann@943: YYPOPSTACK (1); yann@1: yystate = *yyssp; yann@1: YY_STACK_PRINT (yyss, yyssp); yann@1: } yann@1: yann@1: if (yyn == YYFINAL) yann@1: YYACCEPT; yann@1: yann@1: *++yyvsp = yylval; yann@1: yann@1: yann@943: /* Shift the error token. */ yann@1: YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yann@1: yann@1: yystate = yyn; yann@1: goto yynewstate; yann@1: yann@1: yann@1: /*-------------------------------------. yann@1: | yyacceptlab -- YYACCEPT comes here. | yann@1: `-------------------------------------*/ yann@1: yyacceptlab: yann@1: yyresult = 0; yann@1: goto yyreturn; yann@1: yann@1: /*-----------------------------------. yann@1: | yyabortlab -- YYABORT comes here. | yann@1: `-----------------------------------*/ yann@1: yyabortlab: yann@1: yyresult = 1; yann@1: goto yyreturn; yann@1: yann@1: #ifndef yyoverflow yann@1: /*-------------------------------------------------. yann@1: | yyexhaustedlab -- memory exhaustion comes here. | yann@1: `-------------------------------------------------*/ yann@1: yyexhaustedlab: yann@1: yyerror (YY_("memory exhausted")); yann@1: yyresult = 2; yann@1: /* Fall through. */ yann@1: #endif yann@1: yann@1: yyreturn: yann@1: if (yychar != YYEOF && yychar != YYEMPTY) yann@1: yydestruct ("Cleanup: discarding lookahead", yann@1: yytoken, &yylval); yann@943: /* Do not reclaim the symbols of the rule which action triggered yann@943: this YYABORT or YYACCEPT. */ yann@943: YYPOPSTACK (yylen); yann@943: YY_STACK_PRINT (yyss, yyssp); yann@1: while (yyssp != yyss) yann@1: { yann@1: yydestruct ("Cleanup: popping", yann@1: yystos[*yyssp], yyvsp); yann@943: YYPOPSTACK (1); yann@1: } yann@1: #ifndef yyoverflow yann@1: if (yyss != yyssa) yann@1: YYSTACK_FREE (yyss); yann@1: #endif yann@943: #if YYERROR_VERBOSE yann@943: if (yymsg != yymsgbuf) yann@943: YYSTACK_FREE (yymsg); yann@943: #endif yann@943: /* Make sure YYID is used. */ yann@943: return YYID (yyresult); yann@1: } yann@1: yann@1: yann@1: yann@1: yann@1: yann@1: void conf_parse(const char *name) yann@1: { yann@1: struct symbol *sym; yann@1: int i; yann@1: yann@1: zconf_initscan(name); yann@1: yann@1: sym_init(); yann@1: menu_init(); yann@1: modules_sym = sym_lookup(NULL, 0); yann@1: modules_sym->type = S_BOOLEAN; yann@1: modules_sym->flags |= SYMBOL_AUTO; yann@943: rootmenu.prompt = menu_add_prompt(P_MENU, PACKAGE, NULL); yann@1: yann@1: #if YYDEBUG yann@1: if (getenv("ZCONF_DEBUG")) yann@1: zconfdebug = 1; yann@1: #endif yann@1: zconfparse(); yann@1: if (zconfnerrs) yann@1: exit(1); yann@1: if (!modules_sym->prop) { yann@1: struct property *prop; yann@1: yann@1: prop = prop_alloc(P_DEFAULT, modules_sym); yann@1: prop->expr = expr_alloc_symbol(sym_lookup("MODULES", 0)); yann@1: } yann@1: menu_finalize(&rootmenu); yann@1: for_all_symbols(i, sym) { yann@943: if (sym_check_deps(sym)) yann@943: zconfnerrs++; yann@1: } yann@943: if (zconfnerrs) yann@943: exit(1); yann@39: sym_set_change_count(1); yann@1: } yann@1: yann@1: const char *zconf_tokenname(int token) yann@1: { yann@1: switch (token) { yann@1: case T_MENU: return "menu"; yann@1: case T_ENDMENU: return "endmenu"; yann@1: case T_CHOICE: return "choice"; yann@1: case T_ENDCHOICE: return "endchoice"; yann@1: case T_IF: return "if"; yann@1: case T_ENDIF: return "endif"; yann@1: case T_DEPENDS: return "depends"; yann@1: } yann@1: return ""; yann@1: } yann@1: yann@1: static bool zconf_endtoken(struct kconf_id *id, int starttoken, int endtoken) yann@1: { yann@1: if (id->token != endtoken) { yann@1: zconf_error("unexpected '%s' within %s block", yann@1: kconf_id_strings + id->name, zconf_tokenname(starttoken)); yann@1: zconfnerrs++; yann@1: return false; yann@1: } yann@1: if (current_menu->file != current_file) { yann@1: zconf_error("'%s' in different file than '%s'", yann@1: kconf_id_strings + id->name, zconf_tokenname(starttoken)); yann@1: fprintf(stderr, "%s:%d: location of the '%s'\n", yann@1: current_menu->file->name, current_menu->lineno, yann@1: zconf_tokenname(starttoken)); yann@1: zconfnerrs++; yann@1: return false; yann@1: } yann@1: return true; yann@1: } yann@1: yann@1: static void zconfprint(const char *err, ...) yann@1: { yann@1: va_list ap; yann@1: yann@1: fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno()); yann@1: va_start(ap, err); yann@1: vfprintf(stderr, err, ap); yann@1: va_end(ap); yann@1: fprintf(stderr, "\n"); yann@1: } yann@1: yann@1: static void zconf_error(const char *err, ...) yann@1: { yann@1: va_list ap; yann@1: yann@1: zconfnerrs++; yann@1: fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno()); yann@1: va_start(ap, err); yann@1: vfprintf(stderr, err, ap); yann@1: va_end(ap); yann@1: fprintf(stderr, "\n"); yann@1: } yann@1: yann@1: static void zconferror(const char *err) yann@1: { yann@1: #if YYDEBUG yann@1: fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err); yann@1: #endif yann@1: } yann@1: yann@1: void print_quoted_string(FILE *out, const char *str) yann@1: { yann@1: const char *p; yann@1: int len; yann@1: yann@1: putc('"', out); yann@1: while ((p = strchr(str, '"'))) { yann@1: len = p - str; yann@1: if (len) yann@1: fprintf(out, "%.*s", len, str); yann@1: fputs("\\\"", out); yann@1: str = p + 1; yann@1: } yann@1: fputs(str, out); yann@1: putc('"', out); yann@1: } yann@1: yann@1: void print_symbol(FILE *out, struct menu *menu) yann@1: { yann@1: struct symbol *sym = menu->sym; yann@1: struct property *prop; yann@1: yann@1: if (sym_is_choice(sym)) yann@1: fprintf(out, "choice\n"); yann@1: else yann@1: fprintf(out, "config %s\n", sym->name); yann@1: switch (sym->type) { yann@1: case S_BOOLEAN: yann@1: fputs(" boolean\n", out); yann@1: break; yann@1: case S_TRISTATE: yann@1: fputs(" tristate\n", out); yann@1: break; yann@1: case S_STRING: yann@1: fputs(" string\n", out); yann@1: break; yann@1: case S_INT: yann@1: fputs(" integer\n", out); yann@1: break; yann@1: case S_HEX: yann@1: fputs(" hex\n", out); yann@1: break; yann@1: default: yann@1: fputs(" ???\n", out); yann@1: break; yann@1: } yann@1: for (prop = sym->prop; prop; prop = prop->next) { yann@1: if (prop->menu != menu) yann@1: continue; yann@1: switch (prop->type) { yann@1: case P_PROMPT: yann@1: fputs(" prompt ", out); yann@1: print_quoted_string(out, prop->text); yann@1: if (!expr_is_yes(prop->visible.expr)) { yann@1: fputs(" if ", out); yann@1: expr_fprint(prop->visible.expr, out); yann@1: } yann@1: fputc('\n', out); yann@1: break; yann@1: case P_DEFAULT: yann@1: fputs( " default ", out); yann@1: expr_fprint(prop->expr, out); yann@1: if (!expr_is_yes(prop->visible.expr)) { yann@1: fputs(" if ", out); yann@1: expr_fprint(prop->visible.expr, out); yann@1: } yann@1: fputc('\n', out); yann@1: break; yann@1: case P_CHOICE: yann@1: fputs(" #choice value\n", out); yann@1: break; yann@1: default: yann@1: fprintf(out, " unknown prop %d!\n", prop->type); yann@1: break; yann@1: } yann@1: } yann@943: if (menu->help) { yann@943: int len = strlen(menu->help); yann@943: while (menu->help[--len] == '\n') yann@943: menu->help[len] = 0; yann@943: fprintf(out, " help\n%s\n", menu->help); yann@1: } yann@1: fputc('\n', out); yann@1: } yann@1: yann@1: void zconfdump(FILE *out) yann@1: { yann@1: struct property *prop; yann@1: struct symbol *sym; yann@1: struct menu *menu; yann@1: yann@1: menu = rootmenu.list; yann@1: while (menu) { yann@1: if ((sym = menu->sym)) yann@1: print_symbol(out, menu); yann@1: else if ((prop = menu->prompt)) { yann@1: switch (prop->type) { yann@1: case P_COMMENT: yann@1: fputs("\ncomment ", out); yann@1: print_quoted_string(out, prop->text); yann@1: fputs("\n", out); yann@1: break; yann@1: case P_MENU: yann@1: fputs("\nmenu ", out); yann@1: print_quoted_string(out, prop->text); yann@1: fputs("\n", out); yann@1: break; yann@1: default: yann@1: ; yann@1: } yann@1: if (!expr_is_yes(prop->visible.expr)) { yann@1: fputs(" depends ", out); yann@1: expr_fprint(prop->visible.expr, out); yann@1: fputc('\n', out); yann@1: } yann@1: fputs("\n", out); yann@1: } yann@1: yann@1: if (menu->list) yann@1: menu = menu->list; yann@1: else if (menu->next) yann@1: menu = menu->next; yann@1: else while ((menu = menu->parent)) { yann@1: if (menu->prompt && menu->prompt->type == P_MENU) yann@1: fputs("\nendmenu\n", out); yann@1: if (menu->next) { yann@1: menu = menu->next; yann@1: break; yann@1: } yann@1: } yann@1: } yann@1: } yann@1: yann@1: #include "lex.zconf.c" yann@1: #include "util.c" yann@1: #include "confdata.c" yann@1: #include "expr.c" yann@1: #include "symbol.c" yann@1: #include "menu.c" yann@1: