scripts/config/zconf.tab.c_shipped

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