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