Root/scripts/config/zconf.tab.c_shipped

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

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive