OpenWrt – Blame information for rev 2

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