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