kconfig/zconf.tab.c
author "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
Sun Jan 17 23:06:02 2010 +0100 (2010-01-17)
changeset 1740 c57458bb354d
parent 878 aa3be56634c1
child 2448 a103abae1560
permissions -rw-r--r--
configure: do not require hg when configuring in an hg clone

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