| blob | 7b9b259ed2da853d8cdb0b5797b5636876f149d5 |
1 /* A Bison parser, made by GNU Bison 3.7.6. */
3 /* Bison implementation for Yacc-like parsers in C
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
6 Inc.
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <https://www.gnu.org/licenses/>. */
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38 especially those whose name start with YY_ or yy_. They are
39 private implementation details that can be changed or removed. */
41 /* All symbols defined below should begin with yy or YY, to avoid
42 infringing on user name space. This should be done even for local
43 variables, as they might otherwise be expanded by user macros.
44 There are some unavoidable exceptions within include files to
45 define necessary library symbols; they are noted "INFRINGES ON
46 USER NAME SPACE" below. */
48 /* Identify Bison output, and Bison version. */
49 #define YYBISON 30706
51 /* Bison version string. */
52 #define YYBISON_VERSION "3.7.6"
54 /* Skeleton name. */
55 #define YYSKELETON_NAME "yacc.c"
57 /* Pure parsers. */
58 #define YYPURE 0
60 /* Push parsers. */
61 #define YYPUSH 0
63 /* Pull parsers. */
64 #define YYPULL 1
69 /* First part of user prologue. */
72 #include <ctype.h>
73 #include <stdarg.h>
74 #include <stdio.h>
75 #include <stdlib.h>
76 #include <string.h>
77 #include <stdbool.h>
79 #include "lkc.h"
80 #include "internal.h"
82 #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
84 #define PRINTD 0x0001
85 #define DEBUG_PARSE 0x0002
87 int cdebug = PRINTD;
89 static void yyerror(const char *err);
90 static void zconfprint(const char *err, ...);
91 static void zconf_error(const char *err, ...);
92 static bool zconf_endtoken(const char *tokenname,
93 const char *expected_tokenname);
95 struct symbol *symbol_hash[SYMBOL_HASHSIZE];
97 struct menu *current_menu, *current_entry;
101 # ifndef YY_CAST
102 # ifdef __cplusplus
103 # define YY_CAST(Type, Val) static_cast<Type> (Val)
104 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
105 # else
106 # define YY_CAST(Type, Val) ((Type) (Val))
107 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
108 # endif
109 # endif
110 # ifndef YY_NULLPTR
111 # if defined __cplusplus
112 # if 201103L <= __cplusplus
113 # define YY_NULLPTR nullptr
114 # else
115 # define YY_NULLPTR 0
116 # endif
117 # else
118 # define YY_NULLPTR ((void*)0)
119 # endif
120 # endif
122 #include "parser.tab.h"
123 /* Symbol kind. */
124 enum yysymbol_kind_t
125 {
126 YYSYMBOL_YYEMPTY = -2,
127 YYSYMBOL_YYEOF = 0, /* "end of file" */
128 YYSYMBOL_YYerror = 1, /* error */
129 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
130 YYSYMBOL_T_HELPTEXT = 3, /* T_HELPTEXT */
131 YYSYMBOL_T_WORD = 4, /* T_WORD */
132 YYSYMBOL_T_WORD_QUOTE = 5, /* T_WORD_QUOTE */
133 YYSYMBOL_T_BOOL = 6, /* T_BOOL */
134 YYSYMBOL_T_CHOICE = 7, /* T_CHOICE */
135 YYSYMBOL_T_CLOSE_PAREN = 8, /* T_CLOSE_PAREN */
136 YYSYMBOL_T_COLON_EQUAL = 9, /* T_COLON_EQUAL */
137 YYSYMBOL_T_COMMENT = 10, /* T_COMMENT */
138 YYSYMBOL_T_CONFIG = 11, /* T_CONFIG */
139 YYSYMBOL_T_DEFAULT = 12, /* T_DEFAULT */
140 YYSYMBOL_T_DEF_BOOL = 13, /* T_DEF_BOOL */
141 YYSYMBOL_T_DEF_TRISTATE = 14, /* T_DEF_TRISTATE */
142 YYSYMBOL_T_DEPENDS = 15, /* T_DEPENDS */
143 YYSYMBOL_T_ENDCHOICE = 16, /* T_ENDCHOICE */
144 YYSYMBOL_T_ENDIF = 17, /* T_ENDIF */
145 YYSYMBOL_T_ENDMENU = 18, /* T_ENDMENU */
146 YYSYMBOL_T_HELP = 19, /* T_HELP */
147 YYSYMBOL_T_HEX = 20, /* T_HEX */
148 YYSYMBOL_T_IF = 21, /* T_IF */
149 YYSYMBOL_T_IMPLY = 22, /* T_IMPLY */
150 YYSYMBOL_T_INT = 23, /* T_INT */
151 YYSYMBOL_T_MAINMENU = 24, /* T_MAINMENU */
152 YYSYMBOL_T_MENU = 25, /* T_MENU */
153 YYSYMBOL_T_MENUCONFIG = 26, /* T_MENUCONFIG */
154 YYSYMBOL_T_MODULES = 27, /* T_MODULES */
155 YYSYMBOL_T_ON = 28, /* T_ON */
156 YYSYMBOL_T_OPEN_PAREN = 29, /* T_OPEN_PAREN */
157 YYSYMBOL_T_OPTIONAL = 30, /* T_OPTIONAL */
158 YYSYMBOL_T_PLUS_EQUAL = 31, /* T_PLUS_EQUAL */
159 YYSYMBOL_T_PROMPT = 32, /* T_PROMPT */
160 YYSYMBOL_T_RANGE = 33, /* T_RANGE */
161 YYSYMBOL_T_SELECT = 34, /* T_SELECT */
162 YYSYMBOL_T_SOURCE = 35, /* T_SOURCE */
163 YYSYMBOL_T_STRING = 36, /* T_STRING */
164 YYSYMBOL_T_TRISTATE = 37, /* T_TRISTATE */
165 YYSYMBOL_T_VISIBLE = 38, /* T_VISIBLE */
166 YYSYMBOL_T_EOL = 39, /* T_EOL */
167 YYSYMBOL_T_ASSIGN_VAL = 40, /* T_ASSIGN_VAL */
168 YYSYMBOL_T_OR = 41, /* T_OR */
169 YYSYMBOL_T_AND = 42, /* T_AND */
170 YYSYMBOL_T_EQUAL = 43, /* T_EQUAL */
171 YYSYMBOL_T_UNEQUAL = 44, /* T_UNEQUAL */
172 YYSYMBOL_T_LESS = 45, /* T_LESS */
173 YYSYMBOL_T_LESS_EQUAL = 46, /* T_LESS_EQUAL */
174 YYSYMBOL_T_GREATER = 47, /* T_GREATER */
175 YYSYMBOL_T_GREATER_EQUAL = 48, /* T_GREATER_EQUAL */
176 YYSYMBOL_T_NOT = 49, /* T_NOT */
177 YYSYMBOL_YYACCEPT = 50, /* $accept */
178 YYSYMBOL_input = 51, /* input */
179 YYSYMBOL_mainmenu_stmt = 52, /* mainmenu_stmt */
180 YYSYMBOL_stmt_list = 53, /* stmt_list */
181 YYSYMBOL_stmt_list_in_choice = 54, /* stmt_list_in_choice */
182 YYSYMBOL_config_entry_start = 55, /* config_entry_start */
183 YYSYMBOL_config_stmt = 56, /* config_stmt */
184 YYSYMBOL_menuconfig_entry_start = 57, /* menuconfig_entry_start */
185 YYSYMBOL_menuconfig_stmt = 58, /* menuconfig_stmt */
186 YYSYMBOL_config_option_list = 59, /* config_option_list */
187 YYSYMBOL_config_option = 60, /* config_option */
188 YYSYMBOL_choice = 61, /* choice */
189 YYSYMBOL_choice_entry = 62, /* choice_entry */
190 YYSYMBOL_choice_end = 63, /* choice_end */
191 YYSYMBOL_choice_stmt = 64, /* choice_stmt */
192 YYSYMBOL_choice_option_list = 65, /* choice_option_list */
193 YYSYMBOL_choice_option = 66, /* choice_option */
194 YYSYMBOL_type = 67, /* type */
195 YYSYMBOL_logic_type = 68, /* logic_type */
196 YYSYMBOL_default = 69, /* default */
197 YYSYMBOL_if_entry = 70, /* if_entry */
198 YYSYMBOL_if_end = 71, /* if_end */
199 YYSYMBOL_if_stmt = 72, /* if_stmt */
200 YYSYMBOL_if_stmt_in_choice = 73, /* if_stmt_in_choice */
201 YYSYMBOL_menu = 74, /* menu */
202 YYSYMBOL_menu_entry = 75, /* menu_entry */
203 YYSYMBOL_menu_end = 76, /* menu_end */
204 YYSYMBOL_menu_stmt = 77, /* menu_stmt */
205 YYSYMBOL_menu_option_list = 78, /* menu_option_list */
206 YYSYMBOL_source_stmt = 79, /* source_stmt */
207 YYSYMBOL_comment = 80, /* comment */
208 YYSYMBOL_comment_stmt = 81, /* comment_stmt */
209 YYSYMBOL_comment_option_list = 82, /* comment_option_list */
210 YYSYMBOL_help_start = 83, /* help_start */
211 YYSYMBOL_help = 84, /* help */
212 YYSYMBOL_depends = 85, /* depends */
213 YYSYMBOL_visible = 86, /* visible */
214 YYSYMBOL_prompt_stmt_opt = 87, /* prompt_stmt_opt */
215 YYSYMBOL_end = 88, /* end */
216 YYSYMBOL_if_expr = 89, /* if_expr */
217 YYSYMBOL_expr = 90, /* expr */
218 YYSYMBOL_nonconst_symbol = 91, /* nonconst_symbol */
219 YYSYMBOL_symbol = 92, /* symbol */
220 YYSYMBOL_word_opt = 93, /* word_opt */
221 YYSYMBOL_assignment_stmt = 94, /* assignment_stmt */
222 YYSYMBOL_assign_op = 95, /* assign_op */
223 YYSYMBOL_assign_val = 96 /* assign_val */
224 };
225 typedef enum yysymbol_kind_t yysymbol_kind_t;
230 #ifdef short
231 # undef short
232 #endif
234 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
235 <limits.h> and (if available) <stdint.h> are included
236 so that the code can choose integer types of a good width. */
238 #ifndef __PTRDIFF_MAX__
239 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
240 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
241 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
242 # define YY_STDINT_H
243 # endif
244 #endif
246 /* Narrow types that promote to a signed type and that can represent a
247 signed or unsigned integer of at least N bits. In tables they can
248 save space and decrease cache pressure. Promoting to a signed type
249 helps avoid bugs in integer arithmetic. */
251 #ifdef __INT_LEAST8_MAX__
252 typedef __INT_LEAST8_TYPE__ yytype_int8;
253 #elif defined YY_STDINT_H
254 typedef int_least8_t yytype_int8;
255 #else
256 typedef signed char yytype_int8;
257 #endif
259 #ifdef __INT_LEAST16_MAX__
260 typedef __INT_LEAST16_TYPE__ yytype_int16;
261 #elif defined YY_STDINT_H
262 typedef int_least16_t yytype_int16;
263 #else
264 typedef short yytype_int16;
265 #endif
267 /* Work around bug in HP-UX 11.23, which defines these macros
268 incorrectly for preprocessor constants. This workaround can likely
269 be removed in 2023, as HPE has promised support for HP-UX 11.23
270 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
271 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
272 #ifdef __hpux
273 # undef UINT_LEAST8_MAX
274 # undef UINT_LEAST16_MAX
275 # define UINT_LEAST8_MAX 255
276 # define UINT_LEAST16_MAX 65535
277 #endif
279 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
280 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
281 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
282 && UINT_LEAST8_MAX <= INT_MAX)
283 typedef uint_least8_t yytype_uint8;
284 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
285 typedef unsigned char yytype_uint8;
286 #else
287 typedef short yytype_uint8;
288 #endif
290 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
291 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
292 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
293 && UINT_LEAST16_MAX <= INT_MAX)
294 typedef uint_least16_t yytype_uint16;
295 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
296 typedef unsigned short yytype_uint16;
297 #else
298 typedef int yytype_uint16;
299 #endif
301 #ifndef YYPTRDIFF_T
302 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
303 # define YYPTRDIFF_T __PTRDIFF_TYPE__
304 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
305 # elif defined PTRDIFF_MAX
306 # ifndef ptrdiff_t
307 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
308 # endif
309 # define YYPTRDIFF_T ptrdiff_t
310 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
311 # else
312 # define YYPTRDIFF_T long
313 # define YYPTRDIFF_MAXIMUM LONG_MAX
314 # endif
315 #endif
317 #ifndef YYSIZE_T
318 # ifdef __SIZE_TYPE__
319 # define YYSIZE_T __SIZE_TYPE__
320 # elif defined size_t
321 # define YYSIZE_T size_t
322 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
323 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
324 # define YYSIZE_T size_t
325 # else
326 # define YYSIZE_T unsigned
327 # endif
328 #endif
330 #define YYSIZE_MAXIMUM \
331 YY_CAST (YYPTRDIFF_T, \
332 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
333 ? YYPTRDIFF_MAXIMUM \
334 : YY_CAST (YYSIZE_T, -1)))
336 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
339 /* Stored state numbers (used for stacks). */
340 typedef yytype_uint8 yy_state_t;
342 /* State numbers in computations. */
343 typedef int yy_state_fast_t;
345 #ifndef YY_
346 # if defined YYENABLE_NLS && YYENABLE_NLS
347 # if ENABLE_NLS
348 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
349 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
350 # endif
351 # endif
352 # ifndef YY_
353 # define YY_(Msgid) Msgid
354 # endif
355 #endif
358 #ifndef YY_ATTRIBUTE_PURE
359 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
360 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
361 # else
362 # define YY_ATTRIBUTE_PURE
363 # endif
364 #endif
366 #ifndef YY_ATTRIBUTE_UNUSED
367 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
368 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
369 # else
370 # define YY_ATTRIBUTE_UNUSED
371 # endif
372 #endif
374 /* Suppress unused-variable warnings by "using" E. */
375 #if ! defined lint || defined __GNUC__
376 # define YY_USE(E) ((void) (E))
377 #else
378 # define YY_USE(E) /* empty */
379 #endif
381 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
382 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
383 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
384 _Pragma ("GCC diagnostic push") \
385 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
386 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
387 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
388 _Pragma ("GCC diagnostic pop")
389 #else
390 # define YY_INITIAL_VALUE(Value) Value
391 #endif
392 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
393 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
394 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
395 #endif
396 #ifndef YY_INITIAL_VALUE
397 # define YY_INITIAL_VALUE(Value) /* Nothing. */
398 #endif
400 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
401 # define YY_IGNORE_USELESS_CAST_BEGIN \
402 _Pragma ("GCC diagnostic push") \
403 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
404 # define YY_IGNORE_USELESS_CAST_END \
405 _Pragma ("GCC diagnostic pop")
406 #endif
407 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
408 # define YY_IGNORE_USELESS_CAST_BEGIN
409 # define YY_IGNORE_USELESS_CAST_END
410 #endif
413 #define YY_ASSERT(E) ((void) (0 && (E)))
415 #if !defined yyoverflow
417 /* The parser invokes alloca or malloc; define the necessary symbols. */
419 # ifdef YYSTACK_USE_ALLOCA
420 # if YYSTACK_USE_ALLOCA
421 # ifdef __GNUC__
422 # define YYSTACK_ALLOC __builtin_alloca
423 # elif defined __BUILTIN_VA_ARG_INCR
424 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
425 # elif defined _AIX
426 # define YYSTACK_ALLOC __alloca
427 # elif defined _MSC_VER
428 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
429 # define alloca _alloca
430 # else
431 # define YYSTACK_ALLOC alloca
432 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
433 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
434 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
435 # ifndef EXIT_SUCCESS
436 # define EXIT_SUCCESS 0
437 # endif
438 # endif
439 # endif
440 # endif
441 # endif
443 # ifdef YYSTACK_ALLOC
444 /* Pacify GCC's 'empty if-body' warning. */
445 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
446 # ifndef YYSTACK_ALLOC_MAXIMUM
447 /* The OS might guarantee only one guard page at the bottom of the stack,
448 and a page size can be as small as 4096 bytes. So we cannot safely
449 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
450 to allow for a few compiler-allocated temporary stack slots. */
451 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
452 # endif
453 # else
454 # define YYSTACK_ALLOC YYMALLOC
455 # define YYSTACK_FREE YYFREE
456 # ifndef YYSTACK_ALLOC_MAXIMUM
457 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
458 # endif
459 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
460 && ! ((defined YYMALLOC || defined malloc) \
461 && (defined YYFREE || defined free)))
462 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
463 # ifndef EXIT_SUCCESS
464 # define EXIT_SUCCESS 0
465 # endif
466 # endif
467 # ifndef YYMALLOC
468 # define YYMALLOC malloc
469 # if ! defined malloc && ! defined EXIT_SUCCESS
470 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
471 # endif
472 # endif
473 # ifndef YYFREE
474 # define YYFREE free
475 # if ! defined free && ! defined EXIT_SUCCESS
476 void free (void *); /* INFRINGES ON USER NAME SPACE */
477 # endif
478 # endif
479 # endif
480 #endif /* !defined yyoverflow */
482 #if (! defined yyoverflow \
483 && (! defined __cplusplus \
484 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
486 /* A type that is properly aligned for any stack member. */
487 union yyalloc
488 {
489 yy_state_t yyss_alloc;
490 YYSTYPE yyvs_alloc;
491 };
493 /* The size of the maximum gap between one aligned stack and the next. */
494 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
496 /* The size of an array large to enough to hold all stacks, each with
497 N elements. */
498 # define YYSTACK_BYTES(N) \
499 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
500 + YYSTACK_GAP_MAXIMUM)
502 # define YYCOPY_NEEDED 1
504 /* Relocate STACK from its old location to the new one. The
505 local variables YYSIZE and YYSTACKSIZE give the old and new number of
506 elements in the stack, and YYPTR gives the new location of the
507 stack. Advance YYPTR to a properly aligned location for the next
508 stack. */
509 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
510 do \
511 { \
512 YYPTRDIFF_T yynewbytes; \
513 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
514 Stack = &yyptr->Stack_alloc; \
515 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
516 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
517 } \
518 while (0)
520 #endif
522 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
523 /* Copy COUNT objects from SRC to DST. The source and destination do
524 not overlap. */
525 # ifndef YYCOPY
526 # if defined __GNUC__ && 1 < __GNUC__
527 # define YYCOPY(Dst, Src, Count) \
528 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
529 # else
530 # define YYCOPY(Dst, Src, Count) \
531 do \
532 { \
533 YYPTRDIFF_T yyi; \
534 for (yyi = 0; yyi < (Count); yyi++) \
535 (Dst)[yyi] = (Src)[yyi]; \
536 } \
537 while (0)
538 # endif
539 # endif
540 #endif /* !YYCOPY_NEEDED */
542 /* YYFINAL -- State number of the termination state. */
543 #define YYFINAL 6
544 /* YYLAST -- Last index in YYTABLE. */
545 #define YYLAST 187
547 /* YYNTOKENS -- Number of terminals. */
548 #define YYNTOKENS 50
549 /* YYNNTS -- Number of nonterminals. */
550 #define YYNNTS 47
551 /* YYNRULES -- Number of rules. */
552 #define YYNRULES 106
553 /* YYNSTATES -- Number of states. */
554 #define YYNSTATES 185
556 /* YYMAXUTOK -- Last valid token kind. */
557 #define YYMAXUTOK 304
560 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
561 as returned by yylex, with out-of-bounds checking. */
562 #define YYTRANSLATE(YYX) \
563 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
564 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
565 : YYSYMBOL_YYUNDEF)
567 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
568 as returned by yylex. */
569 static const yytype_int8 yytranslate[] =
570 {
571 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
589 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
590 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
592 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
593 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
594 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
595 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
597 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
598 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
599 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
600 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
601 45, 46, 47, 48, 49
602 };
604 #if YYDEBUG
605 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
606 static const yytype_int16 yyrline[] =
607 {
608 0, 109, 109, 109, 113, 118, 120, 121, 122, 123,
609 124, 125, 126, 127, 128, 129, 132, 134, 135, 136,
610 137, 138, 143, 150, 155, 162, 171, 173, 174, 175,
611 178, 186, 192, 202, 208, 214, 220, 230, 240, 245,
612 253, 256, 258, 259, 260, 263, 269, 276, 282, 290,
613 291, 292, 293, 296, 297, 300, 301, 302, 306, 314,
614 322, 325, 330, 337, 342, 350, 353, 355, 356, 359,
615 368, 375, 378, 380, 385, 391, 409, 416, 423, 425,
616 430, 431, 432, 435, 436, 439, 440, 441, 442, 443,
617 444, 445, 446, 447, 448, 449, 453, 455, 456, 459,
618 460, 464, 467, 468, 469, 473, 474
619 };
620 #endif
622 /** Accessing symbol of state STATE. */
623 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
625 #if YYDEBUG || 0
626 /* The user-facing name of the symbol whose (internal) number is
627 YYSYMBOL. No bounds checking. */
628 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
630 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
631 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
632 static const char *const yytname[] =
633 {
634 "\"end of file\"", "error", "\"invalid token\"", "T_HELPTEXT", "T_WORD",
635 "T_WORD_QUOTE", "T_BOOL", "T_CHOICE", "T_CLOSE_PAREN", "T_COLON_EQUAL",
636 "T_COMMENT", "T_CONFIG", "T_DEFAULT", "T_DEF_BOOL", "T_DEF_TRISTATE",
637 "T_DEPENDS", "T_ENDCHOICE", "T_ENDIF", "T_ENDMENU", "T_HELP", "T_HEX",
638 "T_IF", "T_IMPLY", "T_INT", "T_MAINMENU", "T_MENU", "T_MENUCONFIG",
639 "T_MODULES", "T_ON", "T_OPEN_PAREN", "T_OPTIONAL", "T_PLUS_EQUAL",
640 "T_PROMPT", "T_RANGE", "T_SELECT", "T_SOURCE", "T_STRING", "T_TRISTATE",
641 "T_VISIBLE", "T_EOL", "T_ASSIGN_VAL", "T_OR", "T_AND", "T_EQUAL",
642 "T_UNEQUAL", "T_LESS", "T_LESS_EQUAL", "T_GREATER", "T_GREATER_EQUAL",
643 "T_NOT", "$accept", "input", "mainmenu_stmt", "stmt_list",
644 "stmt_list_in_choice", "config_entry_start", "config_stmt",
645 "menuconfig_entry_start", "menuconfig_stmt", "config_option_list",
646 "config_option", "choice", "choice_entry", "choice_end", "choice_stmt",
647 "choice_option_list", "choice_option", "type", "logic_type", "default",
648 "if_entry", "if_end", "if_stmt", "if_stmt_in_choice", "menu",
649 "menu_entry", "menu_end", "menu_stmt", "menu_option_list", "source_stmt",
650 "comment", "comment_stmt", "comment_option_list", "help_start", "help",
651 "depends", "visible", "prompt_stmt_opt", "end", "if_expr", "expr",
652 "nonconst_symbol", "symbol", "word_opt", "assignment_stmt", "assign_op",
653 "assign_val", YY_NULLPTR
654 };
656 static const char *
657 yysymbol_name (yysymbol_kind_t yysymbol)
658 {
659 return yytname[yysymbol];
660 }
661 #endif
663 #ifdef YYPRINT
664 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
665 (internal) symbol number NUM (which must be that of a token). */
666 static const yytype_int16 yytoknum[] =
667 {
668 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
669 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
670 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
671 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
672 295, 296, 297, 298, 299, 300, 301, 302, 303, 304
673 };
674 #endif
676 #define YYPACT_NINF (-64)
678 #define yypact_value_is_default(Yyn) \
679 ((Yyn) == YYPACT_NINF)
681 #define YYTABLE_NINF (-4)
683 #define yytable_value_is_error(Yyn) \
684 0
686 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
687 STATE-NUM. */
688 static const yytype_int16 yypact[] =
689 {
690 5, 26, 27, -64, 34, -2, -64, 64, 8, 15,
691 47, 52, 59, 3, 65, 59, 67, -64, -64, -64,
692 -64, -64, -64, -64, -64, -64, -64, -64, -64, -64,
693 -64, -64, -64, -64, -64, 40, -64, -64, -64, 41,
694 -64, 58, 62, -64, 74, -64, 3, 3, 54, -64,
695 -25, 77, 78, 81, 125, 125, 148, 32, 108, 2,
696 108, 93, -64, -64, 82, -64, -64, -64, 20, -64,
697 -64, 3, 3, 87, 87, 87, 87, 87, 87, -64,
698 -64, -64, -64, -64, -64, -64, 56, 83, -64, 59,
699 -64, 84, 122, 87, 59, -64, -64, -64, 123, -64,
700 3, 127, -64, -64, 59, 96, 131, -64, 123, -64,
701 -64, 102, 103, 107, 110, -64, -64, -64, -64, -64,
702 -64, -64, -64, -64, 111, -64, -64, -64, -64, -64,
703 -64, -64, 109, -64, -64, -64, -64, -64, -64, -64,
704 3, -64, 111, -64, 111, 87, 111, 111, 114, 45,
705 -64, 111, -64, 111, 116, -64, -64, -64, -64, 32,
706 3, 117, 61, 126, 133, 111, 135, -64, -64, 137,
707 138, 140, -64, -64, 69, -64, -64, -64, -64, 142,
708 -64, -64, -64, -64, -64
709 };
711 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
712 Performed when YYTABLE does not specify something else to do. Zero
713 means the default is an error. */
714 static const yytype_int8 yydefact[] =
715 {
716 5, 0, 0, 5, 0, 0, 1, 0, 0, 0,
717 99, 0, 0, 0, 0, 0, 0, 26, 9, 26,
718 12, 41, 16, 7, 5, 10, 66, 5, 11, 13,
719 72, 8, 6, 4, 15, 0, 103, 104, 102, 105,
720 100, 0, 0, 96, 0, 98, 0, 0, 0, 97,
721 85, 0, 0, 0, 23, 25, 38, 0, 0, 63,
722 0, 71, 14, 106, 0, 37, 70, 22, 0, 93,
723 58, 0, 0, 0, 0, 0, 0, 0, 0, 62,
724 24, 69, 53, 55, 56, 57, 0, 0, 51, 0,
725 50, 0, 0, 0, 0, 52, 54, 27, 78, 49,
726 0, 0, 29, 28, 0, 0, 0, 42, 78, 44,
727 43, 0, 0, 0, 0, 18, 40, 16, 19, 20,
728 17, 39, 60, 59, 83, 68, 67, 65, 64, 73,
729 101, 92, 94, 95, 90, 91, 86, 87, 88, 89,
730 0, 74, 83, 36, 83, 0, 83, 83, 0, 83,
731 75, 83, 47, 83, 0, 21, 81, 82, 80, 0,
732 0, 0, 0, 0, 0, 83, 0, 79, 30, 0,
733 0, 0, 46, 61, 84, 77, 76, 34, 31, 0,
734 33, 32, 48, 45, 35
735 };
737 /* YYPGOTO[NTERM-NUM]. */
738 static const yytype_int16 yypgoto[] =
739 {
740 -64, -64, -64, 53, 33, -64, -55, -64, -64, 151,
741 -64, -64, -64, -64, -64, -64, -64, -64, 128, -64,
742 -54, 23, -64, -64, -64, -64, -64, -64, -64, -53,
743 -64, -52, -64, -64, 130, 17, -64, 75, -21, 22,
744 -46, -6, -63, -64, -64, -64, -64
745 };
747 /* YYDEFGOTO[NTERM-NUM]. */
748 static const yytype_uint8 yydefgoto[] =
749 {
750 0, 2, 3, 4, 57, 17, 18, 19, 20, 54,
751 97, 21, 22, 116, 23, 56, 107, 98, 99, 100,
752 24, 122, 25, 118, 26, 27, 127, 28, 59, 29,
753 30, 31, 61, 101, 102, 103, 126, 148, 123, 161,
754 48, 49, 50, 41, 32, 39, 64
755 };
757 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
758 positive, shift that token. If negative, reduce the rule whose
759 number is the opposite. If YYTABLE_NINF, syntax error. */
760 static const yytype_int16 yytable[] =
761 {
762 68, 69, 115, 117, 119, 120, 44, 43, 45, 52,
763 134, 135, 136, 137, 138, 139, 35, 86, 73, 74,
764 75, 76, 77, 78, 36, 132, 133, 6, 131, 1,
765 145, 5, 46, 111, -3, 8, 121, 33, 9, 128,
766 124, 10, 11, 12, 11, 12, 37, 34, 112, 113,
767 114, 40, 47, 13, 149, 13, 7, 42, 38, 14,
768 15, 71, 72, 43, -2, 8, 160, 16, 9, 16,
769 51, 10, 53, 110, 11, 12, 125, 58, 129, 62,
770 60, 63, 165, 142, 140, 13, 71, 72, 146, 14,
771 15, 43, 45, 70, 162, 71, 72, 65, 151, 16,
772 176, 66, 71, 72, 115, 117, 119, 120, 86, 8,
773 71, 72, 9, 67, 174, 10, 79, 80, 11, 12,
774 81, 130, 141, 143, 112, 113, 114, 144, 147, 13,
775 150, 82, 160, 14, 15, 152, 153, 83, 84, 85,
776 86, 155, 156, 16, 87, 88, 157, 89, 90, 158,
777 159, 72, 91, 168, 82, 172, 175, 92, 93, 94,
778 104, 95, 96, 86, 163, 177, 164, 87, 166, 167,
779 55, 169, 178, 170, 180, 171, 181, 182, 105, 183,
780 106, 184, 173, 154, 108, 96, 109, 179
781 };
783 static const yytype_uint8 yycheck[] =
784 {
785 46, 47, 57, 57, 57, 57, 12, 4, 5, 15,
786 73, 74, 75, 76, 77, 78, 1, 15, 43, 44,
787 45, 46, 47, 48, 9, 71, 72, 0, 8, 24,
788 93, 5, 29, 1, 0, 1, 57, 39, 4, 60,
789 38, 7, 10, 11, 10, 11, 31, 39, 16, 17,
790 18, 4, 49, 21, 100, 21, 3, 5, 43, 25,
791 26, 41, 42, 4, 0, 1, 21, 35, 4, 35,
792 5, 7, 5, 56, 10, 11, 59, 24, 61, 39,
793 27, 40, 145, 89, 28, 21, 41, 42, 94, 25,
794 26, 4, 5, 39, 140, 41, 42, 39, 104, 35,
795 39, 39, 41, 42, 159, 159, 159, 159, 15, 1,
796 41, 42, 4, 39, 160, 7, 39, 39, 10, 11,
797 39, 39, 39, 39, 16, 17, 18, 5, 5, 21,
798 3, 6, 21, 25, 26, 39, 5, 12, 13, 14,
799 15, 39, 39, 35, 19, 20, 39, 22, 23, 39,
800 117, 42, 27, 39, 6, 39, 39, 32, 33, 34,
801 12, 36, 37, 15, 142, 39, 144, 19, 146, 147,
802 19, 149, 39, 151, 39, 153, 39, 39, 30, 39,
803 32, 39, 159, 108, 56, 37, 56, 165
804 };
806 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
807 symbol of state STATE-NUM. */
808 static const yytype_int8 yystos[] =
809 {
810 0, 24, 51, 52, 53, 5, 0, 53, 1, 4,
811 7, 10, 11, 21, 25, 26, 35, 55, 56, 57,
812 58, 61, 62, 64, 70, 72, 74, 75, 77, 79,
813 80, 81, 94, 39, 39, 1, 9, 31, 43, 95,
814 4, 93, 5, 4, 91, 5, 29, 49, 90, 91,
815 92, 5, 91, 5, 59, 59, 65, 54, 53, 78,
816 53, 82, 39, 40, 96, 39, 39, 39, 90, 90,
817 39, 41, 42, 43, 44, 45, 46, 47, 48, 39,
818 39, 39, 6, 12, 13, 14, 15, 19, 20, 22,
819 23, 27, 32, 33, 34, 36, 37, 60, 67, 68,
820 69, 83, 84, 85, 12, 30, 32, 66, 68, 84,
821 85, 1, 16, 17, 18, 56, 63, 70, 73, 79,
822 81, 88, 71, 88, 38, 85, 86, 76, 88, 85,
823 39, 8, 90, 90, 92, 92, 92, 92, 92, 92,
824 28, 39, 91, 39, 5, 92, 91, 5, 87, 90,
825 3, 91, 39, 5, 87, 39, 39, 39, 39, 54,
826 21, 89, 90, 89, 89, 92, 89, 89, 39, 89,
827 89, 89, 39, 71, 90, 39, 39, 39, 39, 89,
828 39, 39, 39, 39, 39
829 };
831 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
832 static const yytype_int8 yyr1[] =
833 {
834 0, 50, 51, 51, 52, 53, 53, 53, 53, 53,
835 53, 53, 53, 53, 53, 53, 54, 54, 54, 54,
836 54, 54, 55, 56, 57, 58, 59, 59, 59, 59,
837 60, 60, 60, 60, 60, 60, 60, 61, 62, 63,
838 64, 65, 65, 65, 65, 66, 66, 66, 66, 67,
839 67, 67, 67, 68, 68, 69, 69, 69, 70, 71,
840 72, 73, 74, 75, 76, 77, 78, 78, 78, 79,
841 80, 81, 82, 82, 83, 84, 85, 86, 87, 87,
842 88, 88, 88, 89, 89, 90, 90, 90, 90, 90,
843 90, 90, 90, 90, 90, 90, 91, 92, 92, 93,
844 93, 94, 95, 95, 95, 96, 96
845 };
847 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
848 static const yytype_int8 yyr2[] =
849 {
850 0, 2, 2, 1, 3, 0, 2, 2, 2, 2,
851 2, 2, 2, 2, 4, 3, 0, 2, 2, 2,
852 2, 3, 3, 2, 3, 2, 0, 2, 2, 2,
853 3, 4, 4, 4, 4, 5, 2, 3, 2, 1,
854 3, 0, 2, 2, 2, 4, 3, 2, 4, 1,
855 1, 1, 1, 1, 1, 1, 1, 1, 3, 1,
856 3, 3, 3, 2, 1, 3, 0, 2, 2, 3,
857 3, 2, 0, 2, 2, 2, 4, 3, 0, 2,
858 2, 2, 2, 0, 2, 1, 3, 3, 3, 3,
859 3, 3, 3, 2, 3, 3, 1, 1, 1, 0,
860 1, 4, 1, 1, 1, 0, 1
861 };
864 enum { YYENOMEM = -2 };
866 #define yyerrok (yyerrstatus = 0)
867 #define yyclearin (yychar = YYEMPTY)
869 #define YYACCEPT goto yyacceptlab
870 #define YYABORT goto yyabortlab
871 #define YYERROR goto yyerrorlab
874 #define YYRECOVERING() (!!yyerrstatus)
876 #define YYBACKUP(Token, Value) \
877 do \
878 if (yychar == YYEMPTY) \
879 { \
880 yychar = (Token); \
881 yylval = (Value); \
882 YYPOPSTACK (yylen); \
883 yystate = *yyssp; \
884 goto yybackup; \
885 } \
886 else \
887 { \
888 yyerror (YY_("syntax error: cannot back up")); \
889 YYERROR; \
890 } \
891 while (0)
893 /* Backward compatibility with an undocumented macro.
894 Use YYerror or YYUNDEF. */
895 #define YYERRCODE YYUNDEF
898 /* Enable debugging if requested. */
899 #if YYDEBUG
901 # ifndef YYFPRINTF
902 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
903 # define YYFPRINTF fprintf
904 # endif
906 # define YYDPRINTF(Args) \
907 do { \
908 if (yydebug) \
909 YYFPRINTF Args; \
910 } while (0)
912 /* This macro is provided for backward compatibility. */
913 # ifndef YY_LOCATION_PRINT
914 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
915 # endif
918 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
919 do { \
920 if (yydebug) \
921 { \
922 YYFPRINTF (stderr, "%s ", Title); \
923 yy_symbol_print (stderr, \
924 Kind, Value); \
925 YYFPRINTF (stderr, "\n"); \
926 } \
927 } while (0)
930 /*-----------------------------------.
931 | Print this symbol's value on YYO. |
932 `-----------------------------------*/
934 static void
935 yy_symbol_value_print (FILE *yyo,
936 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
937 {
938 FILE *yyoutput = yyo;
939 YY_USE (yyoutput);
940 if (!yyvaluep)
941 return;
942 # ifdef YYPRINT
943 if (yykind < YYNTOKENS)
944 YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
945 # endif
946 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
947 YY_USE (yykind);
948 YY_IGNORE_MAYBE_UNINITIALIZED_END
949 }
952 /*---------------------------.
953 | Print this symbol on YYO. |
954 `---------------------------*/
956 static void
957 yy_symbol_print (FILE *yyo,
958 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
959 {
960 YYFPRINTF (yyo, "%s %s (",
961 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
963 yy_symbol_value_print (yyo, yykind, yyvaluep);
964 YYFPRINTF (yyo, ")");
965 }
967 /*------------------------------------------------------------------.
968 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
969 | TOP (included). |
970 `------------------------------------------------------------------*/
972 static void
973 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
974 {
975 YYFPRINTF (stderr, "Stack now");
976 for (; yybottom <= yytop; yybottom++)
977 {
978 int yybot = *yybottom;
979 YYFPRINTF (stderr, " %d", yybot);
980 }
981 YYFPRINTF (stderr, "\n");
982 }
984 # define YY_STACK_PRINT(Bottom, Top) \
985 do { \
986 if (yydebug) \
987 yy_stack_print ((Bottom), (Top)); \
988 } while (0)
991 /*------------------------------------------------.
992 | Report that the YYRULE is going to be reduced. |
993 `------------------------------------------------*/
995 static void
996 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
997 int yyrule)
998 {
999 int yylno = yyrline[yyrule];
1000 int yynrhs = yyr2[yyrule];
1001 int yyi;
1002 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1003 yyrule - 1, yylno);
1004 /* The symbols being reduced. */
1005 for (yyi = 0; yyi < yynrhs; yyi++)
1006 {
1007 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1008 yy_symbol_print (stderr,
1009 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1010 &yyvsp[(yyi + 1) - (yynrhs)]);
1011 YYFPRINTF (stderr, "\n");
1012 }
1013 }
1015 # define YY_REDUCE_PRINT(Rule) \
1016 do { \
1017 if (yydebug) \
1018 yy_reduce_print (yyssp, yyvsp, Rule); \
1019 } while (0)
1021 /* Nonzero means print parse trace. It is left uninitialized so that
1022 multiple parsers can coexist. */
1023 int yydebug;
1024 #else /* !YYDEBUG */
1025 # define YYDPRINTF(Args) ((void) 0)
1026 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1027 # define YY_STACK_PRINT(Bottom, Top)
1028 # define YY_REDUCE_PRINT(Rule)
1029 #endif /* !YYDEBUG */
1032 /* YYINITDEPTH -- initial size of the parser's stacks. */
1033 #ifndef YYINITDEPTH
1034 # define YYINITDEPTH 200
1035 #endif
1037 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1038 if the built-in stack extension method is used).
1040 Do not make this value too large; the results are undefined if
1041 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1042 evaluated with infinite-precision integer arithmetic. */
1044 #ifndef YYMAXDEPTH
1045 # define YYMAXDEPTH 10000
1046 #endif
1053 /*-----------------------------------------------.
1054 | Release the memory associated to this symbol. |
1055 `-----------------------------------------------*/
1057 static void
1058 yydestruct (const char *yymsg,
1059 yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1060 {
1061 YY_USE (yyvaluep);
1062 if (!yymsg)
1063 yymsg = "Deleting";
1064 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1066 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1067 switch (yykind)
1068 {
1069 case YYSYMBOL_choice_entry: /* choice_entry */
1070 {
1071 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1072 ((*yyvaluep).menu)->file->name, ((*yyvaluep).menu)->lineno);
1073 if (current_menu == ((*yyvaluep).menu))
1074 menu_end_menu();
1075 }
1076 break;
1078 case YYSYMBOL_if_entry: /* if_entry */
1079 {
1080 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1081 ((*yyvaluep).menu)->file->name, ((*yyvaluep).menu)->lineno);
1082 if (current_menu == ((*yyvaluep).menu))
1083 menu_end_menu();
1084 }
1085 break;
1087 case YYSYMBOL_menu_entry: /* menu_entry */
1088 {
1089 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
1090 ((*yyvaluep).menu)->file->name, ((*yyvaluep).menu)->lineno);
1091 if (current_menu == ((*yyvaluep).menu))
1092 menu_end_menu();
1093 }
1094 break;
1096 default:
1097 break;
1098 }
1099 YY_IGNORE_MAYBE_UNINITIALIZED_END
1100 }
1103 /* Lookahead token kind. */
1104 int yychar;
1106 /* The semantic value of the lookahead symbol. */
1107 YYSTYPE yylval;
1108 /* Number of syntax errors so far. */
1109 int yynerrs;
1114 /*----------.
1115 | yyparse. |
1116 `----------*/
1118 int
1119 yyparse (void)
1120 {
1121 yy_state_fast_t yystate = 0;
1122 /* Number of tokens to shift before error messages enabled. */
1123 int yyerrstatus = 0;
1125 /* Refer to the stacks through separate pointers, to allow yyoverflow
1126 to reallocate them elsewhere. */
1128 /* Their size. */
1129 YYPTRDIFF_T yystacksize = YYINITDEPTH;
1131 /* The state stack: array, bottom, top. */
1132 yy_state_t yyssa[YYINITDEPTH];
1133 yy_state_t *yyss = yyssa;
1134 yy_state_t *yyssp = yyss;
1136 /* The semantic value stack: array, bottom, top. */
1137 YYSTYPE yyvsa[YYINITDEPTH];
1138 YYSTYPE *yyvs = yyvsa;
1139 YYSTYPE *yyvsp = yyvs;
1141 int yyn;
1142 /* The return value of yyparse. */
1143 int yyresult;
1144 /* Lookahead symbol kind. */
1145 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1146 /* The variables used to return semantic value and location from the
1147 action routines. */
1148 YYSTYPE yyval;
1152 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1154 /* The number of symbols on the RHS of the reduced rule.
1155 Keep to zero when no symbol should be popped. */
1156 int yylen = 0;
1158 YYDPRINTF ((stderr, "Starting parse\n"));
1160 yychar = YYEMPTY; /* Cause a token to be read. */
1161 goto yysetstate;
1164 /*------------------------------------------------------------.
1165 | yynewstate -- push a new state, which is found in yystate. |
1166 `------------------------------------------------------------*/
1167 yynewstate:
1168 /* In all cases, when you get here, the value and location stacks
1169 have just been pushed. So pushing a state here evens the stacks. */
1170 yyssp++;
1173 /*--------------------------------------------------------------------.
1174 | yysetstate -- set current state (the top of the stack) to yystate. |
1175 `--------------------------------------------------------------------*/
1176 yysetstate:
1177 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1178 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1179 YY_IGNORE_USELESS_CAST_BEGIN
1180 *yyssp = YY_CAST (yy_state_t, yystate);
1181 YY_IGNORE_USELESS_CAST_END
1182 YY_STACK_PRINT (yyss, yyssp);
1184 if (yyss + yystacksize - 1 <= yyssp)
1185 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1186 goto yyexhaustedlab;
1187 #else
1188 {
1189 /* Get the current used size of the three stacks, in elements. */
1190 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1192 # if defined yyoverflow
1193 {
1194 /* Give user a chance to reallocate the stack. Use copies of
1195 these so that the &'s don't force the real ones into
1196 memory. */
1197 yy_state_t *yyss1 = yyss;
1198 YYSTYPE *yyvs1 = yyvs;
1200 /* Each stack pointer address is followed by the size of the
1201 data in use in that stack, in bytes. This used to be a
1202 conditional around just the two extra args, but that might
1203 be undefined if yyoverflow is a macro. */
1204 yyoverflow (YY_("memory exhausted"),
1205 &yyss1, yysize * YYSIZEOF (*yyssp),
1206 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1207 &yystacksize);
1208 yyss = yyss1;
1209 yyvs = yyvs1;
1210 }
1211 # else /* defined YYSTACK_RELOCATE */
1212 /* Extend the stack our own way. */
1213 if (YYMAXDEPTH <= yystacksize)
1214 goto yyexhaustedlab;
1215 yystacksize *= 2;
1216 if (YYMAXDEPTH < yystacksize)
1217 yystacksize = YYMAXDEPTH;
1219 {
1220 yy_state_t *yyss1 = yyss;
1221 union yyalloc *yyptr =
1222 YY_CAST (union yyalloc *,
1223 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1224 if (! yyptr)
1225 goto yyexhaustedlab;
1226 YYSTACK_RELOCATE (yyss_alloc, yyss);
1227 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1228 # undef YYSTACK_RELOCATE
1229 if (yyss1 != yyssa)
1230 YYSTACK_FREE (yyss1);
1231 }
1232 # endif
1234 yyssp = yyss + yysize - 1;
1235 yyvsp = yyvs + yysize - 1;
1237 YY_IGNORE_USELESS_CAST_BEGIN
1238 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1239 YY_CAST (long, yystacksize)));
1240 YY_IGNORE_USELESS_CAST_END
1242 if (yyss + yystacksize - 1 <= yyssp)
1243 YYABORT;
1244 }
1245 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1247 if (yystate == YYFINAL)
1248 YYACCEPT;
1250 goto yybackup;
1253 /*-----------.
1254 | yybackup. |
1255 `-----------*/
1256 yybackup:
1257 /* Do appropriate processing given the current state. Read a
1258 lookahead token if we need one and don't already have one. */
1260 /* First try to decide what to do without reference to lookahead token. */
1261 yyn = yypact[yystate];
1262 if (yypact_value_is_default (yyn))
1263 goto yydefault;
1265 /* Not known => get a lookahead token if don't already have one. */
1267 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1268 if (yychar == YYEMPTY)
1269 {
1270 YYDPRINTF ((stderr, "Reading a token\n"));
1271 yychar = yylex ();
1272 }
1274 if (yychar <= YYEOF)
1275 {
1276 yychar = YYEOF;
1277 yytoken = YYSYMBOL_YYEOF;
1278 YYDPRINTF ((stderr, "Now at end of input.\n"));
1279 }
1280 else if (yychar == YYerror)
1281 {
1282 /* The scanner already issued an error message, process directly
1283 to error recovery. But do not keep the error token as
1284 lookahead, it is too special and may lead us to an endless
1285 loop in error recovery. */
1286 yychar = YYUNDEF;
1287 yytoken = YYSYMBOL_YYerror;
1288 goto yyerrlab1;
1289 }
1290 else
1291 {
1292 yytoken = YYTRANSLATE (yychar);
1293 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1294 }
1296 /* If the proper action on seeing token YYTOKEN is to reduce or to
1297 detect an error, take that action. */
1298 yyn += yytoken;
1299 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1300 goto yydefault;
1301 yyn = yytable[yyn];
1302 if (yyn <= 0)
1303 {
1304 if (yytable_value_is_error (yyn))
1305 goto yyerrlab;
1306 yyn = -yyn;
1307 goto yyreduce;
1308 }
1310 /* Count tokens shifted since error; after three, turn off error
1311 status. */
1312 if (yyerrstatus)
1313 yyerrstatus--;
1315 /* Shift the lookahead token. */
1316 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1317 yystate = yyn;
1318 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1319 *++yyvsp = yylval;
1320 YY_IGNORE_MAYBE_UNINITIALIZED_END
1322 /* Discard the shifted token. */
1323 yychar = YYEMPTY;
1324 goto yynewstate;
1327 /*-----------------------------------------------------------.
1328 | yydefault -- do the default action for the current state. |
1329 `-----------------------------------------------------------*/
1330 yydefault:
1331 yyn = yydefact[yystate];
1332 if (yyn == 0)
1333 goto yyerrlab;
1334 goto yyreduce;
1337 /*-----------------------------.
1338 | yyreduce -- do a reduction. |
1339 `-----------------------------*/
1340 yyreduce:
1341 /* yyn is the number of a rule to reduce with. */
1342 yylen = yyr2[yyn];
1344 /* If YYLEN is nonzero, implement the default value of the action:
1345 '$$ = $1'.
1347 Otherwise, the following line sets YYVAL to garbage.
1348 This behavior is undocumented and Bison
1349 users should not rely upon it. Assigning to YYVAL
1350 unconditionally makes the parser a bit smaller, and it avoids a
1351 GCC warning that YYVAL may be used uninitialized. */
1352 yyval = yyvsp[1-yylen];
1355 YY_REDUCE_PRINT (yyn);
1356 switch (yyn)
1357 {
1358 case 4: /* mainmenu_stmt: T_MAINMENU T_WORD_QUOTE T_EOL */
1359 {
1360 menu_add_prompt(P_MENU, (yyvsp[-1].string), NULL);
1361 }
1362 break;
1364 case 14: /* stmt_list: stmt_list T_WORD error T_EOL */
1365 { zconf_error("unknown statement \"%s\"", (yyvsp[-2].string)); }
1366 break;
1368 case 15: /* stmt_list: stmt_list error T_EOL */
1369 { zconf_error("invalid statement"); }
1370 break;
1372 case 21: /* stmt_list_in_choice: stmt_list_in_choice error T_EOL */
1373 { zconf_error("invalid statement"); }
1374 break;
1376 case 22: /* config_entry_start: T_CONFIG nonconst_symbol T_EOL */
1377 {
1378 (yyvsp[-1].symbol)->flags |= SYMBOL_OPTIONAL;
1379 menu_add_entry((yyvsp[-1].symbol));
1380 printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].symbol)->name);
1381 }
1382 break;
1384 case 23: /* config_stmt: config_entry_start config_option_list */
1385 {
1386 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1387 }
1388 break;
1390 case 24: /* menuconfig_entry_start: T_MENUCONFIG nonconst_symbol T_EOL */
1391 {
1392 (yyvsp[-1].symbol)->flags |= SYMBOL_OPTIONAL;
1393 menu_add_entry((yyvsp[-1].symbol));
1394 printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].symbol)->name);
1395 }
1396 break;
1398 case 25: /* menuconfig_stmt: menuconfig_entry_start config_option_list */
1399 {
1400 if (current_entry->prompt)
1401 current_entry->prompt->type = P_MENU;
1402 else
1403 zconfprint("warning: menuconfig statement without prompt");
1404 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
1405 }
1406 break;
1408 case 30: /* config_option: type prompt_stmt_opt T_EOL */
1409 {
1410 menu_set_type((yyvsp[-2].type));
1411 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1412 zconf_curname(), zconf_lineno(),
1413 (yyvsp[-2].type));
1414 }
1415 break;
1417 case 31: /* config_option: T_PROMPT T_WORD_QUOTE if_expr T_EOL */
1418 {
1419 menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
1420 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1421 }
1422 break;
1424 case 32: /* config_option: default expr if_expr T_EOL */
1425 {
1426 menu_add_expr(P_DEFAULT, (yyvsp[-2].expr), (yyvsp[-1].expr));
1427 if ((yyvsp[-3].type) != S_UNKNOWN)
1428 menu_set_type((yyvsp[-3].type));
1429 printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
1430 zconf_curname(), zconf_lineno(),
1431 (yyvsp[-3].type));
1432 }
1433 break;
1435 case 33: /* config_option: T_SELECT nonconst_symbol if_expr T_EOL */
1436 {
1437 menu_add_symbol(P_SELECT, (yyvsp[-2].symbol), (yyvsp[-1].expr));
1438 printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
1439 }
1440 break;
1442 case 34: /* config_option: T_IMPLY nonconst_symbol if_expr T_EOL */
1443 {
1444 menu_add_symbol(P_IMPLY, (yyvsp[-2].symbol), (yyvsp[-1].expr));
1445 printd(DEBUG_PARSE, "%s:%d:imply\n", zconf_curname(), zconf_lineno());
1446 }
1447 break;
1449 case 35: /* config_option: T_RANGE symbol symbol if_expr T_EOL */
1450 {
1451 menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[-3].symbol), (yyvsp[-2].symbol)), (yyvsp[-1].expr));
1452 printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
1453 }
1454 break;
1456 case 36: /* config_option: T_MODULES T_EOL */
1457 {
1458 if (modules_sym)
1459 zconf_error("symbol '%s' redefines option 'modules' already defined by symbol '%s'",
1460 current_entry->sym->name, modules_sym->name);
1461 modules_sym = current_entry->sym;
1462 }
1463 break;
1465 case 37: /* choice: T_CHOICE word_opt T_EOL */
1466 {
1467 struct symbol *sym = sym_lookup((yyvsp[-1].string), SYMBOL_CHOICE);
1468 sym->flags |= SYMBOL_NO_WRITE;
1469 menu_add_entry(sym);
1470 menu_add_expr(P_CHOICE, NULL, NULL);
1471 free((yyvsp[-1].string));
1472 printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
1473 }
1474 break;
1476 case 38: /* choice_entry: choice choice_option_list */
1477 {
1478 (yyval.menu) = menu_add_menu();
1479 }
1480 break;
1482 case 39: /* choice_end: end */
1483 {
1484 if (zconf_endtoken((yyvsp[0].string), "choice")) {
1485 menu_end_menu();
1486 printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
1487 }
1488 }
1489 break;
1491 case 45: /* choice_option: T_PROMPT T_WORD_QUOTE if_expr T_EOL */
1492 {
1493 menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
1494 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
1495 }
1496 break;
1498 case 46: /* choice_option: logic_type prompt_stmt_opt T_EOL */
1499 {
1500 menu_set_type((yyvsp[-2].type));
1501 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1502 zconf_curname(), zconf_lineno(), (yyvsp[-2].type));
1503 }
1504 break;
1506 case 47: /* choice_option: T_OPTIONAL T_EOL */
1507 {
1508 current_entry->sym->flags |= SYMBOL_OPTIONAL;
1509 printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
1510 }
1511 break;
1513 case 48: /* choice_option: T_DEFAULT nonconst_symbol if_expr T_EOL */
1514 {
1515 menu_add_symbol(P_DEFAULT, (yyvsp[-2].symbol), (yyvsp[-1].expr));
1516 printd(DEBUG_PARSE, "%s:%d:default\n",
1517 zconf_curname(), zconf_lineno());
1518 }
1519 break;
1521 case 50: /* type: T_INT */
1522 { (yyval.type) = S_INT; }
1523 break;
1525 case 51: /* type: T_HEX */
1526 { (yyval.type) = S_HEX; }
1527 break;
1529 case 52: /* type: T_STRING */
1530 { (yyval.type) = S_STRING; }
1531 break;
1533 case 53: /* logic_type: T_BOOL */
1534 { (yyval.type) = S_BOOLEAN; }
1535 break;
1537 case 54: /* logic_type: T_TRISTATE */
1538 { (yyval.type) = S_TRISTATE; }
1539 break;
1541 case 55: /* default: T_DEFAULT */
1542 { (yyval.type) = S_UNKNOWN; }
1543 break;
1545 case 56: /* default: T_DEF_BOOL */
1546 { (yyval.type) = S_BOOLEAN; }
1547 break;
1549 case 57: /* default: T_DEF_TRISTATE */
1550 { (yyval.type) = S_TRISTATE; }
1551 break;
1553 case 58: /* if_entry: T_IF expr T_EOL */
1554 {
1555 printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
1556 menu_add_entry(NULL);
1557 menu_add_dep((yyvsp[-1].expr));
1558 (yyval.menu) = menu_add_menu();
1559 }
1560 break;
1562 case 59: /* if_end: end */
1563 {
1564 if (zconf_endtoken((yyvsp[0].string), "if")) {
1565 menu_end_menu();
1566 printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
1567 }
1568 }
1569 break;
1571 case 62: /* menu: T_MENU T_WORD_QUOTE T_EOL */
1572 {
1573 menu_add_entry(NULL);
1574 menu_add_prompt(P_MENU, (yyvsp[-1].string), NULL);
1575 printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
1576 }
1577 break;
1579 case 63: /* menu_entry: menu menu_option_list */
1580 {
1581 (yyval.menu) = menu_add_menu();
1582 }
1583 break;
1585 case 64: /* menu_end: end */
1586 {
1587 if (zconf_endtoken((yyvsp[0].string), "menu")) {
1588 menu_end_menu();
1589 printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
1590 }
1591 }
1592 break;
1594 case 69: /* source_stmt: T_SOURCE T_WORD_QUOTE T_EOL */
1595 {
1596 printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
1597 zconf_nextfiles((yyvsp[-1].string));
1598 free((yyvsp[-1].string));
1599 }
1600 break;
1602 case 70: /* comment: T_COMMENT T_WORD_QUOTE T_EOL */
1603 {
1604 menu_add_entry(NULL);
1605 menu_add_prompt(P_COMMENT, (yyvsp[-1].string), NULL);
1606 printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
1607 }
1608 break;
1610 case 74: /* help_start: T_HELP T_EOL */
1611 {
1612 printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
1613 zconf_starthelp();
1614 }
1615 break;
1617 case 75: /* help: help_start T_HELPTEXT */
1618 {
1619 if (current_entry->help) {
1620 free(current_entry->help);
1621 zconfprint("warning: '%s' defined with more than one help text -- only the last one will be used",
1622 current_entry->sym->name ?: "<choice>");
1623 }
1625 /* Is the help text empty or all whitespace? */
1626 if ((yyvsp[0].string)[strspn((yyvsp[0].string), " \f\n\r\t\v")] == '\0')
1627 zconfprint("warning: '%s' defined with blank help text",
1628 current_entry->sym->name ?: "<choice>");
1630 current_entry->help = (yyvsp[0].string);
1631 }
1632 break;
1634 case 76: /* depends: T_DEPENDS T_ON expr T_EOL */
1635 {
1636 menu_add_dep((yyvsp[-1].expr));
1637 printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
1638 }
1639 break;
1641 case 77: /* visible: T_VISIBLE if_expr T_EOL */
1642 {
1643 menu_add_visibility((yyvsp[-1].expr));
1644 }
1645 break;
1647 case 79: /* prompt_stmt_opt: T_WORD_QUOTE if_expr */
1648 {
1649 menu_add_prompt(P_PROMPT, (yyvsp[-1].string), (yyvsp[0].expr));
1650 }
1651 break;
1653 case 80: /* end: T_ENDMENU T_EOL */
1654 { (yyval.string) = "menu"; }
1655 break;
1657 case 81: /* end: T_ENDCHOICE T_EOL */
1658 { (yyval.string) = "choice"; }
1659 break;
1661 case 82: /* end: T_ENDIF T_EOL */
1662 { (yyval.string) = "if"; }
1663 break;
1665 case 83: /* if_expr: %empty */
1666 { (yyval.expr) = NULL; }
1667 break;
1669 case 84: /* if_expr: T_IF expr */
1670 { (yyval.expr) = (yyvsp[0].expr); }
1671 break;
1673 case 85: /* expr: symbol */
1674 { (yyval.expr) = expr_alloc_symbol((yyvsp[0].symbol)); }
1675 break;
1677 case 86: /* expr: symbol T_LESS symbol */
1678 { (yyval.expr) = expr_alloc_comp(E_LTH, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1679 break;
1681 case 87: /* expr: symbol T_LESS_EQUAL symbol */
1682 { (yyval.expr) = expr_alloc_comp(E_LEQ, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1683 break;
1685 case 88: /* expr: symbol T_GREATER symbol */
1686 { (yyval.expr) = expr_alloc_comp(E_GTH, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1687 break;
1689 case 89: /* expr: symbol T_GREATER_EQUAL symbol */
1690 { (yyval.expr) = expr_alloc_comp(E_GEQ, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1691 break;
1693 case 90: /* expr: symbol T_EQUAL symbol */
1694 { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1695 break;
1697 case 91: /* expr: symbol T_UNEQUAL symbol */
1698 { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1699 break;
1701 case 92: /* expr: T_OPEN_PAREN expr T_CLOSE_PAREN */
1702 { (yyval.expr) = (yyvsp[-1].expr); }
1703 break;
1705 case 93: /* expr: T_NOT expr */
1706 { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[0].expr)); }
1707 break;
1709 case 94: /* expr: expr T_OR expr */
1710 { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
1711 break;
1713 case 95: /* expr: expr T_AND expr */
1714 { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
1715 break;
1717 case 96: /* nonconst_symbol: T_WORD */
1718 { (yyval.symbol) = sym_lookup((yyvsp[0].string), 0); free((yyvsp[0].string)); }
1719 break;
1721 case 98: /* symbol: T_WORD_QUOTE */
1722 { (yyval.symbol) = sym_lookup((yyvsp[0].string), SYMBOL_CONST); free((yyvsp[0].string)); }
1723 break;
1725 case 99: /* word_opt: %empty */
1726 { (yyval.string) = NULL; }
1727 break;
1729 case 101: /* assignment_stmt: T_WORD assign_op assign_val T_EOL */
1730 { variable_add((yyvsp[-3].string), (yyvsp[-1].string), (yyvsp[-2].flavor)); free((yyvsp[-3].string)); free((yyvsp[-1].string)); }
1731 break;
1733 case 102: /* assign_op: T_EQUAL */
1734 { (yyval.flavor) = VAR_RECURSIVE; }
1735 break;
1737 case 103: /* assign_op: T_COLON_EQUAL */
1738 { (yyval.flavor) = VAR_SIMPLE; }
1739 break;
1741 case 104: /* assign_op: T_PLUS_EQUAL */
1742 { (yyval.flavor) = VAR_APPEND; }
1743 break;
1745 case 105: /* assign_val: %empty */
1746 { (yyval.string) = xstrdup(""); }
1747 break;
1751 default: break;
1752 }
1753 /* User semantic actions sometimes alter yychar, and that requires
1754 that yytoken be updated with the new translation. We take the
1755 approach of translating immediately before every use of yytoken.
1756 One alternative is translating here after every semantic action,
1757 but that translation would be missed if the semantic action invokes
1758 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1759 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1760 incorrect destructor might then be invoked immediately. In the
1761 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1762 to an incorrect destructor call or verbose syntax error message
1763 before the lookahead is translated. */
1764 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1766 YYPOPSTACK (yylen);
1767 yylen = 0;
1769 *++yyvsp = yyval;
1771 /* Now 'shift' the result of the reduction. Determine what state
1772 that goes to, based on the state we popped back to and the rule
1773 number reduced by. */
1774 {
1775 const int yylhs = yyr1[yyn] - YYNTOKENS;
1776 const int yyi = yypgoto[yylhs] + *yyssp;
1777 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1778 ? yytable[yyi]
1779 : yydefgoto[yylhs]);
1780 }
1782 goto yynewstate;
1785 /*--------------------------------------.
1786 | yyerrlab -- here on detecting error. |
1787 `--------------------------------------*/
1788 yyerrlab:
1789 /* Make sure we have latest lookahead translation. See comments at
1790 user semantic actions for why this is necessary. */
1791 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1792 /* If not already recovering from an error, report this error. */
1793 if (!yyerrstatus)
1794 {
1795 ++yynerrs;
1796 yyerror (YY_("syntax error"));
1797 }
1799 if (yyerrstatus == 3)
1800 {
1801 /* If just tried and failed to reuse lookahead token after an
1802 error, discard it. */
1804 if (yychar <= YYEOF)
1805 {
1806 /* Return failure if at end of input. */
1807 if (yychar == YYEOF)
1808 YYABORT;
1809 }
1810 else
1811 {
1812 yydestruct ("Error: discarding",
1813 yytoken, &yylval);
1814 yychar = YYEMPTY;
1815 }
1816 }
1818 /* Else will try to reuse lookahead token after shifting the error
1819 token. */
1820 goto yyerrlab1;
1823 /*---------------------------------------------------.
1824 | yyerrorlab -- error raised explicitly by YYERROR. |
1825 `---------------------------------------------------*/
1826 yyerrorlab:
1827 /* Pacify compilers when the user code never invokes YYERROR and the
1828 label yyerrorlab therefore never appears in user code. */
1829 if (0)
1830 YYERROR;
1832 /* Do not reclaim the symbols of the rule whose action triggered
1833 this YYERROR. */
1834 YYPOPSTACK (yylen);
1835 yylen = 0;
1836 YY_STACK_PRINT (yyss, yyssp);
1837 yystate = *yyssp;
1838 goto yyerrlab1;
1841 /*-------------------------------------------------------------.
1842 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1843 `-------------------------------------------------------------*/
1844 yyerrlab1:
1845 yyerrstatus = 3; /* Each real token shifted decrements this. */
1847 /* Pop stack until we find a state that shifts the error token. */
1848 for (;;)
1849 {
1850 yyn = yypact[yystate];
1851 if (!yypact_value_is_default (yyn))
1852 {
1853 yyn += YYSYMBOL_YYerror;
1854 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1855 {
1856 yyn = yytable[yyn];
1857 if (0 < yyn)
1858 break;
1859 }
1860 }
1862 /* Pop the current state because it cannot handle the error token. */
1863 if (yyssp == yyss)
1864 YYABORT;
1867 yydestruct ("Error: popping",
1868 YY_ACCESSING_SYMBOL (yystate), yyvsp);
1869 YYPOPSTACK (1);
1870 yystate = *yyssp;
1871 YY_STACK_PRINT (yyss, yyssp);
1872 }
1874 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1875 *++yyvsp = yylval;
1876 YY_IGNORE_MAYBE_UNINITIALIZED_END
1879 /* Shift the error token. */
1880 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1882 yystate = yyn;
1883 goto yynewstate;
1886 /*-------------------------------------.
1887 | yyacceptlab -- YYACCEPT comes here. |
1888 `-------------------------------------*/
1889 yyacceptlab:
1890 yyresult = 0;
1891 goto yyreturn;
1894 /*-----------------------------------.
1895 | yyabortlab -- YYABORT comes here. |
1896 `-----------------------------------*/
1897 yyabortlab:
1898 yyresult = 1;
1899 goto yyreturn;
1902 #if !defined yyoverflow
1903 /*-------------------------------------------------.
1904 | yyexhaustedlab -- memory exhaustion comes here. |
1905 `-------------------------------------------------*/
1906 yyexhaustedlab:
1907 yyerror (YY_("memory exhausted"));
1908 yyresult = 2;
1909 goto yyreturn;
1910 #endif
1913 /*-------------------------------------------------------.
1914 | yyreturn -- parsing is finished, clean up and return. |
1915 `-------------------------------------------------------*/
1916 yyreturn:
1917 if (yychar != YYEMPTY)
1918 {
1919 /* Make sure we have latest lookahead translation. See comments at
1920 user semantic actions for why this is necessary. */
1921 yytoken = YYTRANSLATE (yychar);
1922 yydestruct ("Cleanup: discarding lookahead",
1923 yytoken, &yylval);
1924 }
1925 /* Do not reclaim the symbols of the rule whose action triggered
1926 this YYABORT or YYACCEPT. */
1927 YYPOPSTACK (yylen);
1928 YY_STACK_PRINT (yyss, yyssp);
1929 while (yyssp != yyss)
1930 {
1931 yydestruct ("Cleanup: popping",
1932 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
1933 YYPOPSTACK (1);
1934 }
1935 #ifndef yyoverflow
1936 if (yyss != yyssa)
1937 YYSTACK_FREE (yyss);
1938 #endif
1940 return yyresult;
1941 }
1945 void conf_parse(const char *name)
1946 {
1947 struct symbol *sym;
1948 int i;
1950 zconf_initscan(name);
1952 _menu_init();
1954 if (getenv("ZCONF_DEBUG"))
1955 yydebug = 1;
1956 yyparse();
1958 /* Variables are expanded in the parse phase. We can free them here. */
1959 variable_all_del();
1961 if (yynerrs)
1962 exit(1);
1963 if (!modules_sym)
1964 modules_sym = sym_find( "n" );
1966 if (!menu_has_prompt(&rootmenu)) {
1967 current_entry = &rootmenu;
1968 menu_add_prompt(P_MENU, "Main menu", NULL);
1969 }
1971 menu_finalize(&rootmenu);
1972 for_all_symbols(i, sym) {
1973 if (sym_check_deps(sym))
1974 yynerrs++;
1975 }
1976 if (yynerrs)
1977 exit(1);
1978 conf_set_changed(true);
1979 }
1981 static bool zconf_endtoken(const char *tokenname,
1982 const char *expected_tokenname)
1983 {
1984 if (strcmp(tokenname, expected_tokenname)) {
1985 zconf_error("unexpected '%s' within %s block",
1986 tokenname, expected_tokenname);
1987 yynerrs++;
1988 return false;
1989 }
1990 if (current_menu->file != current_file) {
1991 zconf_error("'%s' in different file than '%s'",
1992 tokenname, expected_tokenname);
1993 fprintf(stderr, "%s:%d: location of the '%s'\n",
1994 current_menu->file->name, current_menu->lineno,
1995 expected_tokenname);
1996 yynerrs++;
1997 return false;
1998 }
1999 return true;
2000 }
2002 static void zconfprint(const char *err, ...)
2003 {
2004 va_list ap;
2006 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
2007 va_start(ap, err);
2008 vfprintf(stderr, err, ap);
2009 va_end(ap);
2010 fprintf(stderr, "\n");
2011 }
2013 static void zconf_error(const char *err, ...)
2014 {
2015 va_list ap;
2017 yynerrs++;
2018 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
2019 va_start(ap, err);
2020 vfprintf(stderr, err, ap);
2021 va_end(ap);
2022 fprintf(stderr, "\n");
2023 }
2025 static void yyerror(const char *err)
2026 {
2027 fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
2028 }
2030 static void print_quoted_string(FILE *out, const char *str)
2031 {
2032 const char *p;
2033 int len;
2035 putc('"', out);
2036 while ((p = strchr(str, '"'))) {
2037 len = p - str;
2038 if (len)
2039 fprintf(out, "%.*s", len, str);
2040 fputs("\\\"", out);
2041 str = p + 1;
2042 }
2043 fputs(str, out);
2044 putc('"', out);
2045 }
2047 static void print_symbol(FILE *out, struct menu *menu)
2048 {
2049 struct symbol *sym = menu->sym;
2050 struct property *prop;
2052 if (sym_is_choice(sym))
2053 fprintf(out, "\nchoice\n");
2054 else
2055 fprintf(out, "\nconfig %s\n", sym->name);
2056 switch (sym->type) {
2057 case S_BOOLEAN:
2058 fputs(" bool\n", out);
2059 break;
2060 case S_TRISTATE:
2061 fputs(" tristate\n", out);
2062 break;
2063 case S_STRING:
2064 fputs(" string\n", out);
2065 break;
2066 case S_INT:
2067 fputs(" integer\n", out);
2068 break;
2069 case S_HEX:
2070 fputs(" hex\n", out);
2071 break;
2072 default:
2073 fputs(" ???\n", out);
2074 break;
2075 }
2076 for (prop = sym->prop; prop; prop = prop->next) {
2077 if (prop->menu != menu)
2078 continue;
2079 switch (prop->type) {
2080 case P_PROMPT:
2081 fputs(" prompt ", out);
2082 print_quoted_string(out, prop->text);
2083 if (!expr_is_yes(prop->visible.expr)) {
2084 fputs(" if ", out);
2085 expr_fprint(prop->visible.expr, out);
2086 }
2087 fputc('\n', out);
2088 break;
2089 case P_DEFAULT:
2090 fputs( " default ", out);
2091 expr_fprint(prop->expr, out);
2092 if (!expr_is_yes(prop->visible.expr)) {
2093 fputs(" if ", out);
2094 expr_fprint(prop->visible.expr, out);
2095 }
2096 fputc('\n', out);
2097 break;
2098 case P_CHOICE:
2099 fputs(" #choice value\n", out);
2100 break;
2101 case P_SELECT:
2102 fputs( " select ", out);
2103 expr_fprint(prop->expr, out);
2104 fputc('\n', out);
2105 break;
2106 case P_IMPLY:
2107 fputs( " imply ", out);
2108 expr_fprint(prop->expr, out);
2109 fputc('\n', out);
2110 break;
2111 case P_RANGE:
2112 fputs( " range ", out);
2113 expr_fprint(prop->expr, out);
2114 fputc('\n', out);
2115 break;
2116 case P_MENU:
2117 fputs( " menu ", out);
2118 print_quoted_string(out, prop->text);
2119 fputc('\n', out);
2120 break;
2121 case P_SYMBOL:
2122 fputs( " symbol ", out);
2123 fprintf(out, "%s\n", prop->menu->sym->name);
2124 break;
2125 default:
2126 fprintf(out, " unknown prop %d!\n", prop->type);
2127 break;
2128 }
2129 }
2130 if (menu->help) {
2131 int len = strlen(menu->help);
2132 while (menu->help[--len] == '\n')
2133 menu->help[len] = 0;
2134 fprintf(out, " help\n%s\n", menu->help);
2135 }
2136 }
2138 void zconfdump(FILE *out)
2139 {
2140 struct property *prop;
2141 struct symbol *sym;
2142 struct menu *menu;
2144 menu = rootmenu.list;
2145 while (menu) {
2146 if ((sym = menu->sym))
2147 print_symbol(out, menu);
2148 else if ((prop = menu->prompt)) {
2149 switch (prop->type) {
2150 case P_COMMENT:
2151 fputs("\ncomment ", out);
2152 print_quoted_string(out, prop->text);
2153 fputs("\n", out);
2154 break;
2155 case P_MENU:
2156 fputs("\nmenu ", out);
2157 print_quoted_string(out, prop->text);
2158 fputs("\n", out);
2159 break;
2160 default:
2161 ;
2162 }
2163 if (!expr_is_yes(prop->visible.expr)) {
2164 fputs(" depends ", out);
2165 expr_fprint(prop->visible.expr, out);
2166 fputc('\n', out);
2167 }
2168 }
2170 if (menu->list)
2171 menu = menu->list;
2172 else if (menu->next)
2173 menu = menu->next;
2174 else while ((menu = menu->parent)) {
2175 if (menu->prompt && menu->prompt->type == P_MENU)
2176 fputs("\nendmenu\n", out);
2177 if (menu->next) {
2178 menu = menu->next;
2179 break;
2180 }
2181 }
2182 }
2183 }