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