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