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 2408