blob: 65b7515a577c537d040b5868d33d46d2e37091df [file] [log] [blame]
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001/* A Bison parser, made by GNU Bison 3.0.4. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002
Yann E. MORINc80de522013-09-03 17:49:04 +02003/* Bison implementation for Yacc-like parsers in C
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05004
5 Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6
Josh Triplett1456edb2009-10-15 11:03:20 -07007 This program is free software: you can redistribute it and/or modify
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 it under the terms of the GNU General Public License as published by
Josh Triplett1456edb2009-10-15 11:03:20 -07009 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -050011
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -050016
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 You should have received a copy of the GNU General Public License
Josh Triplett1456edb2009-10-15 11:03:20 -070018 along with this program. If not, see <http://www.gnu.org/licenses/>. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
Sam Ravnborg14f31562007-09-26 20:15:39 +020020/* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -050029
Sam Ravnborg14f31562007-09-26 20:15:39 +020030 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33/* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36/* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43/* Identify Bison output. */
44#define YYBISON 1
45
Roman Zippelf6a88aa2006-06-08 22:12:44 -070046/* Bison version. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -050047#define YYBISON_VERSION "3.0.4"
Roman Zippelf6a88aa2006-06-08 22:12:44 -070048
Linus Torvalds1da177e2005-04-16 15:20:36 -070049/* Skeleton name. */
50#define YYSKELETON_NAME "yacc.c"
51
52/* Pure parsers. */
53#define YYPURE 0
54
Josh Triplett1456edb2009-10-15 11:03:20 -070055/* Push parsers. */
56#define YYPUSH 0
57
58/* Pull parsers. */
59#define YYPULL 1
60
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Roman Zippel7a884882005-11-08 21:34:51 -080062/* Substitute the variable and function names. */
Josh Triplett1456edb2009-10-15 11:03:20 -070063#define yyparse zconfparse
64#define yylex zconflex
65#define yyerror zconferror
Josh Triplett1456edb2009-10-15 11:03:20 -070066#define yydebug zconfdebug
67#define yynerrs zconfnerrs
68
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -050069#define yylval zconflval
70#define yychar zconfchar
Josh Triplett1456edb2009-10-15 11:03:20 -070071
72/* Copy the first part of user declarations. */
73
74
75/*
76 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
77 * Released under the terms of the GNU GPL v2.0.
78 */
79
80#include <ctype.h>
81#include <stdarg.h>
82#include <stdio.h>
83#include <stdlib.h>
84#include <string.h>
85#include <stdbool.h>
86
Josh Triplett1456edb2009-10-15 11:03:20 -070087#include "lkc.h"
88
89#define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
90
91#define PRINTD 0x0001
92#define DEBUG_PARSE 0x0002
93
94int cdebug = PRINTD;
95
96extern int zconflex(void);
97static void zconfprint(const char *err, ...);
98static void zconf_error(const char *err, ...);
99static void zconferror(const char *err);
Arnaud Lacombe2f76b352011-05-23 01:08:19 -0400100static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken);
Josh Triplett1456edb2009-10-15 11:03:20 -0700101
Andi Kleene66f25d2010-01-13 17:02:44 +0100102struct symbol *symbol_hash[SYMBOL_HASHSIZE];
Josh Triplett1456edb2009-10-15 11:03:20 -0700103
104static struct menu *current_menu, *current_entry;
105
Josh Triplett1456edb2009-10-15 11:03:20 -0700106
107
108
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500109# ifndef YY_NULLPTR
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100110# if defined __cplusplus && 201103L <= __cplusplus
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500111# define YY_NULLPTR nullptr
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100112# else
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500113# define YY_NULLPTR 0
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100114# endif
115# endif
116
Josh Triplett1456edb2009-10-15 11:03:20 -0700117/* Enabling verbose error messages. */
118#ifdef YYERROR_VERBOSE
119# undef YYERROR_VERBOSE
120# define YYERROR_VERBOSE 1
121#else
122# define YYERROR_VERBOSE 0
123#endif
124
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500125
126/* Debug traces. */
127#ifndef YYDEBUG
128# define YYDEBUG 1
129#endif
130#if YYDEBUG
131extern int zconfdebug;
Josh Triplett1456edb2009-10-15 11:03:20 -0700132#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500134/* Token type. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135#ifndef YYTOKENTYPE
136# define YYTOKENTYPE
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500137 enum yytokentype
138 {
139 T_MAINMENU = 258,
140 T_MENU = 259,
141 T_ENDMENU = 260,
142 T_SOURCE = 261,
143 T_CHOICE = 262,
144 T_ENDCHOICE = 263,
145 T_COMMENT = 264,
146 T_CONFIG = 265,
147 T_MENUCONFIG = 266,
148 T_HELP = 267,
149 T_HELPTEXT = 268,
150 T_IF = 269,
151 T_ENDIF = 270,
152 T_DEPENDS = 271,
153 T_OPTIONAL = 272,
154 T_PROMPT = 273,
155 T_TYPE = 274,
156 T_DEFAULT = 275,
157 T_SELECT = 276,
158 T_IMPLY = 277,
159 T_RANGE = 278,
160 T_VISIBLE = 279,
161 T_OPTION = 280,
162 T_ON = 281,
163 T_WORD = 282,
164 T_WORD_QUOTE = 283,
165 T_UNEQUAL = 284,
166 T_LESS = 285,
167 T_LESS_EQUAL = 286,
168 T_GREATER = 287,
169 T_GREATER_EQUAL = 288,
170 T_CLOSE_PAREN = 289,
171 T_OPEN_PAREN = 290,
172 T_EOL = 291,
173 T_OR = 292,
174 T_AND = 293,
175 T_EQUAL = 294,
176 T_NOT = 295
177 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500180/* Value type. */
Sam Ravnborg14f31562007-09-26 20:15:39 +0200181#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500182
183union YYSTYPE
Sam Ravnborg14f31562007-09-26 20:15:39 +0200184{
Josh Triplett1456edb2009-10-15 11:03:20 -0700185
186
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 char *string;
Roman Zippela02f0572005-11-08 21:34:53 -0800188 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 struct symbol *symbol;
190 struct expr *expr;
191 struct menu *menu;
Arnaud Lacombe2f76b352011-05-23 01:08:19 -0400192 const struct kconf_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Josh Triplett1456edb2009-10-15 11:03:20 -0700194
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500195};
Josh Triplett1456edb2009-10-15 11:03:20 -0700196
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500197typedef union YYSTYPE YYSTYPE;
Josh Triplett1456edb2009-10-15 11:03:20 -0700198# define YYSTYPE_IS_TRIVIAL 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199# define YYSTYPE_IS_DECLARED 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200#endif
201
202
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500203extern YYSTYPE zconflval;
204
205int zconfparse (void);
206
207
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209/* Copy the second part of user declarations. */
210
211
Josh Triplett1456edb2009-10-15 11:03:20 -0700212/* Include zconf.hash.c here so it can see the token constants. */
213#include "zconf.hash.c"
214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216
Sam Ravnborg14f31562007-09-26 20:15:39 +0200217#ifdef short
218# undef short
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700219#endif
Sam Ravnborg14f31562007-09-26 20:15:39 +0200220
221#ifdef YYTYPE_UINT8
222typedef YYTYPE_UINT8 yytype_uint8;
223#else
224typedef unsigned char yytype_uint8;
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700225#endif
Sam Ravnborg14f31562007-09-26 20:15:39 +0200226
227#ifdef YYTYPE_INT8
228typedef YYTYPE_INT8 yytype_int8;
Sam Ravnborg14f31562007-09-26 20:15:39 +0200229#else
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500230typedef signed char yytype_int8;
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700231#endif
Sam Ravnborg14f31562007-09-26 20:15:39 +0200232
233#ifdef YYTYPE_UINT16
234typedef YYTYPE_UINT16 yytype_uint16;
235#else
236typedef unsigned short int yytype_uint16;
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700237#endif
238
Sam Ravnborg14f31562007-09-26 20:15:39 +0200239#ifdef YYTYPE_INT16
240typedef YYTYPE_INT16 yytype_int16;
241#else
242typedef short int yytype_int16;
243#endif
244
245#ifndef YYSIZE_T
246# ifdef __SIZE_TYPE__
247# define YYSIZE_T __SIZE_TYPE__
248# elif defined size_t
249# define YYSIZE_T size_t
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500250# elif ! defined YYSIZE_T
Sam Ravnborg14f31562007-09-26 20:15:39 +0200251# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
252# define YYSIZE_T size_t
253# else
254# define YYSIZE_T unsigned int
255# endif
256#endif
257
258#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
259
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700260#ifndef YY_
Arnaud Lacombe2f76b352011-05-23 01:08:19 -0400261# if defined YYENABLE_NLS && YYENABLE_NLS
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700262# if ENABLE_NLS
263# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500264# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700265# endif
266# endif
267# ifndef YY_
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500268# define YY_(Msgid) Msgid
269# endif
270#endif
271
272#ifndef YY_ATTRIBUTE
273# if (defined __GNUC__ \
274 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
275 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
276# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
277# else
278# define YY_ATTRIBUTE(Spec) /* empty */
279# endif
280#endif
281
282#ifndef YY_ATTRIBUTE_PURE
283# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
284#endif
285
286#ifndef YY_ATTRIBUTE_UNUSED
287# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
288#endif
289
290#if !defined _Noreturn \
291 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
292# if defined _MSC_VER && 1200 <= _MSC_VER
293# define _Noreturn __declspec (noreturn)
294# else
295# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700296# endif
297#endif
298
Sam Ravnborg14f31562007-09-26 20:15:39 +0200299/* Suppress unused-variable warnings by "using" E. */
300#if ! defined lint || defined __GNUC__
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500301# define YYUSE(E) ((void) (E))
Sam Ravnborg14f31562007-09-26 20:15:39 +0200302#else
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500303# define YYUSE(E) /* empty */
Sam Ravnborg14f31562007-09-26 20:15:39 +0200304#endif
305
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500306#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
307/* Suppress an incorrect diagnostic about yylval being uninitialized. */
308# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
309 _Pragma ("GCC diagnostic push") \
310 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
311 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
312# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
313 _Pragma ("GCC diagnostic pop")
Sam Ravnborg14f31562007-09-26 20:15:39 +0200314#else
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500315# define YY_INITIAL_VALUE(Value) Value
Sam Ravnborg14f31562007-09-26 20:15:39 +0200316#endif
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500317#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
318# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
319# define YY_IGNORE_MAYBE_UNINITIALIZED_END
Sam Ravnborg14f31562007-09-26 20:15:39 +0200320#endif
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500321#ifndef YY_INITIAL_VALUE
322# define YY_INITIAL_VALUE(Value) /* Nothing. */
323#endif
324
Sam Ravnborg14f31562007-09-26 20:15:39 +0200325
326#if ! defined yyoverflow || YYERROR_VERBOSE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328/* The parser invokes alloca or malloc; define the necessary symbols. */
329
Roman Zippel7a884882005-11-08 21:34:51 -0800330# ifdef YYSTACK_USE_ALLOCA
331# if YYSTACK_USE_ALLOCA
332# ifdef __GNUC__
333# define YYSTACK_ALLOC __builtin_alloca
Sam Ravnborg14f31562007-09-26 20:15:39 +0200334# elif defined __BUILTIN_VA_ARG_INCR
335# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
336# elif defined _AIX
337# define YYSTACK_ALLOC __alloca
338# elif defined _MSC_VER
339# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
340# define alloca _alloca
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341# else
Roman Zippel7a884882005-11-08 21:34:51 -0800342# define YYSTACK_ALLOC alloca
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500343# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700344# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100345 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
Yann E. MORINc80de522013-09-03 17:49:04 +0200346# ifndef EXIT_SUCCESS
347# define EXIT_SUCCESS 0
Sam Ravnborg14f31562007-09-26 20:15:39 +0200348# endif
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700349# endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350# endif
351# endif
352# endif
353
354# ifdef YYSTACK_ALLOC
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500355 /* Pacify GCC's 'empty if-body' warning. */
356# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700357# ifndef YYSTACK_ALLOC_MAXIMUM
358 /* The OS might guarantee only one guard page at the bottom of the stack,
359 and a page size can be as small as 4096 bytes. So we cannot safely
360 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
361 to allow for a few compiler-allocated temporary stack slots. */
Sam Ravnborg14f31562007-09-26 20:15:39 +0200362# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363# endif
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700364# else
Roman Zippel7a884882005-11-08 21:34:51 -0800365# define YYSTACK_ALLOC YYMALLOC
366# define YYSTACK_FREE YYFREE
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700367# ifndef YYSTACK_ALLOC_MAXIMUM
Sam Ravnborg14f31562007-09-26 20:15:39 +0200368# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700369# endif
Yann E. MORINc80de522013-09-03 17:49:04 +0200370# if (defined __cplusplus && ! defined EXIT_SUCCESS \
Sam Ravnborg14f31562007-09-26 20:15:39 +0200371 && ! ((defined YYMALLOC || defined malloc) \
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500372 && (defined YYFREE || defined free)))
Sam Ravnborg14f31562007-09-26 20:15:39 +0200373# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
Yann E. MORINc80de522013-09-03 17:49:04 +0200374# ifndef EXIT_SUCCESS
375# define EXIT_SUCCESS 0
Sam Ravnborg14f31562007-09-26 20:15:39 +0200376# endif
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700377# endif
378# ifndef YYMALLOC
379# define YYMALLOC malloc
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500380# if ! defined malloc && ! defined EXIT_SUCCESS
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700381void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
382# endif
383# endif
384# ifndef YYFREE
385# define YYFREE free
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500386# if ! defined free && ! defined EXIT_SUCCESS
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700387void free (void *); /* INFRINGES ON USER NAME SPACE */
388# endif
389# endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390# endif
Sam Ravnborg14f31562007-09-26 20:15:39 +0200391#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393
Sam Ravnborg14f31562007-09-26 20:15:39 +0200394#if (! defined yyoverflow \
395 && (! defined __cplusplus \
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500396 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398/* A type that is properly aligned for any stack member. */
399union yyalloc
400{
Josh Triplett1456edb2009-10-15 11:03:20 -0700401 yytype_int16 yyss_alloc;
402 YYSTYPE yyvs_alloc;
403};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405/* The size of the maximum gap between one aligned stack and the next. */
406# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
407
408/* The size of an array large to enough to hold all stacks, each with
409 N elements. */
410# define YYSTACK_BYTES(N) \
Sam Ravnborg14f31562007-09-26 20:15:39 +0200411 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 + YYSTACK_GAP_MAXIMUM)
413
Yann E. MORINc80de522013-09-03 17:49:04 +0200414# define YYCOPY_NEEDED 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
416/* Relocate STACK from its old location to the new one. The
417 local variables YYSIZE and YYSTACKSIZE give the old and new number of
418 elements in the stack, and YYPTR gives the new location of the
419 stack. Advance YYPTR to a properly aligned location for the next
420 stack. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500421# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
422 do \
423 { \
424 YYSIZE_T yynewbytes; \
425 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
426 Stack = &yyptr->Stack_alloc; \
427 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
428 yyptr += yynewbytes / sizeof (*yyptr); \
429 } \
430 while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
432#endif
433
Yann E. MORINc80de522013-09-03 17:49:04 +0200434#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100435/* Copy COUNT objects from SRC to DST. The source and destination do
Yann E. MORINc80de522013-09-03 17:49:04 +0200436 not overlap. */
437# ifndef YYCOPY
438# if defined __GNUC__ && 1 < __GNUC__
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100439# define YYCOPY(Dst, Src, Count) \
440 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
Yann E. MORINc80de522013-09-03 17:49:04 +0200441# else
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100442# define YYCOPY(Dst, Src, Count) \
443 do \
444 { \
445 YYSIZE_T yyi; \
446 for (yyi = 0; yyi < (Count); yyi++) \
447 (Dst)[yyi] = (Src)[yyi]; \
448 } \
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500449 while (0)
Yann E. MORINc80de522013-09-03 17:49:04 +0200450# endif
451# endif
452#endif /* !YYCOPY_NEEDED */
453
Sam Ravnborg14f31562007-09-26 20:15:39 +0200454/* YYFINAL -- State number of the termination state. */
Arnaud Lacombec0920a12010-09-10 21:23:28 -0400455#define YYFINAL 11
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456/* YYLAST -- Last index in YYTABLE. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500457#define YYLAST 301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Sam Ravnborg14f31562007-09-26 20:15:39 +0200459/* YYNTOKENS -- Number of terminals. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500460#define YYNTOKENS 41
Sam Ravnborg14f31562007-09-26 20:15:39 +0200461/* YYNNTS -- Number of nonterminals. */
Arnaud Lacombe09899c92010-11-06 18:30:24 -0300462#define YYNNTS 50
Sam Ravnborg14f31562007-09-26 20:15:39 +0200463/* YYNRULES -- Number of rules. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500464#define YYNRULES 124
465/* YYNSTATES -- Number of states. */
466#define YYNSTATES 204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500468/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
469 by yylex, with out-of-bounds checking. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470#define YYUNDEFTOK 2
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500471#define YYMAXUTOK 295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500473#define YYTRANSLATE(YYX) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
475
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500476/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
477 as returned by yylex, without out-of-bounds checking. */
Sam Ravnborg14f31562007-09-26 20:15:39 +0200478static const yytype_uint8 yytranslate[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
480 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
481 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
502 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
504 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
505 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
506 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
507 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
Arnaud Lacombe09899c92010-11-06 18:30:24 -0300508 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500509 35, 36, 37, 38, 39, 40
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510};
511
512#if YYDEBUG
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500513 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
Sam Ravnborg14f31562007-09-26 20:15:39 +0200514static const yytype_uint16 yyrline[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500516 0, 109, 109, 109, 111, 111, 113, 115, 116, 117,
517 118, 119, 120, 124, 128, 128, 128, 128, 128, 128,
518 128, 128, 128, 132, 133, 134, 135, 136, 137, 141,
519 142, 148, 156, 162, 170, 180, 182, 183, 184, 185,
520 186, 187, 190, 198, 204, 214, 220, 226, 232, 235,
521 237, 248, 249, 254, 263, 268, 276, 279, 281, 282,
522 283, 284, 285, 288, 294, 305, 311, 321, 323, 328,
523 336, 344, 347, 349, 350, 351, 356, 363, 370, 375,
524 383, 386, 388, 389, 390, 393, 401, 408, 415, 421,
525 428, 430, 431, 432, 435, 443, 445, 446, 449, 456,
526 458, 463, 464, 467, 468, 469, 473, 474, 477, 478,
527 481, 482, 483, 484, 485, 486, 487, 488, 489, 490,
528 491, 494, 495, 498, 499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529};
530#endif
531
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500532#if YYDEBUG || YYERROR_VERBOSE || 0
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700533/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
Sam Ravnborg14f31562007-09-26 20:15:39 +0200534 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535static const char *const yytname[] =
536{
Roman Zippel7a884882005-11-08 21:34:51 -0800537 "$end", "error", "$undefined", "T_MAINMENU", "T_MENU", "T_ENDMENU",
538 "T_SOURCE", "T_CHOICE", "T_ENDCHOICE", "T_COMMENT", "T_CONFIG",
539 "T_MENUCONFIG", "T_HELP", "T_HELPTEXT", "T_IF", "T_ENDIF", "T_DEPENDS",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500540 "T_OPTIONAL", "T_PROMPT", "T_TYPE", "T_DEFAULT", "T_SELECT", "T_IMPLY",
541 "T_RANGE", "T_VISIBLE", "T_OPTION", "T_ON", "T_WORD", "T_WORD_QUOTE",
542 "T_UNEQUAL", "T_LESS", "T_LESS_EQUAL", "T_GREATER", "T_GREATER_EQUAL",
Sam Ravnborg14f31562007-09-26 20:15:39 +0200543 "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_EOL", "T_OR", "T_AND", "T_EQUAL",
Arnaud Lacombec0920a12010-09-10 21:23:28 -0400544 "T_NOT", "$accept", "input", "start", "stmt_list", "option_name",
545 "common_stmt", "option_error", "config_entry_start", "config_stmt",
Roman Zippela02f0572005-11-08 21:34:53 -0800546 "menuconfig_entry_start", "menuconfig_stmt", "config_option_list",
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700547 "config_option", "symbol_option", "symbol_option_list",
548 "symbol_option_arg", "choice", "choice_entry", "choice_end",
549 "choice_stmt", "choice_option_list", "choice_option", "choice_block",
Arnaud Lacombec0920a12010-09-10 21:23:28 -0400550 "if_entry", "if_end", "if_stmt", "if_block", "mainmenu_stmt", "menu",
551 "menu_entry", "menu_end", "menu_stmt", "menu_block", "source_stmt",
552 "comment", "comment_stmt", "help_start", "help", "depends_list",
Arnaud Lacombe09899c92010-11-06 18:30:24 -0300553 "depends", "visibility_list", "visible", "prompt_stmt_opt", "prompt",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500554 "end", "nl", "if_expr", "expr", "symbol", "word_opt", YY_NULLPTR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555};
556#endif
557
558# ifdef YYPRINT
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500559/* YYTOKNUM[NUM] -- (External) token number corresponding to the
560 (internal) symbol number NUM (which must be that of a token). */
Sam Ravnborg14f31562007-09-26 20:15:39 +0200561static const yytype_uint16 yytoknum[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562{
563 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
564 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
565 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500566 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
567 295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568};
569# endif
570
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500571#define YYPACT_NINF -92
572
573#define yypact_value_is_default(Yystate) \
574 (!!((Yystate) == (-92)))
575
576#define YYTABLE_NINF -88
577
578#define yytable_value_is_error(Yytable_value) \
579 0
580
581 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
582 STATE-NUM. */
583static const yytype_int16 yypact[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584{
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500585 17, 41, -92, 15, -92, 150, -92, 19, -92, -92,
586 -13, -92, 28, 41, 38, 41, 50, 47, 41, 79,
587 82, 44, 76, -92, -92, -92, -92, -92, -92, -92,
588 -92, -92, 118, -92, 129, -92, -92, -92, -92, -92,
589 -92, -92, -92, -92, -92, -92, -92, -92, -92, -92,
590 -92, -92, 184, -92, -92, 107, -92, 111, -92, 113,
591 -92, 116, -92, 139, 140, 151, -92, -92, 44, 44,
592 142, 256, -92, 160, 173, 27, 117, 80, 51, 255,
593 -15, 255, 217, -92, -92, -92, -92, -92, -92, -8,
594 -92, 44, 44, 107, 87, 87, 87, 87, 87, 87,
595 -92, -92, 174, 176, 187, 41, 41, 44, 188, 189,
596 87, -92, 213, -92, -92, -92, -92, 206, -92, -92,
597 193, 41, 41, 203, -92, -92, -92, -92, -92, -92,
598 -92, -92, -92, -92, -92, -92, -92, 229, -92, 241,
599 -92, -92, -92, -92, -92, -92, -92, -92, -92, -92,
600 216, -92, -92, -92, -92, -92, -92, -92, -92, -92,
601 44, 229, 222, 229, 64, 229, 229, 87, 31, 231,
602 -92, -92, 229, 236, 229, 44, -92, 145, 242, -92,
603 -92, 243, 244, 245, 229, 251, -92, -92, 247, -92,
604 257, 125, -92, -92, -92, -92, -92, 260, 41, -92,
605 -92, -92, -92, -92
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606};
607
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500608 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
609 Performed when YYTABLE does not specify something else to do. Zero
610 means the default is an error. */
611static const yytype_uint8 yydefact[] =
612{
613 6, 0, 106, 0, 3, 0, 6, 6, 101, 102,
614 0, 1, 0, 0, 0, 0, 123, 0, 0, 0,
615 0, 0, 0, 14, 19, 15, 16, 21, 17, 18,
616 20, 22, 0, 23, 0, 7, 35, 26, 35, 27,
617 57, 67, 8, 72, 24, 95, 81, 9, 28, 90,
618 25, 10, 0, 107, 2, 76, 13, 0, 103, 0,
619 124, 0, 104, 0, 0, 0, 121, 122, 0, 0,
620 0, 110, 105, 0, 0, 0, 0, 0, 0, 0,
621 90, 0, 0, 77, 85, 53, 86, 31, 33, 0,
622 118, 0, 0, 69, 0, 0, 0, 0, 0, 0,
623 11, 12, 0, 0, 0, 0, 99, 0, 0, 0,
624 0, 49, 0, 41, 40, 36, 37, 0, 39, 38,
625 0, 0, 99, 0, 61, 62, 58, 60, 59, 68,
626 56, 55, 73, 75, 71, 74, 70, 108, 97, 0,
627 96, 82, 84, 80, 83, 79, 92, 93, 91, 117,
628 119, 120, 116, 111, 112, 113, 114, 115, 30, 88,
629 0, 108, 0, 108, 108, 108, 108, 0, 0, 0,
630 89, 65, 108, 0, 108, 0, 98, 0, 0, 42,
631 100, 0, 0, 0, 108, 51, 48, 29, 0, 64,
632 0, 109, 94, 43, 44, 45, 46, 0, 0, 50,
633 63, 66, 47, 52
634};
635
636 /* YYPGOTO[NTERM-NUM]. */
637static const yytype_int16 yypgoto[] =
638{
639 -92, -92, 285, 291, -92, 32, -66, -92, -92, -92,
640 -92, 261, -92, -92, -92, -92, -92, -92, -92, 1,
641 -92, -92, -92, -92, -92, -92, -92, -92, -92, -92,
642 -92, 24, -92, -92, -92, -92, -92, 221, 220, -64,
643 -92, -92, 179, -1, 67, 0, 110, -67, -91, -92
644};
645
646 /* YYDEFGOTO[NTERM-NUM]. */
647static const yytype_int16 yydefgoto[] =
648{
649 -1, 3, 4, 5, 34, 35, 114, 36, 37, 38,
650 39, 75, 115, 116, 168, 199, 40, 41, 130, 42,
651 77, 126, 78, 43, 134, 44, 79, 6, 45, 46,
652 143, 47, 81, 48, 49, 50, 117, 118, 82, 119,
653 80, 140, 162, 163, 51, 7, 176, 70, 71, 61
654};
655
656 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
657 positive, shift that token. If negative, reduce the rule whose
658 number is the opposite. If YYTABLE_NINF, syntax error. */
659static const yytype_int16 yytable[] =
660{
661 10, 89, 90, 152, 153, 154, 155, 156, 157, 137,
662 55, 125, 57, 128, 59, 11, 147, 63, 148, 167,
663 1, 138, 1, 2, 150, 151, 149, -32, 102, 91,
664 92, -32, -32, -32, -32, -32, -32, -32, -32, 103,
665 164, -32, -32, 104, -32, 105, 106, 107, 108, 109,
666 110, -32, 111, 2, 112, 53, 14, 15, 185, 17,
667 18, 19, 20, 113, 56, 21, 22, 186, 8, 9,
668 93, 66, 67, 147, 58, 148, 184, 60, 175, 68,
669 133, 102, 142, 62, 69, -54, -54, 33, -54, -54,
670 -54, -54, 103, 177, -54, -54, 104, 120, 121, 122,
671 123, 91, 92, 135, 161, 144, 64, 112, 191, 65,
672 129, 132, 72, 141, 66, 67, 124, -34, 102, 73,
673 172, -34, -34, -34, -34, -34, -34, -34, -34, 103,
674 74, -34, -34, 104, -34, 105, 106, 107, 108, 109,
675 110, -34, 111, 53, 112, 131, 136, 83, 145, 84,
676 -5, 12, 85, 113, 13, 14, 15, 16, 17, 18,
677 19, 20, 91, 92, 21, 22, 23, 24, 25, 26,
678 27, 28, 29, 30, 31, 86, 87, 32, 2, 91,
679 92, 192, 91, 92, -4, 12, 33, 88, 13, 14,
680 15, 16, 17, 18, 19, 20, 100, 203, 21, 22,
681 23, 24, 25, 26, 27, 28, 29, 30, 31, 101,
682 158, 32, 159, 160, 169, 165, 166, -87, 102, 170,
683 33, -87, -87, -87, -87, -87, -87, -87, -87, 171,
684 174, -87, -87, 104, -87, -87, -87, -87, -87, -87,
685 -87, -87, 102, 175, 112, -78, -78, -78, -78, -78,
686 -78, -78, -78, 146, 92, -78, -78, 104, 179, 13,
687 14, 15, 16, 17, 18, 19, 20, 187, 112, 21,
688 22, 178, 189, 180, 181, 182, 183, 146, 193, 194,
689 195, 196, 188, 200, 190, 94, 95, 96, 97, 98,
690 198, 33, 54, 201, 197, 99, 202, 52, 127, 76,
691 139, 173
692};
693
694static const yytype_uint8 yycheck[] =
695{
696 1, 68, 69, 94, 95, 96, 97, 98, 99, 24,
697 10, 77, 13, 77, 15, 0, 82, 18, 82, 110,
698 3, 36, 3, 36, 91, 92, 34, 0, 1, 37,
699 38, 4, 5, 6, 7, 8, 9, 10, 11, 12,
700 107, 14, 15, 16, 17, 18, 19, 20, 21, 22,
701 23, 24, 25, 36, 27, 36, 5, 6, 27, 8,
702 9, 10, 11, 36, 36, 14, 15, 36, 27, 28,
703 70, 27, 28, 139, 36, 139, 167, 27, 14, 35,
704 79, 1, 81, 36, 40, 5, 6, 36, 8, 9,
705 10, 11, 12, 160, 14, 15, 16, 17, 18, 19,
706 20, 37, 38, 79, 105, 81, 27, 27, 175, 27,
707 78, 79, 36, 81, 27, 28, 36, 0, 1, 1,
708 121, 4, 5, 6, 7, 8, 9, 10, 11, 12,
709 1, 14, 15, 16, 17, 18, 19, 20, 21, 22,
710 23, 24, 25, 36, 27, 78, 79, 36, 81, 36,
711 0, 1, 36, 36, 4, 5, 6, 7, 8, 9,
712 10, 11, 37, 38, 14, 15, 16, 17, 18, 19,
713 20, 21, 22, 23, 24, 36, 36, 27, 36, 37,
714 38, 36, 37, 38, 0, 1, 36, 36, 4, 5,
715 6, 7, 8, 9, 10, 11, 36, 198, 14, 15,
716 16, 17, 18, 19, 20, 21, 22, 23, 24, 36,
717 36, 27, 36, 26, 1, 27, 27, 0, 1, 13,
718 36, 4, 5, 6, 7, 8, 9, 10, 11, 36,
719 27, 14, 15, 16, 17, 18, 19, 20, 21, 22,
720 23, 24, 1, 14, 27, 4, 5, 6, 7, 8,
721 9, 10, 11, 36, 38, 14, 15, 16, 36, 4,
722 5, 6, 7, 8, 9, 10, 11, 36, 27, 14,
723 15, 161, 36, 163, 164, 165, 166, 36, 36, 36,
724 36, 36, 172, 36, 174, 29, 30, 31, 32, 33,
725 39, 36, 7, 36, 184, 39, 36, 6, 77, 38,
726 80, 122
727};
728
729 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
730 symbol of state STATE-NUM. */
731static const yytype_uint8 yystos[] =
732{
733 0, 3, 36, 42, 43, 44, 68, 86, 27, 28,
734 84, 0, 1, 4, 5, 6, 7, 8, 9, 10,
735 11, 14, 15, 16, 17, 18, 19, 20, 21, 22,
736 23, 24, 27, 36, 45, 46, 48, 49, 50, 51,
737 57, 58, 60, 64, 66, 69, 70, 72, 74, 75,
738 76, 85, 44, 36, 43, 86, 36, 84, 36, 84,
739 27, 90, 36, 84, 27, 27, 27, 28, 35, 40,
740 88, 89, 36, 1, 1, 52, 52, 61, 63, 67,
741 81, 73, 79, 36, 36, 36, 36, 36, 36, 88,
742 88, 37, 38, 86, 29, 30, 31, 32, 33, 39,
743 36, 36, 1, 12, 16, 18, 19, 20, 21, 22,
744 23, 25, 27, 36, 47, 53, 54, 77, 78, 80,
745 17, 18, 19, 20, 36, 47, 62, 78, 80, 46,
746 59, 85, 46, 60, 65, 72, 85, 24, 36, 79,
747 82, 46, 60, 71, 72, 85, 36, 47, 80, 34,
748 88, 88, 89, 89, 89, 89, 89, 89, 36, 36,
749 26, 84, 83, 84, 88, 27, 27, 89, 55, 1,
750 13, 36, 84, 83, 27, 14, 87, 88, 87, 36,
751 87, 87, 87, 87, 89, 27, 36, 36, 87, 36,
752 87, 88, 36, 36, 36, 36, 36, 87, 39, 56,
753 36, 36, 36, 84
754};
755
756 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
757static const yytype_uint8 yyr1[] =
758{
759 0, 41, 42, 42, 43, 43, 44, 44, 44, 44,
760 44, 44, 44, 44, 45, 45, 45, 45, 45, 45,
761 45, 45, 45, 46, 46, 46, 46, 46, 46, 47,
762 47, 48, 49, 50, 51, 52, 52, 52, 52, 52,
763 52, 52, 53, 53, 53, 53, 53, 53, 54, 55,
764 55, 56, 56, 57, 58, 59, 60, 61, 61, 61,
765 61, 61, 61, 62, 62, 62, 62, 63, 63, 64,
766 65, 66, 67, 67, 67, 67, 68, 69, 70, 71,
767 72, 73, 73, 73, 73, 74, 75, 76, 77, 78,
768 79, 79, 79, 79, 80, 81, 81, 81, 82, 83,
769 83, 84, 84, 85, 85, 85, 86, 86, 87, 87,
770 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
771 88, 89, 89, 90, 90
772};
773
774 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
Sam Ravnborg14f31562007-09-26 20:15:39 +0200775static const yytype_uint8 yyr2[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776{
Arnaud Lacombec0920a12010-09-10 21:23:28 -0400777 0, 2, 2, 1, 2, 1, 0, 2, 2, 2,
778 2, 4, 4, 3, 1, 1, 1, 1, 1, 1,
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500779 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
780 2, 3, 2, 3, 2, 0, 2, 2, 2, 2,
781 2, 2, 3, 4, 4, 4, 4, 5, 3, 0,
782 3, 0, 2, 3, 2, 1, 3, 0, 2, 2,
783 2, 2, 2, 4, 3, 2, 4, 0, 2, 3,
784 1, 3, 0, 2, 2, 2, 3, 3, 3, 1,
785 3, 0, 2, 2, 2, 3, 3, 2, 2, 2,
786 0, 2, 2, 2, 4, 0, 2, 2, 2, 0,
787 2, 1, 1, 2, 2, 2, 1, 2, 0, 2,
788 1, 3, 3, 3, 3, 3, 3, 3, 2, 3,
789 3, 1, 1, 0, 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790};
791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500793#define yyerrok (yyerrstatus = 0)
794#define yyclearin (yychar = YYEMPTY)
795#define YYEMPTY (-2)
796#define YYEOF 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500798#define YYACCEPT goto yyacceptlab
799#define YYABORT goto yyabortlab
800#define YYERROR goto yyerrorlab
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
803#define YYRECOVERING() (!!yyerrstatus)
804
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100805#define YYBACKUP(Token, Value) \
806do \
807 if (yychar == YYEMPTY) \
808 { \
809 yychar = (Token); \
810 yylval = (Value); \
811 YYPOPSTACK (yylen); \
812 yystate = *yyssp; \
813 goto yybackup; \
814 } \
815 else \
816 { \
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700817 yyerror (YY_("syntax error: cannot back up")); \
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500818 YYERROR; \
819 } \
820while (0)
821
822/* Error token number */
823#define YYTERROR 1
824#define YYERRCODE 256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Roman Zippel7a884882005-11-08 21:34:51 -0800826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
828/* Enable debugging if requested. */
829#if YYDEBUG
830
831# ifndef YYFPRINTF
832# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
833# define YYFPRINTF fprintf
834# endif
835
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500836# define YYDPRINTF(Args) \
837do { \
838 if (yydebug) \
839 YYFPRINTF Args; \
840} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500842/* This macro is provided for backward compatibility. */
843#ifndef YY_LOCATION_PRINT
844# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
845#endif
Sam Ravnborg14f31562007-09-26 20:15:39 +0200846
847
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500848# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
849do { \
850 if (yydebug) \
851 { \
852 YYFPRINTF (stderr, "%s ", Title); \
853 yy_symbol_print (stderr, \
854 Type, Value); \
855 YYFPRINTF (stderr, "\n"); \
856 } \
857} while (0)
Sam Ravnborg14f31562007-09-26 20:15:39 +0200858
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500859
860/*----------------------------------------.
861| Print this symbol's value on YYOUTPUT. |
862`----------------------------------------*/
863
Sam Ravnborg14f31562007-09-26 20:15:39 +0200864static void
865yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
Sam Ravnborg14f31562007-09-26 20:15:39 +0200866{
Jan Beulich4a47f1e2015-06-15 13:00:59 +0100867 FILE *yyo = yyoutput;
868 YYUSE (yyo);
Sam Ravnborg14f31562007-09-26 20:15:39 +0200869 if (!yyvaluep)
870 return;
871# ifdef YYPRINT
872 if (yytype < YYNTOKENS)
873 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
Sam Ravnborg14f31562007-09-26 20:15:39 +0200874# endif
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500875 YYUSE (yytype);
Sam Ravnborg14f31562007-09-26 20:15:39 +0200876}
877
878
879/*--------------------------------.
880| Print this symbol on YYOUTPUT. |
881`--------------------------------*/
882
Sam Ravnborg14f31562007-09-26 20:15:39 +0200883static void
884yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
Sam Ravnborg14f31562007-09-26 20:15:39 +0200885{
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500886 YYFPRINTF (yyoutput, "%s %s (",
887 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
Sam Ravnborg14f31562007-09-26 20:15:39 +0200888
889 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
890 YYFPRINTF (yyoutput, ")");
891}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893/*------------------------------------------------------------------.
894| yy_stack_print -- Print the state stack from its BOTTOM up to its |
Roman Zippel7a884882005-11-08 21:34:51 -0800895| TOP (included). |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896`------------------------------------------------------------------*/
897
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898static void
Josh Triplett1456edb2009-10-15 11:03:20 -0700899yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
901 YYFPRINTF (stderr, "Stack now");
Josh Triplett1456edb2009-10-15 11:03:20 -0700902 for (; yybottom <= yytop; yybottom++)
903 {
904 int yybot = *yybottom;
905 YYFPRINTF (stderr, " %d", yybot);
906 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 YYFPRINTF (stderr, "\n");
908}
909
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500910# define YY_STACK_PRINT(Bottom, Top) \
911do { \
912 if (yydebug) \
913 yy_stack_print ((Bottom), (Top)); \
914} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
916
917/*------------------------------------------------.
918| Report that the YYRULE is going to be reduced. |
919`------------------------------------------------*/
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921static void
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500922yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923{
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500924 unsigned long int yylno = yyrline[yyrule];
Sam Ravnborg14f31562007-09-26 20:15:39 +0200925 int yynrhs = yyr2[yyrule];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 int yyi;
Sam Ravnborg14f31562007-09-26 20:15:39 +0200927 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500928 yyrule - 1, yylno);
Sam Ravnborg14f31562007-09-26 20:15:39 +0200929 /* The symbols being reduced. */
930 for (yyi = 0; yyi < yynrhs; yyi++)
931 {
Josh Triplett1456edb2009-10-15 11:03:20 -0700932 YYFPRINTF (stderr, " $%d = ", yyi + 1);
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500933 yy_symbol_print (stderr,
934 yystos[yyssp[yyi + 1 - yynrhs]],
935 &(yyvsp[(yyi + 1) - (yynrhs)])
936 );
Josh Triplett1456edb2009-10-15 11:03:20 -0700937 YYFPRINTF (stderr, "\n");
Sam Ravnborg14f31562007-09-26 20:15:39 +0200938 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939}
940
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500941# define YY_REDUCE_PRINT(Rule) \
942do { \
943 if (yydebug) \
944 yy_reduce_print (yyssp, yyvsp, Rule); \
945} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
947/* Nonzero means print parse trace. It is left uninitialized so that
948 multiple parsers can coexist. */
949int yydebug;
950#else /* !YYDEBUG */
951# define YYDPRINTF(Args)
Roman Zippel7a884882005-11-08 21:34:51 -0800952# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953# define YY_STACK_PRINT(Bottom, Top)
954# define YY_REDUCE_PRINT(Rule)
955#endif /* !YYDEBUG */
956
957
958/* YYINITDEPTH -- initial size of the parser's stacks. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -0500959#ifndef YYINITDEPTH
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960# define YYINITDEPTH 200
961#endif
962
963/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
964 if the built-in stack extension method is used).
965
966 Do not make this value too large; the results are undefined if
Roman Zippelf6a88aa2006-06-08 22:12:44 -0700967 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 evaluated with infinite-precision integer arithmetic. */
969
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970#ifndef YYMAXDEPTH
971# define YYMAXDEPTH 10000
972#endif
973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974
975#if YYERROR_VERBOSE
976
977# ifndef yystrlen
Sam Ravnborg14f31562007-09-26 20:15:39 +0200978# if defined __GLIBC__ && defined _STRING_H
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979# define yystrlen strlen
980# else
981/* Return the length of YYSTR. */
982static YYSIZE_T
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983yystrlen (const char *yystr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
Sam Ravnborg14f31562007-09-26 20:15:39 +0200985 YYSIZE_T yylen;
986 for (yylen = 0; yystr[yylen]; yylen++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 continue;
Sam Ravnborg14f31562007-09-26 20:15:39 +0200988 return yylen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989}
990# endif
991# endif
992
993# ifndef yystpcpy
Sam Ravnborg14f31562007-09-26 20:15:39 +0200994# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995# define yystpcpy stpcpy
996# else
997/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
998 YYDEST. */
999static char *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000yystpcpy (char *yydest, const char *yysrc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001{
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001002 char *yyd = yydest;
1003 const char *yys = yysrc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
1005 while ((*yyd++ = *yys++) != '\0')
1006 continue;
1007
1008 return yyd - 1;
1009}
1010# endif
1011# endif
1012
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001013# ifndef yytnamerr
1014/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1015 quotes and backslashes, so that it's suitable for yyerror. The
1016 heuristic is that double-quoting is unnecessary unless the string
1017 contains an apostrophe, a comma, or backslash (other than
1018 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1019 null, do not copy; instead, return the length of what the result
1020 would have been. */
1021static YYSIZE_T
1022yytnamerr (char *yyres, const char *yystr)
1023{
1024 if (*yystr == '"')
1025 {
Sam Ravnborg14f31562007-09-26 20:15:39 +02001026 YYSIZE_T yyn = 0;
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001027 char const *yyp = yystr;
1028
1029 for (;;)
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001030 switch (*++yyp)
1031 {
1032 case '\'':
1033 case ',':
1034 goto do_not_strip_quotes;
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001035
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001036 case '\\':
1037 if (*++yyp != '\\')
1038 goto do_not_strip_quotes;
1039 /* Fall through. */
1040 default:
1041 if (yyres)
1042 yyres[yyn] = *yyp;
1043 yyn++;
1044 break;
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001045
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001046 case '"':
1047 if (yyres)
1048 yyres[yyn] = '\0';
1049 return yyn;
1050 }
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001051 do_not_strip_quotes: ;
1052 }
1053
1054 if (! yyres)
1055 return yystrlen (yystr);
1056
1057 return yystpcpy (yyres, yystr) - yyres;
1058}
1059# endif
1060
Yann E. MORINc80de522013-09-03 17:49:04 +02001061/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1062 about the unexpected token YYTOKEN for the state stack whose top is
1063 YYSSP.
1064
1065 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1066 not large enough to hold the message. In that case, also set
1067 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1068 required number of bytes is too large to store. */
1069static int
1070yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1071 yytype_int16 *yyssp, int yytoken)
Sam Ravnborg14f31562007-09-26 20:15:39 +02001072{
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001073 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
Yann E. MORINc80de522013-09-03 17:49:04 +02001074 YYSIZE_T yysize = yysize0;
Yann E. MORINc80de522013-09-03 17:49:04 +02001075 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1076 /* Internationalized format string. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001077 const char *yyformat = YY_NULLPTR;
Yann E. MORINc80de522013-09-03 17:49:04 +02001078 /* Arguments of yyformat. */
1079 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1080 /* Number of reported tokens (one for the "unexpected", one per
1081 "expected"). */
1082 int yycount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Yann E. MORINc80de522013-09-03 17:49:04 +02001084 /* There are many possibilities here to consider:
Yann E. MORINc80de522013-09-03 17:49:04 +02001085 - If this state is a consistent state with a default action, then
1086 the only way this function was invoked is if the default action
1087 is an error action. In that case, don't check for expected
1088 tokens because there are none.
1089 - The only way there can be no lookahead present (in yychar) is if
1090 this state is a consistent state with a default action. Thus,
1091 detecting the absence of a lookahead is sufficient to determine
1092 that there is no unexpected or expected token to report. In that
1093 case, just report a simple "syntax error".
1094 - Don't assume there isn't a lookahead just because this state is a
1095 consistent state with a default action. There might have been a
1096 previous inconsistent state, consistent state with a non-default
1097 action, or user semantic action that manipulated yychar.
1098 - Of course, the expected token list depends on states to have
1099 correct lookahead information, and it depends on the parser not
1100 to perform extra reductions after fetching a lookahead from the
1101 scanner and before detecting a syntax error. Thus, state merging
1102 (from LALR or IELR) and default reductions corrupt the expected
1103 token list. However, the list is correct for canonical LR with
1104 one exception: it will still contain any token that will not be
1105 accepted due to an error action in a later state.
1106 */
1107 if (yytoken != YYEMPTY)
Sam Ravnborg14f31562007-09-26 20:15:39 +02001108 {
Yann E. MORINc80de522013-09-03 17:49:04 +02001109 int yyn = yypact[*yyssp];
1110 yyarg[yycount++] = yytname[yytoken];
1111 if (!yypact_value_is_default (yyn))
1112 {
1113 /* Start YYX at -YYN if negative to avoid negative indexes in
1114 YYCHECK. In other words, skip the first -YYN actions for
1115 this state because they are default actions. */
1116 int yyxbegin = yyn < 0 ? -yyn : 0;
1117 /* Stay within bounds of both yycheck and yytname. */
1118 int yychecklim = YYLAST - yyn + 1;
1119 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1120 int yyx;
Sam Ravnborg14f31562007-09-26 20:15:39 +02001121
Yann E. MORINc80de522013-09-03 17:49:04 +02001122 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1123 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1124 && !yytable_value_is_error (yytable[yyx + yyn]))
1125 {
1126 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1127 {
1128 yycount = 1;
1129 yysize = yysize0;
1130 break;
1131 }
1132 yyarg[yycount++] = yytname[yyx];
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001133 {
1134 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1135 if (! (yysize <= yysize1
1136 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1137 return 2;
1138 yysize = yysize1;
1139 }
Yann E. MORINc80de522013-09-03 17:49:04 +02001140 }
1141 }
Sam Ravnborg14f31562007-09-26 20:15:39 +02001142 }
Yann E. MORINc80de522013-09-03 17:49:04 +02001143
1144 switch (yycount)
1145 {
1146# define YYCASE_(N, S) \
1147 case N: \
1148 yyformat = S; \
1149 break
1150 YYCASE_(0, YY_("syntax error"));
1151 YYCASE_(1, YY_("syntax error, unexpected %s"));
1152 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1153 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1154 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1155 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1156# undef YYCASE_
1157 }
1158
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001159 {
1160 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1161 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1162 return 2;
1163 yysize = yysize1;
1164 }
Yann E. MORINc80de522013-09-03 17:49:04 +02001165
1166 if (*yymsg_alloc < yysize)
1167 {
1168 *yymsg_alloc = 2 * yysize;
1169 if (! (yysize <= *yymsg_alloc
1170 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1171 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1172 return 1;
1173 }
1174
1175 /* Avoid sprintf, as that infringes on the user's name space.
1176 Don't have undefined behavior even if the translation
1177 produced a string with the wrong number of "%s"s. */
1178 {
1179 char *yyp = *yymsg;
1180 int yyi = 0;
1181 while ((*yyp = *yyformat) != '\0')
1182 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1183 {
1184 yyp += yytnamerr (yyp, yyarg[yyi++]);
1185 yyformat += 2;
1186 }
1187 else
1188 {
1189 yyp++;
1190 yyformat++;
1191 }
1192 }
1193 return 0;
Sam Ravnborg14f31562007-09-26 20:15:39 +02001194}
1195#endif /* YYERROR_VERBOSE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197/*-----------------------------------------------.
1198| Release the memory associated to this symbol. |
1199`-----------------------------------------------*/
1200
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201static void
Roman Zippel7a884882005-11-08 21:34:51 -08001202yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203{
Sam Ravnborg14f31562007-09-26 20:15:39 +02001204 YYUSE (yyvaluep);
Roman Zippel7a884882005-11-08 21:34:51 -08001205 if (!yymsg)
1206 yymsg = "Deleting";
1207 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1208
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001209 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 switch (yytype)
1211 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001212 case 58: /* choice_entry */
Roman Zippela02f0572005-11-08 21:34:53 -08001213
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001214 {
Roman Zippela02f0572005-11-08 21:34:53 -08001215 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001216 ((*yyvaluep).menu)->file->name, ((*yyvaluep).menu)->lineno);
1217 if (current_menu == ((*yyvaluep).menu))
Roman Zippela02f0572005-11-08 21:34:53 -08001218 menu_end_menu();
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001219}
Roman Zippela02f0572005-11-08 21:34:53 -08001220
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001221 break;
Roman Zippela02f0572005-11-08 21:34:53 -08001222
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001223 case 64: /* if_entry */
1224
1225 {
Roman Zippela02f0572005-11-08 21:34:53 -08001226 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001227 ((*yyvaluep).menu)->file->name, ((*yyvaluep).menu)->lineno);
1228 if (current_menu == ((*yyvaluep).menu))
Roman Zippela02f0572005-11-08 21:34:53 -08001229 menu_end_menu();
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001230}
Roman Zippela02f0572005-11-08 21:34:53 -08001231
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001232 break;
Roman Zippela02f0572005-11-08 21:34:53 -08001233
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001234 case 70: /* menu_entry */
1235
1236 {
Roman Zippela02f0572005-11-08 21:34:53 -08001237 fprintf(stderr, "%s:%d: missing end statement for this entry\n",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001238 ((*yyvaluep).menu)->file->name, ((*yyvaluep).menu)->lineno);
1239 if (current_menu == ((*yyvaluep).menu))
Roman Zippela02f0572005-11-08 21:34:53 -08001240 menu_end_menu();
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001241}
Roman Zippela02f0572005-11-08 21:34:53 -08001242
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001243 break;
1244
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
1246 default:
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001247 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 }
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001249 YY_IGNORE_MAYBE_UNINITIALIZED_END
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Yann E. MORINc80de522013-09-03 17:49:04 +02001252
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
1254
Josh Triplett1456edb2009-10-15 11:03:20 -07001255/* The lookahead symbol. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256int yychar;
1257
Josh Triplett1456edb2009-10-15 11:03:20 -07001258/* The semantic value of the lookahead symbol. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259YYSTYPE yylval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260/* Number of syntax errors so far. */
1261int yynerrs;
1262
1263
Yann E. MORINc80de522013-09-03 17:49:04 +02001264/*----------.
1265| yyparse. |
1266`----------*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268int
1269yyparse (void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270{
Josh Triplett1456edb2009-10-15 11:03:20 -07001271 int yystate;
1272 /* Number of tokens to shift before error messages enabled. */
1273 int yyerrstatus;
1274
1275 /* The stacks and their tools:
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001276 'yyss': related to states.
1277 'yyvs': related to semantic values.
Josh Triplett1456edb2009-10-15 11:03:20 -07001278
Jan Beulich4a47f1e2015-06-15 13:00:59 +01001279 Refer to the stacks through separate pointers, to allow yyoverflow
Josh Triplett1456edb2009-10-15 11:03:20 -07001280 to reallocate them elsewhere. */
1281
1282 /* The state stack. */
1283 yytype_int16 yyssa[YYINITDEPTH];
1284 yytype_int16 *yyss;
1285 yytype_int16 *yyssp;
1286
1287 /* The semantic value stack. */
1288 YYSTYPE yyvsa[YYINITDEPTH];
1289 YYSTYPE *yyvs;
1290 YYSTYPE *yyvsp;
1291
1292 YYSIZE_T yystacksize;
1293
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001294 int yyn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 int yyresult;
Josh Triplett1456edb2009-10-15 11:03:20 -07001296 /* Lookahead token as an internal (translated) token number. */
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001297 int yytoken = 0;
Josh Triplett1456edb2009-10-15 11:03:20 -07001298 /* The variables used to return semantic value and location from the
1299 action routines. */
1300 YYSTYPE yyval;
1301
Sam Ravnborg14f31562007-09-26 20:15:39 +02001302#if YYERROR_VERBOSE
1303 /* Buffer for error messages, and its allocated size. */
1304 char yymsgbuf[128];
1305 char *yymsg = yymsgbuf;
1306 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1307#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Sam Ravnborg14f31562007-09-26 20:15:39 +02001309#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Sam Ravnborg14f31562007-09-26 20:15:39 +02001311 /* The number of symbols on the RHS of the reduced rule.
1312 Keep to zero when no symbol should be popped. */
1313 int yylen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001315 yyssp = yyss = yyssa;
1316 yyvsp = yyvs = yyvsa;
Josh Triplett1456edb2009-10-15 11:03:20 -07001317 yystacksize = YYINITDEPTH;
1318
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 YYDPRINTF ((stderr, "Starting parse\n"));
1320
1321 yystate = 0;
1322 yyerrstatus = 0;
1323 yynerrs = 0;
Josh Triplett1456edb2009-10-15 11:03:20 -07001324 yychar = YYEMPTY; /* Cause a token to be read. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 goto yysetstate;
1326
1327/*------------------------------------------------------------.
1328| yynewstate -- Push a new state, which is found in yystate. |
1329`------------------------------------------------------------*/
1330 yynewstate:
1331 /* In all cases, when you get here, the value and location stacks
Sam Ravnborg14f31562007-09-26 20:15:39 +02001332 have just been pushed. So pushing a state here evens the stacks. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 yyssp++;
1334
1335 yysetstate:
1336 *yyssp = yystate;
1337
1338 if (yyss + yystacksize - 1 <= yyssp)
1339 {
1340 /* Get the current used size of the three stacks, in elements. */
1341 YYSIZE_T yysize = yyssp - yyss + 1;
1342
1343#ifdef yyoverflow
1344 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001345 /* Give user a chance to reallocate the stack. Use copies of
1346 these so that the &'s don't force the real ones into
1347 memory. */
1348 YYSTYPE *yyvs1 = yyvs;
1349 yytype_int16 *yyss1 = yyss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001351 /* Each stack pointer address is followed by the size of the
1352 data in use in that stack, in bytes. This used to be a
1353 conditional around just the two extra args, but that might
1354 be undefined if yyoverflow is a macro. */
1355 yyoverflow (YY_("memory exhausted"),
1356 &yyss1, yysize * sizeof (*yyssp),
1357 &yyvs1, yysize * sizeof (*yyvsp),
1358 &yystacksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001360 yyss = yyss1;
1361 yyvs = yyvs1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 }
1363#else /* no yyoverflow */
1364# ifndef YYSTACK_RELOCATE
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001365 goto yyexhaustedlab;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366# else
1367 /* Extend the stack our own way. */
1368 if (YYMAXDEPTH <= yystacksize)
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001369 goto yyexhaustedlab;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 yystacksize *= 2;
1371 if (YYMAXDEPTH < yystacksize)
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001372 yystacksize = YYMAXDEPTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
1374 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001375 yytype_int16 *yyss1 = yyss;
1376 union yyalloc *yyptr =
1377 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1378 if (! yyptr)
1379 goto yyexhaustedlab;
1380 YYSTACK_RELOCATE (yyss_alloc, yyss);
1381 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382# undef YYSTACK_RELOCATE
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001383 if (yyss1 != yyssa)
1384 YYSTACK_FREE (yyss1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 }
1386# endif
1387#endif /* no yyoverflow */
1388
1389 yyssp = yyss + yysize - 1;
1390 yyvsp = yyvs + yysize - 1;
1391
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001393 (unsigned long int) yystacksize));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
1395 if (yyss + yystacksize - 1 <= yyssp)
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001396 YYABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 }
1398
1399 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1400
Josh Triplett1456edb2009-10-15 11:03:20 -07001401 if (yystate == YYFINAL)
1402 YYACCEPT;
1403
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 goto yybackup;
1405
1406/*-----------.
1407| yybackup. |
1408`-----------*/
1409yybackup:
1410
Sam Ravnborg14f31562007-09-26 20:15:39 +02001411 /* Do appropriate processing given the current state. Read a
Josh Triplett1456edb2009-10-15 11:03:20 -07001412 lookahead token if we need one and don't already have one. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Josh Triplett1456edb2009-10-15 11:03:20 -07001414 /* First try to decide what to do without reference to lookahead token. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 yyn = yypact[yystate];
Yann E. MORINc80de522013-09-03 17:49:04 +02001416 if (yypact_value_is_default (yyn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 goto yydefault;
1418
Josh Triplett1456edb2009-10-15 11:03:20 -07001419 /* Not known => get a lookahead token if don't already have one. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Josh Triplett1456edb2009-10-15 11:03:20 -07001421 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 if (yychar == YYEMPTY)
1423 {
1424 YYDPRINTF ((stderr, "Reading a token: "));
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001425 yychar = yylex ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 }
1427
1428 if (yychar <= YYEOF)
1429 {
1430 yychar = yytoken = YYEOF;
1431 YYDPRINTF ((stderr, "Now at end of input.\n"));
1432 }
1433 else
1434 {
1435 yytoken = YYTRANSLATE (yychar);
Roman Zippel7a884882005-11-08 21:34:51 -08001436 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 }
1438
1439 /* If the proper action on seeing token YYTOKEN is to reduce or to
1440 detect an error, take that action. */
1441 yyn += yytoken;
1442 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1443 goto yydefault;
1444 yyn = yytable[yyn];
1445 if (yyn <= 0)
1446 {
Yann E. MORINc80de522013-09-03 17:49:04 +02001447 if (yytable_value_is_error (yyn))
1448 goto yyerrlab;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 yyn = -yyn;
1450 goto yyreduce;
1451 }
1452
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 /* Count tokens shifted since error; after three, turn off error
1454 status. */
1455 if (yyerrstatus)
1456 yyerrstatus--;
1457
Josh Triplett1456edb2009-10-15 11:03:20 -07001458 /* Shift the lookahead token. */
Sam Ravnborg14f31562007-09-26 20:15:39 +02001459 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1460
Josh Triplett1456edb2009-10-15 11:03:20 -07001461 /* Discard the shifted token. */
1462 yychar = YYEMPTY;
Sam Ravnborg14f31562007-09-26 20:15:39 +02001463
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 yystate = yyn;
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001465 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Sam Ravnborg14f31562007-09-26 20:15:39 +02001466 *++yyvsp = yylval;
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001467 YY_IGNORE_MAYBE_UNINITIALIZED_END
Sam Ravnborg14f31562007-09-26 20:15:39 +02001468
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 goto yynewstate;
1470
1471
1472/*-----------------------------------------------------------.
1473| yydefault -- do the default action for the current state. |
1474`-----------------------------------------------------------*/
1475yydefault:
1476 yyn = yydefact[yystate];
1477 if (yyn == 0)
1478 goto yyerrlab;
1479 goto yyreduce;
1480
1481
1482/*-----------------------------.
1483| yyreduce -- Do a reduction. |
1484`-----------------------------*/
1485yyreduce:
1486 /* yyn is the number of a rule to reduce with. */
1487 yylen = yyr2[yyn];
1488
1489 /* If YYLEN is nonzero, implement the default value of the action:
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001490 '$$ = $1'.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
1492 Otherwise, the following line sets YYVAL to garbage.
1493 This behavior is undocumented and Bison
1494 users should not rely upon it. Assigning to YYVAL
1495 unconditionally makes the parser a bit smaller, and it avoids a
1496 GCC warning that YYVAL may be used uninitialized. */
1497 yyval = yyvsp[1-yylen];
1498
1499
1500 YY_REDUCE_PRINT (yyn);
1501 switch (yyn)
1502 {
Arnaud Lacombec0920a12010-09-10 21:23:28 -04001503 case 10:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
Yann E. MORINc80de522013-09-03 17:49:04 +02001505 { zconf_error("unexpected end statement"); }
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001506
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 break;
1508
Arnaud Lacombec0920a12010-09-10 21:23:28 -04001509 case 11:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001511 { zconf_error("unknown statement \"%s\"", (yyvsp[-2].string)); }
1512
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 break;
1514
Arnaud Lacombec0920a12010-09-10 21:23:28 -04001515 case 12:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Roman Zippela02f0572005-11-08 21:34:53 -08001517 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001518 zconf_error("unexpected option \"%s\"", kconf_id_strings + (yyvsp[-2].id)->name);
Yann E. MORINc80de522013-09-03 17:49:04 +02001519}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001520
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 break;
1522
Arnaud Lacombec0920a12010-09-10 21:23:28 -04001523 case 13:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
Yann E. MORINc80de522013-09-03 17:49:04 +02001525 { zconf_error("invalid statement"); }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526
Roman Zippela02f0572005-11-08 21:34:53 -08001527 break;
1528
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001529 case 29:
Roman Zippela02f0572005-11-08 21:34:53 -08001530
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001531 { zconf_error("unknown option \"%s\"", (yyvsp[-2].string)); }
1532
Roman Zippela02f0572005-11-08 21:34:53 -08001533 break;
1534
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001535 case 30:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001537 { zconf_error("invalid option"); }
1538
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 break;
1540
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001541 case 31:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001544 struct symbol *sym = sym_lookup((yyvsp[-1].string), 0);
1545 sym->flags |= SYMBOL_OPTIONAL;
1546 menu_add_entry(sym);
1547 printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
Yann E. MORINc80de522013-09-03 17:49:04 +02001548}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001549
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 break;
1551
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001552 case 32:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
1554 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001555 menu_end_entry();
1556 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001557}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001558
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 break;
1560
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001561 case 33:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562
1563 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001564 struct symbol *sym = sym_lookup((yyvsp[-1].string), 0);
1565 sym->flags |= SYMBOL_OPTIONAL;
1566 menu_add_entry(sym);
1567 printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
1568}
1569
1570 break;
1571
1572 case 34:
1573
1574 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 if (current_entry->prompt)
1576 current_entry->prompt->type = P_MENU;
1577 else
1578 zconfprint("warning: menuconfig statement without prompt");
1579 menu_end_entry();
1580 printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001581}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 break;
1584
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001585 case 42:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
1587 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001588 menu_set_type((yyvsp[-2].id)->stype);
1589 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1590 zconf_curname(), zconf_lineno(),
1591 (yyvsp[-2].id)->stype);
Yann E. MORINc80de522013-09-03 17:49:04 +02001592}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001593
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 break;
1595
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001596 case 43:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
1598 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001599 menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
1600 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001601}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001602
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 break;
1604
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001605 case 44:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
1607 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001608 menu_add_expr(P_DEFAULT, (yyvsp[-2].expr), (yyvsp[-1].expr));
1609 if ((yyvsp[-3].id)->stype != S_UNKNOWN)
1610 menu_set_type((yyvsp[-3].id)->stype);
1611 printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
1612 zconf_curname(), zconf_lineno(),
1613 (yyvsp[-3].id)->stype);
Yann E. MORINc80de522013-09-03 17:49:04 +02001614}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001615
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 break;
1617
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001618 case 45:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
1620 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001621 menu_add_symbol(P_SELECT, sym_lookup((yyvsp[-2].string), 0), (yyvsp[-1].expr));
1622 printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001623}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001624
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 break;
1626
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001627 case 46:
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001628
1629 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001630 menu_add_symbol(P_IMPLY, sym_lookup((yyvsp[-2].string), 0), (yyvsp[-1].expr));
1631 printd(DEBUG_PARSE, "%s:%d:imply\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001632}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001633
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001634 break;
1635
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001636 case 47:
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001637
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001638 {
1639 menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[-3].symbol), (yyvsp[-2].symbol)), (yyvsp[-1].expr));
1640 printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
1641}
1642
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001643 break;
1644
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001645 case 50:
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001646
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001647 {
1648 const struct kconf_id *id = kconf_id_lookup((yyvsp[-1].string), strlen((yyvsp[-1].string)));
1649 if (id && id->flags & TF_OPTION)
1650 menu_add_option(id->token, (yyvsp[0].string));
1651 else
1652 zconfprint("warning: ignoring unknown option %s", (yyvsp[-1].string));
1653 free((yyvsp[-1].string));
1654}
1655
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001656 break;
1657
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001658 case 51:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001660 { (yyval.string) = NULL; }
1661
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 break;
1663
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001664 case 52:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001666 { (yyval.string) = (yyvsp[0].string); }
1667
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 break;
1669
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001670 case 53:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671
1672 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001673 struct symbol *sym = sym_lookup((yyvsp[-1].string), SYMBOL_CHOICE);
1674 sym->flags |= SYMBOL_AUTO;
1675 menu_add_entry(sym);
1676 menu_add_expr(P_CHOICE, NULL, NULL);
1677 printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
1678}
1679
1680 break;
1681
1682 case 54:
1683
1684 {
1685 (yyval.menu) = menu_add_menu();
1686}
1687
1688 break;
1689
1690 case 55:
1691
1692 {
1693 if (zconf_endtoken((yyvsp[0].id), T_CHOICE, T_ENDCHOICE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 menu_end_menu();
1695 printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
1696 }
Yann E. MORINc80de522013-09-03 17:49:04 +02001697}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 break;
1700
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001701 case 63:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
1703 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001704 menu_add_prompt(P_PROMPT, (yyvsp[-2].string), (yyvsp[-1].expr));
1705 printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001706}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001707
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 break;
1709
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001710 case 64:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711
1712 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001713 if ((yyvsp[-2].id)->stype == S_BOOLEAN || (yyvsp[-2].id)->stype == S_TRISTATE) {
1714 menu_set_type((yyvsp[-2].id)->stype);
1715 printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
1716 zconf_curname(), zconf_lineno(),
1717 (yyvsp[-2].id)->stype);
1718 } else
1719 YYERROR;
1720}
1721
1722 break;
1723
1724 case 65:
1725
1726 {
1727 current_entry->sym->flags |= SYMBOL_OPTIONAL;
1728 printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
1729}
1730
1731 break;
1732
1733 case 66:
1734
1735 {
1736 if ((yyvsp[-3].id)->stype == S_UNKNOWN) {
1737 menu_add_symbol(P_DEFAULT, sym_lookup((yyvsp[-2].string), 0), (yyvsp[-1].expr));
Roman Zippel3370f9f2005-11-08 21:34:52 -08001738 printd(DEBUG_PARSE, "%s:%d:default\n",
1739 zconf_curname(), zconf_lineno());
1740 } else
1741 YYERROR;
Yann E. MORINc80de522013-09-03 17:49:04 +02001742}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001743
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 break;
1745
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001746 case 69:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
1748 {
1749 printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
1750 menu_add_entry(NULL);
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001751 menu_add_dep((yyvsp[-1].expr));
Roman Zippela02f0572005-11-08 21:34:53 -08001752 (yyval.menu) = menu_add_menu();
Yann E. MORINc80de522013-09-03 17:49:04 +02001753}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001754
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 break;
1756
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001757 case 70:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758
1759 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001760 if (zconf_endtoken((yyvsp[0].id), T_IF, T_ENDIF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 menu_end_menu();
1762 printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
1763 }
Yann E. MORINc80de522013-09-03 17:49:04 +02001764}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 break;
1767
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001768 case 76:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769
1770 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001771 menu_add_prompt(P_MENU, (yyvsp[-1].string), NULL);
Yann E. MORINc80de522013-09-03 17:49:04 +02001772}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001773
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 break;
1775
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001776 case 77:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
1778 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001779 menu_add_entry(NULL);
1780 menu_add_prompt(P_MENU, (yyvsp[-1].string), NULL);
1781 printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
1782}
1783
1784 break;
1785
1786 case 78:
1787
1788 {
1789 (yyval.menu) = menu_add_menu();
1790}
1791
1792 break;
1793
1794 case 79:
1795
1796 {
1797 if (zconf_endtoken((yyvsp[0].id), T_MENU, T_ENDMENU)) {
Roman Zippela02f0572005-11-08 21:34:53 -08001798 menu_end_menu();
1799 printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
1800 }
Yann E. MORINc80de522013-09-03 17:49:04 +02001801}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 break;
1804
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001805 case 85:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806
1807 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001808 printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), (yyvsp[-1].string));
1809 zconf_nextfile((yyvsp[-1].string));
Yann E. MORINc80de522013-09-03 17:49:04 +02001810}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001811
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 break;
1813
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001814 case 86:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815
1816 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001817 menu_add_entry(NULL);
1818 menu_add_prompt(P_COMMENT, (yyvsp[-1].string), NULL);
1819 printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001820}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001821
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 break;
1823
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001824 case 87:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
1826 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001827 menu_end_entry();
Yann E. MORINc80de522013-09-03 17:49:04 +02001828}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001829
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 break;
1831
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001832 case 88:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833
1834 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001835 printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
1836 zconf_starthelp();
1837}
1838
1839 break;
1840
1841 case 89:
1842
1843 {
1844 current_entry->help = (yyvsp[0].string);
1845}
1846
1847 break;
1848
1849 case 94:
1850
1851 {
1852 menu_add_dep((yyvsp[-1].expr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
Yann E. MORINc80de522013-09-03 17:49:04 +02001854}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001856 break;
1857
1858 case 98:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859
1860 {
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001861 menu_add_visibility((yyvsp[0].expr));
Yann E. MORINc80de522013-09-03 17:49:04 +02001862}
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 break;
1865
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001866 case 100:
Roman Zippela02f0572005-11-08 21:34:53 -08001867
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001868 {
1869 menu_add_prompt(P_PROMPT, (yyvsp[-1].string), (yyvsp[0].expr));
1870}
Roman Zippela02f0572005-11-08 21:34:53 -08001871
Roman Zippela02f0572005-11-08 21:34:53 -08001872 break;
1873
1874 case 103:
1875
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001876 { (yyval.id) = (yyvsp[-1].id); }
1877
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001878 break;
1879
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001880 case 104:
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001881
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001882 { (yyval.id) = (yyvsp[-1].id); }
1883
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001884 break;
1885
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001886 case 105:
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001887
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001888 { (yyval.id) = (yyvsp[-1].id); }
1889
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001890 break;
1891
1892 case 108:
1893
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001894 { (yyval.expr) = NULL; }
1895
Roman Zippel5a1aa8a2008-02-29 05:11:50 +01001896 break;
1897
1898 case 109:
1899
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001900 { (yyval.expr) = (yyvsp[0].expr); }
1901
Arnaud Lacombec0920a12010-09-10 21:23:28 -04001902 break;
1903
1904 case 110:
1905
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001906 { (yyval.expr) = expr_alloc_symbol((yyvsp[0].symbol)); }
1907
Arnaud Lacombec0920a12010-09-10 21:23:28 -04001908 break;
1909
1910 case 111:
1911
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001912 { (yyval.expr) = expr_alloc_comp(E_LTH, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1913
Arnaud Lacombec0920a12010-09-10 21:23:28 -04001914 break;
1915
1916 case 112:
1917
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001918 { (yyval.expr) = expr_alloc_comp(E_LEQ, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1919
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001920 break;
1921
1922 case 113:
1923
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001924 { (yyval.expr) = expr_alloc_comp(E_GTH, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1925
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001926 break;
1927
1928 case 114:
1929
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001930 { (yyval.expr) = expr_alloc_comp(E_GEQ, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1931
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001932 break;
1933
1934 case 115:
1935
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001936 { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1937
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001938 break;
1939
1940 case 116:
1941
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001942 { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[-2].symbol), (yyvsp[0].symbol)); }
1943
Arnaud Lacombe09899c92010-11-06 18:30:24 -03001944 break;
1945
1946 case 117:
1947
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001948 { (yyval.expr) = (yyvsp[-1].expr); }
1949
Jan Beulich4a47f1e2015-06-15 13:00:59 +01001950 break;
1951
1952 case 118:
1953
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001954 { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[0].expr)); }
1955
Jan Beulich4a47f1e2015-06-15 13:00:59 +01001956 break;
1957
1958 case 119:
1959
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001960 { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
1961
Jan Beulich4a47f1e2015-06-15 13:00:59 +01001962 break;
1963
1964 case 120:
1965
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001966 { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
1967
Jan Beulich4a47f1e2015-06-15 13:00:59 +01001968 break;
1969
1970 case 121:
1971
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001972 { (yyval.symbol) = sym_lookup((yyvsp[0].string), 0); free((yyvsp[0].string)); }
1973
1974 break;
1975
1976 case 122:
1977
1978 { (yyval.symbol) = sym_lookup((yyvsp[0].string), SYMBOL_CONST); free((yyvsp[0].string)); }
1979
1980 break;
1981
1982 case 123:
1983
Yann E. MORINc80de522013-09-03 17:49:04 +02001984 { (yyval.string) = NULL; }
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05001985
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001986 break;
1987
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001988
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989
Roman Zippelf6a88aa2006-06-08 22:12:44 -07001990 default: break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 }
Yann E. MORINc80de522013-09-03 17:49:04 +02001992 /* User semantic actions sometimes alter yychar, and that requires
1993 that yytoken be updated with the new translation. We take the
1994 approach of translating immediately before every use of yytoken.
1995 One alternative is translating here after every semantic action,
1996 but that translation would be missed if the semantic action invokes
1997 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1998 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1999 incorrect destructor might then be invoked immediately. In the
2000 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2001 to an incorrect destructor call or verbose syntax error message
2002 before the lookahead is translated. */
Sam Ravnborg14f31562007-09-26 20:15:39 +02002003 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004
Sam Ravnborg14f31562007-09-26 20:15:39 +02002005 YYPOPSTACK (yylen);
2006 yylen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 YY_STACK_PRINT (yyss, yyssp);
2008
2009 *++yyvsp = yyval;
2010
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002011 /* Now 'shift' the result of the reduction. Determine what state
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 that goes to, based on the state we popped back to and the rule
2013 number reduced by. */
2014
2015 yyn = yyr1[yyn];
2016
2017 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2018 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2019 yystate = yytable[yystate];
2020 else
2021 yystate = yydefgoto[yyn - YYNTOKENS];
2022
2023 goto yynewstate;
2024
2025
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002026/*--------------------------------------.
2027| yyerrlab -- here on detecting error. |
2028`--------------------------------------*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029yyerrlab:
Yann E. MORINc80de522013-09-03 17:49:04 +02002030 /* Make sure we have latest lookahead translation. See comments at
2031 user semantic actions for why this is necessary. */
2032 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2033
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 /* If not already recovering from an error, report this error. */
2035 if (!yyerrstatus)
2036 {
2037 ++yynerrs;
Sam Ravnborg14f31562007-09-26 20:15:39 +02002038#if ! YYERROR_VERBOSE
2039 yyerror (YY_("syntax error"));
2040#else
Yann E. MORINc80de522013-09-03 17:49:04 +02002041# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2042 yyssp, yytoken)
Sam Ravnborg14f31562007-09-26 20:15:39 +02002043 {
Yann E. MORINc80de522013-09-03 17:49:04 +02002044 char const *yymsgp = YY_("syntax error");
2045 int yysyntax_error_status;
2046 yysyntax_error_status = YYSYNTAX_ERROR;
2047 if (yysyntax_error_status == 0)
2048 yymsgp = yymsg;
2049 else if (yysyntax_error_status == 1)
2050 {
2051 if (yymsg != yymsgbuf)
2052 YYSTACK_FREE (yymsg);
2053 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2054 if (!yymsg)
2055 {
2056 yymsg = yymsgbuf;
2057 yymsg_alloc = sizeof yymsgbuf;
2058 yysyntax_error_status = 2;
2059 }
2060 else
2061 {
2062 yysyntax_error_status = YYSYNTAX_ERROR;
2063 yymsgp = yymsg;
2064 }
2065 }
2066 yyerror (yymsgp);
2067 if (yysyntax_error_status == 2)
2068 goto yyexhaustedlab;
Sam Ravnborg14f31562007-09-26 20:15:39 +02002069 }
Yann E. MORINc80de522013-09-03 17:49:04 +02002070# undef YYSYNTAX_ERROR
Sam Ravnborg14f31562007-09-26 20:15:39 +02002071#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 }
2073
2074
2075
2076 if (yyerrstatus == 3)
2077 {
Josh Triplett1456edb2009-10-15 11:03:20 -07002078 /* If just tried and failed to reuse lookahead token after an
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002079 error, discard it. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080
Roman Zippel7a884882005-11-08 21:34:51 -08002081 if (yychar <= YYEOF)
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002082 {
2083 /* Return failure if at end of input. */
2084 if (yychar == YYEOF)
2085 YYABORT;
2086 }
Roman Zippel7a884882005-11-08 21:34:51 -08002087 else
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002088 {
2089 yydestruct ("Error: discarding",
2090 yytoken, &yylval);
2091 yychar = YYEMPTY;
2092 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 }
2094
Josh Triplett1456edb2009-10-15 11:03:20 -07002095 /* Else will try to reuse lookahead token after shifting the error
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 token. */
2097 goto yyerrlab1;
2098
2099
Roman Zippel7a884882005-11-08 21:34:51 -08002100/*---------------------------------------------------.
2101| yyerrorlab -- error raised explicitly by YYERROR. |
2102`---------------------------------------------------*/
2103yyerrorlab:
2104
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002105 /* Pacify compilers like GCC when the user code never invokes
2106 YYERROR and the label yyerrorlab therefore never appears in user
2107 code. */
Sam Ravnborg14f31562007-09-26 20:15:39 +02002108 if (/*CONSTCOND*/ 0)
Roman Zippel7a884882005-11-08 21:34:51 -08002109 goto yyerrorlab;
Roman Zippel7a884882005-11-08 21:34:51 -08002110
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002111 /* Do not reclaim the symbols of the rule whose action triggered
Sam Ravnborg14f31562007-09-26 20:15:39 +02002112 this YYERROR. */
2113 YYPOPSTACK (yylen);
2114 yylen = 0;
2115 YY_STACK_PRINT (yyss, yyssp);
Roman Zippel7a884882005-11-08 21:34:51 -08002116 yystate = *yyssp;
2117 goto yyerrlab1;
2118
2119
2120/*-------------------------------------------------------------.
2121| yyerrlab1 -- common code for both syntax error and YYERROR. |
2122`-------------------------------------------------------------*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123yyerrlab1:
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002124 yyerrstatus = 3; /* Each real token shifted decrements this. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125
2126 for (;;)
2127 {
2128 yyn = yypact[yystate];
Yann E. MORINc80de522013-09-03 17:49:04 +02002129 if (!yypact_value_is_default (yyn))
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002130 {
2131 yyn += YYTERROR;
2132 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2133 {
2134 yyn = yytable[yyn];
2135 if (0 < yyn)
2136 break;
2137 }
2138 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139
2140 /* Pop the current state because it cannot handle the error token. */
2141 if (yyssp == yyss)
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002142 YYABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
Sam Ravnborg14f31562007-09-26 20:15:39 +02002145 yydestruct ("Error: popping",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002146 yystos[yystate], yyvsp);
Sam Ravnborg14f31562007-09-26 20:15:39 +02002147 YYPOPSTACK (1);
Roman Zippel7a884882005-11-08 21:34:51 -08002148 yystate = *yyssp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 YY_STACK_PRINT (yyss, yyssp);
2150 }
2151
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002152 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 *++yyvsp = yylval;
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002154 YY_IGNORE_MAYBE_UNINITIALIZED_END
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155
2156
Sam Ravnborg14f31562007-09-26 20:15:39 +02002157 /* Shift the error token. */
Roman Zippel7a884882005-11-08 21:34:51 -08002158 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2159
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 yystate = yyn;
2161 goto yynewstate;
2162
2163
2164/*-------------------------------------.
2165| yyacceptlab -- YYACCEPT comes here. |
2166`-------------------------------------*/
2167yyacceptlab:
2168 yyresult = 0;
2169 goto yyreturn;
2170
2171/*-----------------------------------.
2172| yyabortlab -- YYABORT comes here. |
2173`-----------------------------------*/
2174yyabortlab:
2175 yyresult = 1;
2176 goto yyreturn;
2177
Jan Beulich4a47f1e2015-06-15 13:00:59 +01002178#if !defined yyoverflow || YYERROR_VERBOSE
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002179/*-------------------------------------------------.
2180| yyexhaustedlab -- memory exhaustion comes here. |
2181`-------------------------------------------------*/
2182yyexhaustedlab:
2183 yyerror (YY_("memory exhausted"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 yyresult = 2;
2185 /* Fall through. */
2186#endif
2187
2188yyreturn:
Josh Triplett1456edb2009-10-15 11:03:20 -07002189 if (yychar != YYEMPTY)
Yann E. MORINc80de522013-09-03 17:49:04 +02002190 {
2191 /* Make sure we have latest lookahead translation. See comments at
2192 user semantic actions for why this is necessary. */
2193 yytoken = YYTRANSLATE (yychar);
2194 yydestruct ("Cleanup: discarding lookahead",
2195 yytoken, &yylval);
2196 }
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002197 /* Do not reclaim the symbols of the rule whose action triggered
Sam Ravnborg14f31562007-09-26 20:15:39 +02002198 this YYABORT or YYACCEPT. */
2199 YYPOPSTACK (yylen);
2200 YY_STACK_PRINT (yyss, yyssp);
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002201 while (yyssp != yyss)
2202 {
2203 yydestruct ("Cleanup: popping",
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002204 yystos[*yyssp], yyvsp);
Sam Ravnborg14f31562007-09-26 20:15:39 +02002205 YYPOPSTACK (1);
Roman Zippelf6a88aa2006-06-08 22:12:44 -07002206 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207#ifndef yyoverflow
2208 if (yyss != yyssa)
2209 YYSTACK_FREE (yyss);
2210#endif
Sam Ravnborg14f31562007-09-26 20:15:39 +02002211#if YYERROR_VERBOSE
2212 if (yymsg != yymsgbuf)
2213 YYSTACK_FREE (yymsg);
2214#endif
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002215 return yyresult;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216}
2217
2218
2219
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220void conf_parse(const char *name)
2221{
2222 struct symbol *sym;
2223 int i;
2224
2225 zconf_initscan(name);
2226
2227 sym_init();
nir.tzachar@gmail.com692d97c2009-11-25 12:28:43 +02002228 _menu_init();
blaisorblade@yahoo.itfb7f6ff2005-07-28 17:56:25 +02002229 rootmenu.prompt = menu_add_prompt(P_MENU, "Linux Kernel Configuration", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230
Roman Zippela02f0572005-11-08 21:34:53 -08002231 if (getenv("ZCONF_DEBUG"))
2232 zconfdebug = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 zconfparse();
2234 if (zconfnerrs)
2235 exit(1);
Yann E. MORINc80de522013-09-03 17:49:04 +02002236 if (!modules_sym)
2237 modules_sym = sym_find( "n" );
Arnaud Lacombec0920a12010-09-10 21:23:28 -04002238
2239 rootmenu.prompt->text = _(rootmenu.prompt->text);
2240 rootmenu.prompt->text = sym_expand_string_value(rootmenu.prompt->text);
2241
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 menu_finalize(&rootmenu);
2243 for_all_symbols(i, sym) {
Sam Ravnborg5447d342007-05-06 09:20:10 +02002244 if (sym_check_deps(sym))
2245 zconfnerrs++;
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09002246 }
Sam Ravnborg5447d342007-05-06 09:20:10 +02002247 if (zconfnerrs)
2248 exit(1);
Karsten Wiesebfc10002006-12-13 00:34:07 -08002249 sym_set_change_count(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250}
2251
Josh Triplett65166572009-10-15 12:13:36 -07002252static const char *zconf_tokenname(int token)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253{
2254 switch (token) {
2255 case T_MENU: return "menu";
2256 case T_ENDMENU: return "endmenu";
2257 case T_CHOICE: return "choice";
2258 case T_ENDCHOICE: return "endchoice";
2259 case T_IF: return "if";
2260 case T_ENDIF: return "endif";
Roman Zippela02f0572005-11-08 21:34:53 -08002261 case T_DEPENDS: return "depends";
Arnaud Lacombe09899c92010-11-06 18:30:24 -03002262 case T_VISIBLE: return "visible";
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 }
2264 return "<token>";
2265}
2266
Arnaud Lacombe2f76b352011-05-23 01:08:19 -04002267static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268{
Roman Zippela02f0572005-11-08 21:34:53 -08002269 if (id->token != endtoken) {
2270 zconf_error("unexpected '%s' within %s block",
2271 kconf_id_strings + id->name, zconf_tokenname(starttoken));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 zconfnerrs++;
2273 return false;
2274 }
2275 if (current_menu->file != current_file) {
Roman Zippela02f0572005-11-08 21:34:53 -08002276 zconf_error("'%s' in different file than '%s'",
2277 kconf_id_strings + id->name, zconf_tokenname(starttoken));
2278 fprintf(stderr, "%s:%d: location of the '%s'\n",
2279 current_menu->file->name, current_menu->lineno,
2280 zconf_tokenname(starttoken));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 zconfnerrs++;
2282 return false;
2283 }
2284 return true;
2285}
2286
2287static void zconfprint(const char *err, ...)
2288{
2289 va_list ap;
2290
Roman Zippela02f0572005-11-08 21:34:53 -08002291 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
2292 va_start(ap, err);
2293 vfprintf(stderr, err, ap);
2294 va_end(ap);
2295 fprintf(stderr, "\n");
2296}
2297
2298static void zconf_error(const char *err, ...)
2299{
2300 va_list ap;
2301
2302 zconfnerrs++;
2303 fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 va_start(ap, err);
2305 vfprintf(stderr, err, ap);
2306 va_end(ap);
2307 fprintf(stderr, "\n");
2308}
2309
2310static void zconferror(const char *err)
2311{
2312 fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313}
2314
Josh Triplett65166572009-10-15 12:13:36 -07002315static void print_quoted_string(FILE *out, const char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316{
2317 const char *p;
2318 int len;
2319
2320 putc('"', out);
2321 while ((p = strchr(str, '"'))) {
2322 len = p - str;
2323 if (len)
2324 fprintf(out, "%.*s", len, str);
2325 fputs("\\\"", out);
2326 str = p + 1;
2327 }
2328 fputs(str, out);
2329 putc('"', out);
2330}
2331
Josh Triplett65166572009-10-15 12:13:36 -07002332static void print_symbol(FILE *out, struct menu *menu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333{
2334 struct symbol *sym = menu->sym;
2335 struct property *prop;
2336
2337 if (sym_is_choice(sym))
Li Zefanc6ccc302010-04-14 11:44:20 +08002338 fprintf(out, "\nchoice\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 else
Li Zefanc6ccc302010-04-14 11:44:20 +08002340 fprintf(out, "\nconfig %s\n", sym->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 switch (sym->type) {
2342 case S_BOOLEAN:
2343 fputs(" boolean\n", out);
2344 break;
2345 case S_TRISTATE:
2346 fputs(" tristate\n", out);
2347 break;
2348 case S_STRING:
2349 fputs(" string\n", out);
2350 break;
2351 case S_INT:
2352 fputs(" integer\n", out);
2353 break;
2354 case S_HEX:
2355 fputs(" hex\n", out);
2356 break;
2357 default:
2358 fputs(" ???\n", out);
2359 break;
2360 }
2361 for (prop = sym->prop; prop; prop = prop->next) {
2362 if (prop->menu != menu)
2363 continue;
2364 switch (prop->type) {
2365 case P_PROMPT:
2366 fputs(" prompt ", out);
2367 print_quoted_string(out, prop->text);
2368 if (!expr_is_yes(prop->visible.expr)) {
2369 fputs(" if ", out);
2370 expr_fprint(prop->visible.expr, out);
2371 }
2372 fputc('\n', out);
2373 break;
2374 case P_DEFAULT:
2375 fputs( " default ", out);
2376 expr_fprint(prop->expr, out);
2377 if (!expr_is_yes(prop->visible.expr)) {
2378 fputs(" if ", out);
2379 expr_fprint(prop->visible.expr, out);
2380 }
2381 fputc('\n', out);
2382 break;
2383 case P_CHOICE:
2384 fputs(" #choice value\n", out);
2385 break;
Li Zefanc6ccc302010-04-14 11:44:20 +08002386 case P_SELECT:
2387 fputs( " select ", out);
2388 expr_fprint(prop->expr, out);
2389 fputc('\n', out);
2390 break;
Nicolas Pitre32ce5ac2016-11-11 00:10:06 -05002391 case P_IMPLY:
2392 fputs( " imply ", out);
2393 expr_fprint(prop->expr, out);
2394 fputc('\n', out);
2395 break;
Li Zefanc6ccc302010-04-14 11:44:20 +08002396 case P_RANGE:
2397 fputs( " range ", out);
2398 expr_fprint(prop->expr, out);
2399 fputc('\n', out);
2400 break;
2401 case P_MENU:
2402 fputs( " menu ", out);
2403 print_quoted_string(out, prop->text);
2404 fputc('\n', out);
2405 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 default:
2407 fprintf(out, " unknown prop %d!\n", prop->type);
2408 break;
2409 }
2410 }
Sam Ravnborg03d29122007-07-21 00:00:36 +02002411 if (menu->help) {
2412 int len = strlen(menu->help);
2413 while (menu->help[--len] == '\n')
2414 menu->help[len] = 0;
2415 fprintf(out, " help\n%s\n", menu->help);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417}
2418
2419void zconfdump(FILE *out)
2420{
2421 struct property *prop;
2422 struct symbol *sym;
2423 struct menu *menu;
2424
2425 menu = rootmenu.list;
2426 while (menu) {
2427 if ((sym = menu->sym))
2428 print_symbol(out, menu);
2429 else if ((prop = menu->prompt)) {
2430 switch (prop->type) {
2431 case P_COMMENT:
2432 fputs("\ncomment ", out);
2433 print_quoted_string(out, prop->text);
2434 fputs("\n", out);
2435 break;
2436 case P_MENU:
2437 fputs("\nmenu ", out);
2438 print_quoted_string(out, prop->text);
2439 fputs("\n", out);
2440 break;
2441 default:
2442 ;
2443 }
2444 if (!expr_is_yes(prop->visible.expr)) {
2445 fputs(" depends ", out);
2446 expr_fprint(prop->visible.expr, out);
2447 fputc('\n', out);
2448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 }
2450
2451 if (menu->list)
2452 menu = menu->list;
2453 else if (menu->next)
2454 menu = menu->next;
2455 else while ((menu = menu->parent)) {
2456 if (menu->prompt && menu->prompt->type == P_MENU)
2457 fputs("\nendmenu\n", out);
2458 if (menu->next) {
2459 menu = menu->next;
2460 break;
2461 }
2462 }
2463 }
2464}
2465
Arnaud Lacombe2f76b352011-05-23 01:08:19 -04002466#include "zconf.lex.c"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467#include "util.c"
2468#include "confdata.c"
2469#include "expr.c"
2470#include "symbol.c"
2471#include "menu.c"