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