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