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