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