projects / openwrt / staging / jow.git / blob
? search:


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