scripts/kconfig/zconf.tab.c_shipped

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