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