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