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