Return to zconf.tab.c_shipped CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / tools / kconfig

Annotation of qemu/roms/seabios/tools/kconfig/zconf.tab.c_shipped, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.