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