scripts/kconfig/zconf.tab.c_shipped

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