~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/kconfig/zconf.tab.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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"
2472 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp