1 /* A Bison parser, made by GNU Bison 3.0.5. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "3.0.5" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 62 63 64 /* Copy the first part of user declarations. */ 65 #line 1 "mcparse.y" /* yacc.c:339 */ 66 /* mcparse.y -- parser for Windows mc files 67 Copyright (C) 2007-2020 Free Software Foundation, Inc. 68 69 Parser for Windows mc files 70 Written by Kai Tietz, Onevision. 71 72 This file is part of GNU Binutils. 73 74 This program is free software; you can redistribute it and/or modify 75 it under the terms of the GNU General Public License as published by 76 the Free Software Foundation; either version 3 of the License, or 77 (at your option) any later version. 78 79 This program is distributed in the hope that it will be useful, 80 but WITHOUT ANY WARRANTY; without even the implied warranty of 81 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 82 GNU General Public License for more details. 83 84 You should have received a copy of the GNU General Public License 85 along with this program; if not, write to the Free Software 86 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 87 02110-1301, USA. */ 88 89 /* This is a parser for Windows rc files. It is based on the parser 90 by Gunther Ebert <gunther.ebert@ixos-leipzig.de>. */ 91 92 #include "sysdep.h" 93 #include "bfd.h" 94 #include "bucomm.h" 95 #include "libiberty.h" 96 #include "windmc.h" 97 #include "safe-ctype.h" 98 99 static rc_uint_type mc_last_id = 0; 100 static rc_uint_type mc_sefa_val = 0; 101 static unichar *mc_last_symbol = NULL; 102 static const mc_keyword *mc_cur_severity = NULL; 103 static const mc_keyword *mc_cur_facility = NULL; 104 static mc_node *cur_node = NULL; 105 106 107 #line 108 "mcparse.c" /* yacc.c:339 */ 108 109 # ifndef YY_NULLPTR 110 # if defined __cplusplus && 201103L <= __cplusplus 111 # define YY_NULLPTR nullptr 112 # else 113 # define YY_NULLPTR 0 114 # endif 115 # endif 116 117 /* Enabling verbose error messages. */ 118 #ifdef YYERROR_VERBOSE 119 # undef YYERROR_VERBOSE 120 # define YYERROR_VERBOSE 1 121 #else 122 # define YYERROR_VERBOSE 0 123 #endif 124 125 /* In a future release of Bison, this section will be replaced 126 by #include "y.tab.h". */ 127 #ifndef YY_YY_MCPARSE_H_INCLUDED 128 # define YY_YY_MCPARSE_H_INCLUDED 129 /* Debug traces. */ 130 #ifndef YYDEBUG 131 # define YYDEBUG 0 132 #endif 133 #if YYDEBUG 134 extern int yydebug; 135 #endif 136 137 /* Token type. */ 138 #ifndef YYTOKENTYPE 139 # define YYTOKENTYPE 140 enum yytokentype 141 { 142 NL = 258, 143 MCIDENT = 259, 144 MCFILENAME = 260, 145 MCLINE = 261, 146 MCCOMMENT = 262, 147 MCTOKEN = 263, 148 MCENDLINE = 264, 149 MCLANGUAGENAMES = 265, 150 MCFACILITYNAMES = 266, 151 MCSEVERITYNAMES = 267, 152 MCOUTPUTBASE = 268, 153 MCMESSAGEIDTYPEDEF = 269, 154 MCLANGUAGE = 270, 155 MCMESSAGEID = 271, 156 MCSEVERITY = 272, 157 MCFACILITY = 273, 158 MCSYMBOLICNAME = 274, 159 MCNUMBER = 275 160 }; 161 #endif 162 /* Tokens. */ 163 #define NL 258 164 #define MCIDENT 259 165 #define MCFILENAME 260 166 #define MCLINE 261 167 #define MCCOMMENT 262 168 #define MCTOKEN 263 169 #define MCENDLINE 264 170 #define MCLANGUAGENAMES 265 171 #define MCFACILITYNAMES 266 172 #define MCSEVERITYNAMES 267 173 #define MCOUTPUTBASE 268 174 #define MCMESSAGEIDTYPEDEF 269 175 #define MCLANGUAGE 270 176 #define MCMESSAGEID 271 177 #define MCSEVERITY 272 178 #define MCFACILITY 273 179 #define MCSYMBOLICNAME 274 180 #define MCNUMBER 275 181 182 /* Value type. */ 183 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 184 185 union YYSTYPE 186 { 187 #line 44 "mcparse.y" /* yacc.c:355 */ 188 189 rc_uint_type ival; 190 unichar *ustr; 191 const mc_keyword *tok; 192 mc_node *nod; 193 194 #line 195 "mcparse.c" /* yacc.c:355 */ 195 }; 196 197 typedef union YYSTYPE YYSTYPE; 198 # define YYSTYPE_IS_TRIVIAL 1 199 # define YYSTYPE_IS_DECLARED 1 200 #endif 201 202 203 extern YYSTYPE yylval; 204 205 int yyparse (void); 206 207 #endif /* !YY_YY_MCPARSE_H_INCLUDED */ 208 209 /* Copy the second part of user declarations. */ 210 211 #line 212 "mcparse.c" /* yacc.c:358 */ 212 213 #ifdef short 214 # undef short 215 #endif 216 217 #ifdef YYTYPE_UINT8 218 typedef YYTYPE_UINT8 yytype_uint8; 219 #else 220 typedef unsigned char yytype_uint8; 221 #endif 222 223 #ifdef YYTYPE_INT8 224 typedef YYTYPE_INT8 yytype_int8; 225 #else 226 typedef signed char yytype_int8; 227 #endif 228 229 #ifdef YYTYPE_UINT16 230 typedef YYTYPE_UINT16 yytype_uint16; 231 #else 232 typedef unsigned short int yytype_uint16; 233 #endif 234 235 #ifdef YYTYPE_INT16 236 typedef YYTYPE_INT16 yytype_int16; 237 #else 238 typedef short int yytype_int16; 239 #endif 240 241 #ifndef YYSIZE_T 242 # ifdef __SIZE_TYPE__ 243 # define YYSIZE_T __SIZE_TYPE__ 244 # elif defined size_t 245 # define YYSIZE_T size_t 246 # elif ! defined YYSIZE_T 247 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 248 # define YYSIZE_T size_t 249 # else 250 # define YYSIZE_T unsigned int 251 # endif 252 #endif 253 254 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 255 256 #ifndef YY_ 257 # if defined YYENABLE_NLS && YYENABLE_NLS 258 # if ENABLE_NLS 259 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 260 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 261 # endif 262 # endif 263 # ifndef YY_ 264 # define YY_(Msgid) Msgid 265 # endif 266 #endif 267 268 #ifndef YY_ATTRIBUTE 269 # if (defined __GNUC__ \ 270 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 271 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 272 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 273 # else 274 # define YY_ATTRIBUTE(Spec) /* empty */ 275 # endif 276 #endif 277 278 #ifndef YY_ATTRIBUTE_PURE 279 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 280 #endif 281 282 #ifndef YY_ATTRIBUTE_UNUSED 283 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 284 #endif 285 286 #if !defined _Noreturn \ 287 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 288 # if defined _MSC_VER && 1200 <= _MSC_VER 289 # define _Noreturn __declspec (noreturn) 290 # else 291 # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 292 # endif 293 #endif 294 295 /* Suppress unused-variable warnings by "using" E. */ 296 #if ! defined lint || defined __GNUC__ 297 # define YYUSE(E) ((void) (E)) 298 #else 299 # define YYUSE(E) /* empty */ 300 #endif 301 302 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 303 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 304 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 305 _Pragma ("GCC diagnostic push") \ 306 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 307 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 308 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 309 _Pragma ("GCC diagnostic pop") 310 #else 311 # define YY_INITIAL_VALUE(Value) Value 312 #endif 313 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 314 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 315 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 316 #endif 317 #ifndef YY_INITIAL_VALUE 318 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 319 #endif 320 321 322 #if ! defined yyoverflow || YYERROR_VERBOSE 323 324 /* The parser invokes alloca or malloc; define the necessary symbols. */ 325 326 # ifdef YYSTACK_USE_ALLOCA 327 # if YYSTACK_USE_ALLOCA 328 # ifdef __GNUC__ 329 # define YYSTACK_ALLOC __builtin_alloca 330 # elif defined __BUILTIN_VA_ARG_INCR 331 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 332 # elif defined _AIX 333 # define YYSTACK_ALLOC __alloca 334 # elif defined _MSC_VER 335 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 336 # define alloca _alloca 337 # else 338 # define YYSTACK_ALLOC alloca 339 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 340 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 341 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 342 # ifndef EXIT_SUCCESS 343 # define EXIT_SUCCESS 0 344 # endif 345 # endif 346 # endif 347 # endif 348 # endif 349 350 # ifdef YYSTACK_ALLOC 351 /* Pacify GCC's 'empty if-body' warning. */ 352 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 353 # ifndef YYSTACK_ALLOC_MAXIMUM 354 /* The OS might guarantee only one guard page at the bottom of the stack, 355 and a page size can be as small as 4096 bytes. So we cannot safely 356 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 357 to allow for a few compiler-allocated temporary stack slots. */ 358 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 359 # endif 360 # else 361 # define YYSTACK_ALLOC YYMALLOC 362 # define YYSTACK_FREE YYFREE 363 # ifndef YYSTACK_ALLOC_MAXIMUM 364 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 365 # endif 366 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 367 && ! ((defined YYMALLOC || defined malloc) \ 368 && (defined YYFREE || defined free))) 369 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 370 # ifndef EXIT_SUCCESS 371 # define EXIT_SUCCESS 0 372 # endif 373 # endif 374 # ifndef YYMALLOC 375 # define YYMALLOC malloc 376 # if ! defined malloc && ! defined EXIT_SUCCESS 377 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 378 # endif 379 # endif 380 # ifndef YYFREE 381 # define YYFREE free 382 # if ! defined free && ! defined EXIT_SUCCESS 383 void free (void *); /* INFRINGES ON USER NAME SPACE */ 384 # endif 385 # endif 386 # endif 387 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 388 389 390 #if (! defined yyoverflow \ 391 && (! defined __cplusplus \ 392 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 393 394 /* A type that is properly aligned for any stack member. */ 395 union yyalloc 396 { 397 yytype_int16 yyss_alloc; 398 YYSTYPE yyvs_alloc; 399 }; 400 401 /* The size of the maximum gap between one aligned stack and the next. */ 402 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 403 404 /* The size of an array large to enough to hold all stacks, each with 405 N elements. */ 406 # define YYSTACK_BYTES(N) \ 407 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 408 + YYSTACK_GAP_MAXIMUM) 409 410 # define YYCOPY_NEEDED 1 411 412 /* Relocate STACK from its old location to the new one. The 413 local variables YYSIZE and YYSTACKSIZE give the old and new number of 414 elements in the stack, and YYPTR gives the new location of the 415 stack. Advance YYPTR to a properly aligned location for the next 416 stack. */ 417 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 418 do \ 419 { \ 420 YYSIZE_T yynewbytes; \ 421 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 422 Stack = &yyptr->Stack_alloc; \ 423 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 424 yyptr += yynewbytes / sizeof (*yyptr); \ 425 } \ 426 while (0) 427 428 #endif 429 430 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 431 /* Copy COUNT objects from SRC to DST. The source and destination do 432 not overlap. */ 433 # ifndef YYCOPY 434 # if defined __GNUC__ && 1 < __GNUC__ 435 # define YYCOPY(Dst, Src, Count) \ 436 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 437 # else 438 # define YYCOPY(Dst, Src, Count) \ 439 do \ 440 { \ 441 YYSIZE_T yyi; \ 442 for (yyi = 0; yyi < (Count); yyi++) \ 443 (Dst)[yyi] = (Src)[yyi]; \ 444 } \ 445 while (0) 446 # endif 447 # endif 448 #endif /* !YYCOPY_NEEDED */ 449 450 /* YYFINAL -- State number of the termination state. */ 451 #define YYFINAL 3 452 /* YYLAST -- Last index in YYTABLE. */ 453 #define YYLAST 114 454 455 /* YYNTOKENS -- Number of terminals. */ 456 #define YYNTOKENS 26 457 /* YYNNTS -- Number of nonterminals. */ 458 #define YYNNTS 29 459 /* YYNRULES -- Number of rules. */ 460 #define YYNRULES 82 461 /* YYNSTATES -- Number of states. */ 462 #define YYNSTATES 125 463 464 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned 465 by yylex, with out-of-bounds checking. */ 466 #define YYUNDEFTOK 2 467 #define YYMAXUTOK 275 468 469 #define YYTRANSLATE(YYX) \ 470 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 471 472 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 473 as returned by yylex, without out-of-bounds checking. */ 474 static const yytype_uint8 yytranslate[] = 475 { 476 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 477 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 478 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 480 22, 23, 2, 25, 2, 2, 2, 2, 2, 2, 481 2, 2, 2, 2, 2, 2, 2, 2, 24, 2, 482 2, 21, 2, 2, 2, 2, 2, 2, 2, 2, 483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 486 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 501 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 502 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 503 15, 16, 17, 18, 19, 20 504 }; 505 506 #if YYDEBUG 507 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 508 static const yytype_uint16 yyrline[] = 509 { 510 0, 66, 66, 69, 71, 73, 74, 75, 80, 84, 511 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 512 95, 96, 102, 106, 110, 117, 118, 119, 123, 127, 513 128, 132, 133, 134, 138, 142, 143, 147, 148, 149, 514 153, 157, 158, 159, 160, 165, 168, 172, 177, 176, 515 189, 190, 191, 195, 198, 202, 206, 211, 218, 224, 516 230, 238, 246, 254, 261, 262, 266, 276, 280, 292, 517 293, 296, 297, 311, 315, 320, 325, 330, 337, 338, 518 342, 346, 350 519 }; 520 #endif 521 522 #if YYDEBUG || YYERROR_VERBOSE || 0 523 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 524 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 525 static const char *const yytname[] = 526 { 527 "$end", "error", "$undefined", "NL", "MCIDENT", "MCFILENAME", "MCLINE", 528 "MCCOMMENT", "MCTOKEN", "MCENDLINE", "MCLANGUAGENAMES", 529 "MCFACILITYNAMES", "MCSEVERITYNAMES", "MCOUTPUTBASE", 530 "MCMESSAGEIDTYPEDEF", "MCLANGUAGE", "MCMESSAGEID", "MCSEVERITY", 531 "MCFACILITY", "MCSYMBOLICNAME", "MCNUMBER", "'='", "'('", "')'", "':'", 532 "'+'", "$accept", "input", "entities", "entity", "global_section", 533 "severitymaps", "severitymap", "facilitymaps", "facilitymap", "langmaps", 534 "langmap", "alias_name", "message", "$@1", "id", "vid", "sefasy_def", 535 "severity", "facility", "symbol", "lang_entities", "lang_entity", 536 "lines", "comments", "lang", "token", "lex_want_nl", "lex_want_line", 537 "lex_want_filename", YY_NULLPTR 538 }; 539 #endif 540 541 # ifdef YYPRINT 542 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 543 (internal) symbol number NUM (which must be that of a token). */ 544 static const yytype_uint16 yytoknum[] = 545 { 546 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 547 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 548 275, 61, 40, 41, 58, 43 549 }; 550 # endif 551 552 #define YYPACT_NINF -34 553 554 #define yypact_value_is_default(Yystate) \ 555 (!!((Yystate) == (-34))) 556 557 #define YYTABLE_NINF -83 558 559 #define yytable_value_is_error(Yytable_value) \ 560 0 561 562 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 563 STATE-NUM. */ 564 static const yytype_int8 yypact[] = 565 { 566 -34, 62, 70, -34, -34, -34, 15, 22, 30, -15, 567 34, 37, -34, -34, -34, -34, 56, -34, 10, -34, 568 12, -34, 20, 25, -34, 52, -34, 0, 80, -34, 569 -34, 71, -34, 84, -34, 86, -34, -34, -34, -34, 570 -34, 45, -34, 1, 68, 74, 76, -34, -34, -34, 571 -34, -34, -34, 4, -34, 38, -34, 6, -34, 39, 572 -34, 29, -34, 40, -34, -34, 93, 94, 99, 43, 573 76, -34, -34, -34, -34, -34, -34, 46, -34, -34, 574 -34, -34, 47, -34, -34, -34, -34, 49, -34, -34, 575 -34, -34, 83, -34, 3, -34, 2, -34, 81, -34, 576 81, 92, -34, -34, 48, -34, 82, 72, -34, -34, 577 -34, 104, 105, 108, -34, -34, -34, 73, -34, -34, 578 -34, -34, -34, -34, -34 579 }; 580 581 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 582 Performed when YYTABLE does not specify something else to do. Zero 583 means the default is an error. */ 584 static const yytype_uint8 yydefact[] = 585 { 586 3, 0, 0, 1, 8, 71, 0, 0, 0, 0, 587 0, 0, 4, 5, 6, 57, 7, 16, 0, 20, 588 0, 12, 0, 0, 24, 0, 52, 0, 48, 72, 589 15, 0, 19, 0, 11, 0, 21, 23, 22, 51, 590 54, 0, 50, 0, 0, 0, 0, 58, 59, 60, 591 39, 78, 79, 0, 37, 0, 33, 0, 31, 0, 592 27, 0, 25, 0, 56, 55, 0, 0, 0, 0, 593 49, 64, 81, 14, 13, 38, 44, 0, 18, 17, 594 32, 36, 0, 10, 9, 26, 30, 0, 61, 62, 595 63, 77, 0, 65, 0, 43, 0, 35, 45, 29, 596 45, 0, 69, 67, 0, 42, 0, 0, 34, 28, 597 76, 78, 79, 0, 70, 68, 66, 0, 47, 46, 598 74, 73, 75, 41, 40 599 }; 600 601 /* YYPGOTO[NTERM-NUM]. */ 602 static const yytype_int8 yypgoto[] = 603 { 604 -34, -34, -34, -34, -34, -34, 50, -34, 53, -34, 605 59, 13, -34, -34, -34, -34, -34, -34, -34, -34, 606 -34, 44, -34, -34, -34, -33, -34, -34, -34 607 }; 608 609 /* YYDEFGOTO[NTERM-NUM]. */ 610 static const yytype_int8 yydefgoto[] = 611 { 612 -1, 1, 2, 12, 13, 61, 62, 57, 58, 53, 613 54, 108, 14, 46, 15, 42, 28, 47, 48, 49, 614 70, 71, 104, 16, 72, 55, 92, 94, 106 615 }; 616 617 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 618 positive, shift that token. If negative, reduce the rule whose 619 number is the opposite. If YYTABLE_NINF, syntax error. */ 620 static const yytype_int8 yytable[] = 621 { 622 59, 39, 63, 105, 102, 73, 23, 78, 51, 103, 623 51, 30, 52, 32, 52, -53, 17, -53, -53, -53, 624 40, 34, 66, 19, 59, 41, -82, 74, 63, 79, 625 83, 21, 31, 51, 33, 24, 18, 52, 26, 76, 626 81, 86, 35, 20, 91, 36, 64, 95, 97, 114, 627 99, 22, 84, 37, 115, 25, 38, 116, 27, 77, 628 82, 87, 3, 29, -80, 65, 96, 98, 113, 100, 629 -2, 4, 50, 118, 123, 51, 119, 5, 124, 52, 630 6, 7, 8, 9, 10, 56, 11, 60, 51, 67, 631 51, 69, 52, 110, 52, 68, 111, 43, 44, 45, 632 112, 88, 89, 90, 101, 107, 117, 120, 121, 122, 633 80, 85, 75, 109, 93 634 }; 635 636 static const yytype_uint8 yycheck[] = 637 { 638 33, 1, 35, 1, 1, 1, 21, 1, 4, 6, 639 4, 1, 8, 1, 8, 15, 1, 17, 18, 19, 640 20, 1, 21, 1, 57, 25, 24, 23, 61, 23, 641 1, 1, 22, 4, 22, 1, 21, 8, 1, 1, 642 1, 1, 22, 21, 1, 20, 1, 1, 1, 1, 643 1, 21, 23, 1, 6, 21, 4, 9, 21, 21, 644 21, 21, 0, 7, 21, 20, 20, 20, 101, 20, 645 0, 1, 1, 1, 1, 4, 4, 7, 5, 8, 646 10, 11, 12, 13, 14, 1, 16, 1, 4, 21, 647 4, 15, 8, 1, 8, 21, 4, 17, 18, 19, 648 8, 8, 8, 4, 21, 24, 24, 3, 3, 1, 649 57, 61, 53, 100, 70 650 }; 651 652 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 653 symbol of state STATE-NUM. */ 654 static const yytype_uint8 yystos[] = 655 { 656 0, 27, 28, 0, 1, 7, 10, 11, 12, 13, 657 14, 16, 29, 30, 38, 40, 49, 1, 21, 1, 658 21, 1, 21, 21, 1, 21, 1, 21, 42, 7, 659 1, 22, 1, 22, 1, 22, 20, 1, 4, 1, 660 20, 25, 41, 17, 18, 19, 39, 43, 44, 45, 661 1, 4, 8, 35, 36, 51, 1, 33, 34, 51, 662 1, 31, 32, 51, 1, 20, 21, 21, 21, 15, 663 46, 47, 50, 1, 23, 36, 1, 21, 1, 23, 664 34, 1, 21, 1, 23, 32, 1, 21, 8, 8, 665 4, 1, 52, 47, 53, 1, 20, 1, 20, 1, 666 20, 21, 1, 6, 48, 1, 54, 24, 37, 37, 667 1, 4, 8, 51, 1, 6, 9, 24, 1, 4, 668 3, 3, 1, 1, 5 669 }; 670 671 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 672 static const yytype_uint8 yyr1[] = 673 { 674 0, 26, 27, 28, 28, 29, 29, 29, 29, 30, 675 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 676 30, 30, 30, 30, 30, 31, 31, 31, 32, 32, 677 32, 33, 33, 33, 34, 34, 34, 35, 35, 35, 678 36, 36, 36, 36, 36, 37, 37, 37, 39, 38, 679 40, 40, 40, 41, 41, 41, 41, 42, 42, 42, 680 42, 43, 44, 45, 46, 46, 47, 48, 48, 48, 681 48, 49, 49, 50, 50, 50, 50, 50, 51, 51, 682 52, 53, 54 683 }; 684 685 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 686 static const yytype_uint8 yyr2[] = 687 { 688 0, 2, 1, 0, 2, 1, 1, 1, 1, 5, 689 5, 3, 2, 5, 5, 3, 2, 5, 5, 3, 690 2, 3, 3, 3, 2, 1, 2, 1, 4, 3, 691 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 692 6, 6, 4, 3, 2, 0, 2, 2, 0, 4, 693 3, 3, 2, 0, 1, 2, 2, 0, 2, 2, 694 2, 3, 3, 3, 1, 2, 4, 1, 2, 1, 695 2, 1, 2, 5, 5, 5, 4, 2, 1, 1, 696 0, 0, 0 697 }; 698 699 700 #define yyerrok (yyerrstatus = 0) 701 #define yyclearin (yychar = YYEMPTY) 702 #define YYEMPTY (-2) 703 #define YYEOF 0 704 705 #define YYACCEPT goto yyacceptlab 706 #define YYABORT goto yyabortlab 707 #define YYERROR goto yyerrorlab 708 709 710 #define YYRECOVERING() (!!yyerrstatus) 711 712 #define YYBACKUP(Token, Value) \ 713 do \ 714 if (yychar == YYEMPTY) \ 715 { \ 716 yychar = (Token); \ 717 yylval = (Value); \ 718 YYPOPSTACK (yylen); \ 719 yystate = *yyssp; \ 720 goto yybackup; \ 721 } \ 722 else \ 723 { \ 724 yyerror (YY_("syntax error: cannot back up")); \ 725 YYERROR; \ 726 } \ 727 while (0) 728 729 /* Error token number */ 730 #define YYTERROR 1 731 #define YYERRCODE 256 732 733 734 735 /* Enable debugging if requested. */ 736 #if YYDEBUG 737 738 # ifndef YYFPRINTF 739 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 740 # define YYFPRINTF fprintf 741 # endif 742 743 # define YYDPRINTF(Args) \ 744 do { \ 745 if (yydebug) \ 746 YYFPRINTF Args; \ 747 } while (0) 748 749 /* This macro is provided for backward compatibility. */ 750 #ifndef YY_LOCATION_PRINT 751 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 752 #endif 753 754 755 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 756 do { \ 757 if (yydebug) \ 758 { \ 759 YYFPRINTF (stderr, "%s ", Title); \ 760 yy_symbol_print (stderr, \ 761 Type, Value); \ 762 YYFPRINTF (stderr, "\n"); \ 763 } \ 764 } while (0) 765 766 767 /*----------------------------------------. 768 | Print this symbol's value on YYOUTPUT. | 769 `----------------------------------------*/ 770 771 static void 772 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 773 { 774 FILE *yyo = yyoutput; 775 YYUSE (yyo); 776 if (!yyvaluep) 777 return; 778 # ifdef YYPRINT 779 if (yytype < YYNTOKENS) 780 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 781 # endif 782 YYUSE (yytype); 783 } 784 785 786 /*--------------------------------. 787 | Print this symbol on YYOUTPUT. | 788 `--------------------------------*/ 789 790 static void 791 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 792 { 793 YYFPRINTF (yyoutput, "%s %s (", 794 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); 795 796 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 797 YYFPRINTF (yyoutput, ")"); 798 } 799 800 /*------------------------------------------------------------------. 801 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 802 | TOP (included). | 803 `------------------------------------------------------------------*/ 804 805 static void 806 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 807 { 808 YYFPRINTF (stderr, "Stack now"); 809 for (; yybottom <= yytop; yybottom++) 810 { 811 int yybot = *yybottom; 812 YYFPRINTF (stderr, " %d", yybot); 813 } 814 YYFPRINTF (stderr, "\n"); 815 } 816 817 # define YY_STACK_PRINT(Bottom, Top) \ 818 do { \ 819 if (yydebug) \ 820 yy_stack_print ((Bottom), (Top)); \ 821 } while (0) 822 823 824 /*------------------------------------------------. 825 | Report that the YYRULE is going to be reduced. | 826 `------------------------------------------------*/ 827 828 static void 829 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule) 830 { 831 unsigned long int yylno = yyrline[yyrule]; 832 int yynrhs = yyr2[yyrule]; 833 int yyi; 834 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 835 yyrule - 1, yylno); 836 /* The symbols being reduced. */ 837 for (yyi = 0; yyi < yynrhs; yyi++) 838 { 839 YYFPRINTF (stderr, " $%d = ", yyi + 1); 840 yy_symbol_print (stderr, 841 yystos[yyssp[yyi + 1 - yynrhs]], 842 &(yyvsp[(yyi + 1) - (yynrhs)]) 843 ); 844 YYFPRINTF (stderr, "\n"); 845 } 846 } 847 848 # define YY_REDUCE_PRINT(Rule) \ 849 do { \ 850 if (yydebug) \ 851 yy_reduce_print (yyssp, yyvsp, Rule); \ 852 } while (0) 853 854 /* Nonzero means print parse trace. It is left uninitialized so that 855 multiple parsers can coexist. */ 856 int yydebug; 857 #else /* !YYDEBUG */ 858 # define YYDPRINTF(Args) 859 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 860 # define YY_STACK_PRINT(Bottom, Top) 861 # define YY_REDUCE_PRINT(Rule) 862 #endif /* !YYDEBUG */ 863 864 865 /* YYINITDEPTH -- initial size of the parser's stacks. */ 866 #ifndef YYINITDEPTH 867 # define YYINITDEPTH 200 868 #endif 869 870 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 871 if the built-in stack extension method is used). 872 873 Do not make this value too large; the results are undefined if 874 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 875 evaluated with infinite-precision integer arithmetic. */ 876 877 #ifndef YYMAXDEPTH 878 # define YYMAXDEPTH 10000 879 #endif 880 881 882 #if YYERROR_VERBOSE 883 884 # ifndef yystrlen 885 # if defined __GLIBC__ && defined _STRING_H 886 # define yystrlen strlen 887 # else 888 /* Return the length of YYSTR. */ 889 static YYSIZE_T 890 yystrlen (const char *yystr) 891 { 892 YYSIZE_T yylen; 893 for (yylen = 0; yystr[yylen]; yylen++) 894 continue; 895 return yylen; 896 } 897 # endif 898 # endif 899 900 # ifndef yystpcpy 901 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 902 # define yystpcpy stpcpy 903 # else 904 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 905 YYDEST. */ 906 static char * 907 yystpcpy (char *yydest, const char *yysrc) 908 { 909 char *yyd = yydest; 910 const char *yys = yysrc; 911 912 while ((*yyd++ = *yys++) != '\0') 913 continue; 914 915 return yyd - 1; 916 } 917 # endif 918 # endif 919 920 # ifndef yytnamerr 921 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 922 quotes and backslashes, so that it's suitable for yyerror. The 923 heuristic is that double-quoting is unnecessary unless the string 924 contains an apostrophe, a comma, or backslash (other than 925 backslash-backslash). YYSTR is taken from yytname. If YYRES is 926 null, do not copy; instead, return the length of what the result 927 would have been. */ 928 static YYSIZE_T 929 yytnamerr (char *yyres, const char *yystr) 930 { 931 if (*yystr == '"') 932 { 933 YYSIZE_T yyn = 0; 934 char const *yyp = yystr; 935 936 for (;;) 937 switch (*++yyp) 938 { 939 case '\'': 940 case ',': 941 goto do_not_strip_quotes; 942 943 case '\\': 944 if (*++yyp != '\\') 945 goto do_not_strip_quotes; 946 /* Fall through. */ 947 default: 948 if (yyres) 949 yyres[yyn] = *yyp; 950 yyn++; 951 break; 952 953 case '"': 954 if (yyres) 955 yyres[yyn] = '\0'; 956 return yyn; 957 } 958 do_not_strip_quotes: ; 959 } 960 961 if (! yyres) 962 return yystrlen (yystr); 963 964 return yystpcpy (yyres, yystr) - yyres; 965 } 966 # endif 967 968 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 969 about the unexpected token YYTOKEN for the state stack whose top is 970 YYSSP. 971 972 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 973 not large enough to hold the message. In that case, also set 974 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 975 required number of bytes is too large to store. */ 976 static int 977 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 978 yytype_int16 *yyssp, int yytoken) 979 { 980 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 981 YYSIZE_T yysize = yysize0; 982 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 983 /* Internationalized format string. */ 984 const char *yyformat = YY_NULLPTR; 985 /* Arguments of yyformat. */ 986 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 987 /* Number of reported tokens (one for the "unexpected", one per 988 "expected"). */ 989 int yycount = 0; 990 991 /* There are many possibilities here to consider: 992 - If this state is a consistent state with a default action, then 993 the only way this function was invoked is if the default action 994 is an error action. In that case, don't check for expected 995 tokens because there are none. 996 - The only way there can be no lookahead present (in yychar) is if 997 this state is a consistent state with a default action. Thus, 998 detecting the absence of a lookahead is sufficient to determine 999 that there is no unexpected or expected token to report. In that 1000 case, just report a simple "syntax error". 1001 - Don't assume there isn't a lookahead just because this state is a 1002 consistent state with a default action. There might have been a 1003 previous inconsistent state, consistent state with a non-default 1004 action, or user semantic action that manipulated yychar. 1005 - Of course, the expected token list depends on states to have 1006 correct lookahead information, and it depends on the parser not 1007 to perform extra reductions after fetching a lookahead from the 1008 scanner and before detecting a syntax error. Thus, state merging 1009 (from LALR or IELR) and default reductions corrupt the expected 1010 token list. However, the list is correct for canonical LR with 1011 one exception: it will still contain any token that will not be 1012 accepted due to an error action in a later state. 1013 */ 1014 if (yytoken != YYEMPTY) 1015 { 1016 int yyn = yypact[*yyssp]; 1017 yyarg[yycount++] = yytname[yytoken]; 1018 if (!yypact_value_is_default (yyn)) 1019 { 1020 /* Start YYX at -YYN if negative to avoid negative indexes in 1021 YYCHECK. In other words, skip the first -YYN actions for 1022 this state because they are default actions. */ 1023 int yyxbegin = yyn < 0 ? -yyn : 0; 1024 /* Stay within bounds of both yycheck and yytname. */ 1025 int yychecklim = YYLAST - yyn + 1; 1026 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1027 int yyx; 1028 1029 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1030 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1031 && !yytable_value_is_error (yytable[yyx + yyn])) 1032 { 1033 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1034 { 1035 yycount = 1; 1036 yysize = yysize0; 1037 break; 1038 } 1039 yyarg[yycount++] = yytname[yyx]; 1040 { 1041 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 1042 if (! (yysize <= yysize1 1043 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1044 return 2; 1045 yysize = yysize1; 1046 } 1047 } 1048 } 1049 } 1050 1051 switch (yycount) 1052 { 1053 # define YYCASE_(N, S) \ 1054 case N: \ 1055 yyformat = S; \ 1056 break 1057 default: /* Avoid compiler warnings. */ 1058 YYCASE_(0, YY_("syntax error")); 1059 YYCASE_(1, YY_("syntax error, unexpected %s")); 1060 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1061 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1062 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1063 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1064 # undef YYCASE_ 1065 } 1066 1067 { 1068 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 1069 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1070 return 2; 1071 yysize = yysize1; 1072 } 1073 1074 if (*yymsg_alloc < yysize) 1075 { 1076 *yymsg_alloc = 2 * yysize; 1077 if (! (yysize <= *yymsg_alloc 1078 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1079 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1080 return 1; 1081 } 1082 1083 /* Avoid sprintf, as that infringes on the user's name space. 1084 Don't have undefined behavior even if the translation 1085 produced a string with the wrong number of "%s"s. */ 1086 { 1087 char *yyp = *yymsg; 1088 int yyi = 0; 1089 while ((*yyp = *yyformat) != '\0') 1090 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1091 { 1092 yyp += yytnamerr (yyp, yyarg[yyi++]); 1093 yyformat += 2; 1094 } 1095 else 1096 { 1097 yyp++; 1098 yyformat++; 1099 } 1100 } 1101 return 0; 1102 } 1103 #endif /* YYERROR_VERBOSE */ 1104 1105 /*-----------------------------------------------. 1106 | Release the memory associated to this symbol. | 1107 `-----------------------------------------------*/ 1108 1109 static void 1110 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1111 { 1112 YYUSE (yyvaluep); 1113 if (!yymsg) 1114 yymsg = "Deleting"; 1115 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1116 1117 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1118 YYUSE (yytype); 1119 YY_IGNORE_MAYBE_UNINITIALIZED_END 1120 } 1121 1122 1123 1124 1125 /* The lookahead symbol. */ 1126 int yychar; 1127 1128 /* The semantic value of the lookahead symbol. */ 1129 YYSTYPE yylval; 1130 /* Number of syntax errors so far. */ 1131 int yynerrs; 1132 1133 1134 /*----------. 1135 | yyparse. | 1136 `----------*/ 1137 1138 int 1139 yyparse (void) 1140 { 1141 int yystate; 1142 /* Number of tokens to shift before error messages enabled. */ 1143 int yyerrstatus; 1144 1145 /* The stacks and their tools: 1146 'yyss': related to states. 1147 'yyvs': related to semantic values. 1148 1149 Refer to the stacks through separate pointers, to allow yyoverflow 1150 to reallocate them elsewhere. */ 1151 1152 /* The state stack. */ 1153 yytype_int16 yyssa[YYINITDEPTH]; 1154 yytype_int16 *yyss; 1155 yytype_int16 *yyssp; 1156 1157 /* The semantic value stack. */ 1158 YYSTYPE yyvsa[YYINITDEPTH]; 1159 YYSTYPE *yyvs; 1160 YYSTYPE *yyvsp; 1161 1162 YYSIZE_T yystacksize; 1163 1164 int yyn; 1165 int yyresult; 1166 /* Lookahead token as an internal (translated) token number. */ 1167 int yytoken = 0; 1168 /* The variables used to return semantic value and location from the 1169 action routines. */ 1170 YYSTYPE yyval; 1171 1172 #if YYERROR_VERBOSE 1173 /* Buffer for error messages, and its allocated size. */ 1174 char yymsgbuf[128]; 1175 char *yymsg = yymsgbuf; 1176 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1177 #endif 1178 1179 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1180 1181 /* The number of symbols on the RHS of the reduced rule. 1182 Keep to zero when no symbol should be popped. */ 1183 int yylen = 0; 1184 1185 yyssp = yyss = yyssa; 1186 yyvsp = yyvs = yyvsa; 1187 yystacksize = YYINITDEPTH; 1188 1189 YYDPRINTF ((stderr, "Starting parse\n")); 1190 1191 yystate = 0; 1192 yyerrstatus = 0; 1193 yynerrs = 0; 1194 yychar = YYEMPTY; /* Cause a token to be read. */ 1195 goto yysetstate; 1196 1197 /*------------------------------------------------------------. 1198 | yynewstate -- Push a new state, which is found in yystate. | 1199 `------------------------------------------------------------*/ 1200 yynewstate: 1201 /* In all cases, when you get here, the value and location stacks 1202 have just been pushed. So pushing a state here evens the stacks. */ 1203 yyssp++; 1204 1205 yysetstate: 1206 *yyssp = yystate; 1207 1208 if (yyss + yystacksize - 1 <= yyssp) 1209 { 1210 /* Get the current used size of the three stacks, in elements. */ 1211 YYSIZE_T yysize = yyssp - yyss + 1; 1212 1213 #ifdef yyoverflow 1214 { 1215 /* Give user a chance to reallocate the stack. Use copies of 1216 these so that the &'s don't force the real ones into 1217 memory. */ 1218 YYSTYPE *yyvs1 = yyvs; 1219 yytype_int16 *yyss1 = yyss; 1220 1221 /* Each stack pointer address is followed by the size of the 1222 data in use in that stack, in bytes. This used to be a 1223 conditional around just the two extra args, but that might 1224 be undefined if yyoverflow is a macro. */ 1225 yyoverflow (YY_("memory exhausted"), 1226 &yyss1, yysize * sizeof (*yyssp), 1227 &yyvs1, yysize * sizeof (*yyvsp), 1228 &yystacksize); 1229 1230 yyss = yyss1; 1231 yyvs = yyvs1; 1232 } 1233 #else /* no yyoverflow */ 1234 # ifndef YYSTACK_RELOCATE 1235 goto yyexhaustedlab; 1236 # else 1237 /* Extend the stack our own way. */ 1238 if (YYMAXDEPTH <= yystacksize) 1239 goto yyexhaustedlab; 1240 yystacksize *= 2; 1241 if (YYMAXDEPTH < yystacksize) 1242 yystacksize = YYMAXDEPTH; 1243 1244 { 1245 yytype_int16 *yyss1 = yyss; 1246 union yyalloc *yyptr = 1247 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1248 if (! yyptr) 1249 goto yyexhaustedlab; 1250 YYSTACK_RELOCATE (yyss_alloc, yyss); 1251 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1252 # undef YYSTACK_RELOCATE 1253 if (yyss1 != yyssa) 1254 YYSTACK_FREE (yyss1); 1255 } 1256 # endif 1257 #endif /* no yyoverflow */ 1258 1259 yyssp = yyss + yysize - 1; 1260 yyvsp = yyvs + yysize - 1; 1261 1262 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1263 (unsigned long int) yystacksize)); 1264 1265 if (yyss + yystacksize - 1 <= yyssp) 1266 YYABORT; 1267 } 1268 1269 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1270 1271 if (yystate == YYFINAL) 1272 YYACCEPT; 1273 1274 goto yybackup; 1275 1276 /*-----------. 1277 | yybackup. | 1278 `-----------*/ 1279 yybackup: 1280 1281 /* Do appropriate processing given the current state. Read a 1282 lookahead token if we need one and don't already have one. */ 1283 1284 /* First try to decide what to do without reference to lookahead token. */ 1285 yyn = yypact[yystate]; 1286 if (yypact_value_is_default (yyn)) 1287 goto yydefault; 1288 1289 /* Not known => get a lookahead token if don't already have one. */ 1290 1291 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1292 if (yychar == YYEMPTY) 1293 { 1294 YYDPRINTF ((stderr, "Reading a token: ")); 1295 yychar = yylex (); 1296 } 1297 1298 if (yychar <= YYEOF) 1299 { 1300 yychar = yytoken = YYEOF; 1301 YYDPRINTF ((stderr, "Now at end of input.\n")); 1302 } 1303 else 1304 { 1305 yytoken = YYTRANSLATE (yychar); 1306 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1307 } 1308 1309 /* If the proper action on seeing token YYTOKEN is to reduce or to 1310 detect an error, take that action. */ 1311 yyn += yytoken; 1312 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1313 goto yydefault; 1314 yyn = yytable[yyn]; 1315 if (yyn <= 0) 1316 { 1317 if (yytable_value_is_error (yyn)) 1318 goto yyerrlab; 1319 yyn = -yyn; 1320 goto yyreduce; 1321 } 1322 1323 /* Count tokens shifted since error; after three, turn off error 1324 status. */ 1325 if (yyerrstatus) 1326 yyerrstatus--; 1327 1328 /* Shift the lookahead token. */ 1329 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1330 1331 /* Discard the shifted token. */ 1332 yychar = YYEMPTY; 1333 1334 yystate = yyn; 1335 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1336 *++yyvsp = yylval; 1337 YY_IGNORE_MAYBE_UNINITIALIZED_END 1338 1339 goto yynewstate; 1340 1341 1342 /*-----------------------------------------------------------. 1343 | yydefault -- do the default action for the current state. | 1344 `-----------------------------------------------------------*/ 1345 yydefault: 1346 yyn = yydefact[yystate]; 1347 if (yyn == 0) 1348 goto yyerrlab; 1349 goto yyreduce; 1350 1351 1352 /*-----------------------------. 1353 | yyreduce -- Do a reduction. | 1354 `-----------------------------*/ 1355 yyreduce: 1356 /* yyn is the number of a rule to reduce with. */ 1357 yylen = yyr2[yyn]; 1358 1359 /* If YYLEN is nonzero, implement the default value of the action: 1360 '$$ = $1'. 1361 1362 Otherwise, the following line sets YYVAL to garbage. 1363 This behavior is undocumented and Bison 1364 users should not rely upon it. Assigning to YYVAL 1365 unconditionally makes the parser a bit smaller, and it avoids a 1366 GCC warning that YYVAL may be used uninitialized. */ 1367 yyval = yyvsp[1-yylen]; 1368 1369 1370 YY_REDUCE_PRINT (yyn); 1371 switch (yyn) 1372 { 1373 case 7: 1374 #line 76 "mcparse.y" /* yacc.c:1648 */ 1375 { 1376 cur_node = mc_add_node (); 1377 cur_node->user_text = (yyvsp[0].ustr); 1378 } 1379 #line 1380 "mcparse.c" /* yacc.c:1648 */ 1380 break; 1381 1382 case 8: 1383 #line 80 "mcparse.y" /* yacc.c:1648 */ 1384 { mc_fatal ("syntax error"); } 1385 #line 1386 "mcparse.c" /* yacc.c:1648 */ 1386 break; 1387 1388 case 10: 1389 #line 85 "mcparse.y" /* yacc.c:1648 */ 1390 { mc_fatal ("missing ')' in SeverityNames"); } 1391 #line 1392 "mcparse.c" /* yacc.c:1648 */ 1392 break; 1393 1394 case 11: 1395 #line 86 "mcparse.y" /* yacc.c:1648 */ 1396 { mc_fatal ("missing '(' in SeverityNames"); } 1397 #line 1398 "mcparse.c" /* yacc.c:1648 */ 1398 break; 1399 1400 case 12: 1401 #line 87 "mcparse.y" /* yacc.c:1648 */ 1402 { mc_fatal ("missing '=' for SeverityNames"); } 1403 #line 1404 "mcparse.c" /* yacc.c:1648 */ 1404 break; 1405 1406 case 14: 1407 #line 89 "mcparse.y" /* yacc.c:1648 */ 1408 { mc_fatal ("missing ')' in LanguageNames"); } 1409 #line 1410 "mcparse.c" /* yacc.c:1648 */ 1410 break; 1411 1412 case 15: 1413 #line 90 "mcparse.y" /* yacc.c:1648 */ 1414 { mc_fatal ("missing '(' in LanguageNames"); } 1415 #line 1416 "mcparse.c" /* yacc.c:1648 */ 1416 break; 1417 1418 case 16: 1419 #line 91 "mcparse.y" /* yacc.c:1648 */ 1420 { mc_fatal ("missing '=' for LanguageNames"); } 1421 #line 1422 "mcparse.c" /* yacc.c:1648 */ 1422 break; 1423 1424 case 18: 1425 #line 93 "mcparse.y" /* yacc.c:1648 */ 1426 { mc_fatal ("missing ')' in FacilityNames"); } 1427 #line 1428 "mcparse.c" /* yacc.c:1648 */ 1428 break; 1429 1430 case 19: 1431 #line 94 "mcparse.y" /* yacc.c:1648 */ 1432 { mc_fatal ("missing '(' in FacilityNames"); } 1433 #line 1434 "mcparse.c" /* yacc.c:1648 */ 1434 break; 1435 1436 case 20: 1437 #line 95 "mcparse.y" /* yacc.c:1648 */ 1438 { mc_fatal ("missing '=' for FacilityNames"); } 1439 #line 1440 "mcparse.c" /* yacc.c:1648 */ 1440 break; 1441 1442 case 21: 1443 #line 97 "mcparse.y" /* yacc.c:1648 */ 1444 { 1445 if ((yyvsp[0].ival) != 10 && (yyvsp[0].ival) != 16) 1446 mc_fatal ("OutputBase allows 10 or 16 as value"); 1447 mcset_out_values_are_decimal = ((yyvsp[0].ival) == 10 ? 1 : 0); 1448 } 1449 #line 1450 "mcparse.c" /* yacc.c:1648 */ 1450 break; 1451 1452 case 22: 1453 #line 103 "mcparse.y" /* yacc.c:1648 */ 1454 { 1455 mcset_msg_id_typedef = (yyvsp[0].ustr); 1456 } 1457 #line 1458 "mcparse.c" /* yacc.c:1648 */ 1458 break; 1459 1460 case 23: 1461 #line 107 "mcparse.y" /* yacc.c:1648 */ 1462 { 1463 mc_fatal ("MessageIdTypedef expects an identifier"); 1464 } 1465 #line 1466 "mcparse.c" /* yacc.c:1648 */ 1466 break; 1467 1468 case 24: 1469 #line 111 "mcparse.y" /* yacc.c:1648 */ 1470 { 1471 mc_fatal ("missing '=' for MessageIdTypedef"); 1472 } 1473 #line 1474 "mcparse.c" /* yacc.c:1648 */ 1474 break; 1475 1476 case 27: 1477 #line 119 "mcparse.y" /* yacc.c:1648 */ 1478 { mc_fatal ("severity ident missing"); } 1479 #line 1480 "mcparse.c" /* yacc.c:1648 */ 1480 break; 1481 1482 case 28: 1483 #line 124 "mcparse.y" /* yacc.c:1648 */ 1484 { 1485 mc_add_keyword ((yyvsp[-3].ustr), MCTOKEN, "severity", (yyvsp[-1].ival), (yyvsp[0].ustr)); 1486 } 1487 #line 1488 "mcparse.c" /* yacc.c:1648 */ 1488 break; 1489 1490 case 29: 1491 #line 127 "mcparse.y" /* yacc.c:1648 */ 1492 { mc_fatal ("severity number missing"); } 1493 #line 1494 "mcparse.c" /* yacc.c:1648 */ 1494 break; 1495 1496 case 30: 1497 #line 128 "mcparse.y" /* yacc.c:1648 */ 1498 { mc_fatal ("severity missing '='"); } 1499 #line 1500 "mcparse.c" /* yacc.c:1648 */ 1500 break; 1501 1502 case 33: 1503 #line 134 "mcparse.y" /* yacc.c:1648 */ 1504 { mc_fatal ("missing ident in FacilityNames"); } 1505 #line 1506 "mcparse.c" /* yacc.c:1648 */ 1506 break; 1507 1508 case 34: 1509 #line 139 "mcparse.y" /* yacc.c:1648 */ 1510 { 1511 mc_add_keyword ((yyvsp[-3].ustr), MCTOKEN, "facility", (yyvsp[-1].ival), (yyvsp[0].ustr)); 1512 } 1513 #line 1514 "mcparse.c" /* yacc.c:1648 */ 1514 break; 1515 1516 case 35: 1517 #line 142 "mcparse.y" /* yacc.c:1648 */ 1518 { mc_fatal ("facility number missing"); } 1519 #line 1520 "mcparse.c" /* yacc.c:1648 */ 1520 break; 1521 1522 case 36: 1523 #line 143 "mcparse.y" /* yacc.c:1648 */ 1524 { mc_fatal ("facility missing '='"); } 1525 #line 1526 "mcparse.c" /* yacc.c:1648 */ 1526 break; 1527 1528 case 39: 1529 #line 149 "mcparse.y" /* yacc.c:1648 */ 1530 { mc_fatal ("missing ident in LanguageNames"); } 1531 #line 1532 "mcparse.c" /* yacc.c:1648 */ 1532 break; 1533 1534 case 40: 1535 #line 154 "mcparse.y" /* yacc.c:1648 */ 1536 { 1537 mc_add_keyword ((yyvsp[-5].ustr), MCTOKEN, "language", (yyvsp[-3].ival), (yyvsp[0].ustr)); 1538 } 1539 #line 1540 "mcparse.c" /* yacc.c:1648 */ 1540 break; 1541 1542 case 41: 1543 #line 157 "mcparse.y" /* yacc.c:1648 */ 1544 { mc_fatal ("missing filename in LanguageNames"); } 1545 #line 1546 "mcparse.c" /* yacc.c:1648 */ 1546 break; 1547 1548 case 42: 1549 #line 158 "mcparse.y" /* yacc.c:1648 */ 1550 { mc_fatal ("missing ':' in LanguageNames"); } 1551 #line 1552 "mcparse.c" /* yacc.c:1648 */ 1552 break; 1553 1554 case 43: 1555 #line 159 "mcparse.y" /* yacc.c:1648 */ 1556 { mc_fatal ("missing language code in LanguageNames"); } 1557 #line 1558 "mcparse.c" /* yacc.c:1648 */ 1558 break; 1559 1560 case 44: 1561 #line 160 "mcparse.y" /* yacc.c:1648 */ 1562 { mc_fatal ("missing '=' for LanguageNames"); } 1563 #line 1564 "mcparse.c" /* yacc.c:1648 */ 1564 break; 1565 1566 case 45: 1567 #line 165 "mcparse.y" /* yacc.c:1648 */ 1568 { 1569 (yyval.ustr) = NULL; 1570 } 1571 #line 1572 "mcparse.c" /* yacc.c:1648 */ 1572 break; 1573 1574 case 46: 1575 #line 169 "mcparse.y" /* yacc.c:1648 */ 1576 { 1577 (yyval.ustr) = (yyvsp[0].ustr); 1578 } 1579 #line 1580 "mcparse.c" /* yacc.c:1648 */ 1580 break; 1581 1582 case 47: 1583 #line 172 "mcparse.y" /* yacc.c:1648 */ 1584 { mc_fatal ("illegal token in identifier"); (yyval.ustr) = NULL; } 1585 #line 1586 "mcparse.c" /* yacc.c:1648 */ 1586 break; 1587 1588 case 48: 1589 #line 177 "mcparse.y" /* yacc.c:1648 */ 1590 { 1591 cur_node = mc_add_node (); 1592 cur_node->symbol = mc_last_symbol; 1593 cur_node->facility = mc_cur_facility; 1594 cur_node->severity = mc_cur_severity; 1595 cur_node->id = ((yyvsp[-1].ival) & 0xffffUL); 1596 cur_node->vid = ((yyvsp[-1].ival) & 0xffffUL) | mc_sefa_val; 1597 mc_last_id = (yyvsp[-1].ival); 1598 } 1599 #line 1600 "mcparse.c" /* yacc.c:1648 */ 1600 break; 1601 1602 case 50: 1603 #line 189 "mcparse.y" /* yacc.c:1648 */ 1604 { (yyval.ival) = (yyvsp[0].ival); } 1605 #line 1606 "mcparse.c" /* yacc.c:1648 */ 1606 break; 1607 1608 case 51: 1609 #line 190 "mcparse.y" /* yacc.c:1648 */ 1610 { mc_fatal ("missing number in MessageId"); (yyval.ival) = 0; } 1611 #line 1612 "mcparse.c" /* yacc.c:1648 */ 1612 break; 1613 1614 case 52: 1615 #line 191 "mcparse.y" /* yacc.c:1648 */ 1616 { mc_fatal ("missing '=' for MessageId"); (yyval.ival) = 0; } 1617 #line 1618 "mcparse.c" /* yacc.c:1648 */ 1618 break; 1619 1620 case 53: 1621 #line 195 "mcparse.y" /* yacc.c:1648 */ 1622 { 1623 (yyval.ival) = ++mc_last_id; 1624 } 1625 #line 1626 "mcparse.c" /* yacc.c:1648 */ 1626 break; 1627 1628 case 54: 1629 #line 199 "mcparse.y" /* yacc.c:1648 */ 1630 { 1631 (yyval.ival) = (yyvsp[0].ival); 1632 } 1633 #line 1634 "mcparse.c" /* yacc.c:1648 */ 1634 break; 1635 1636 case 55: 1637 #line 203 "mcparse.y" /* yacc.c:1648 */ 1638 { 1639 (yyval.ival) = mc_last_id + (yyvsp[0].ival); 1640 } 1641 #line 1642 "mcparse.c" /* yacc.c:1648 */ 1642 break; 1643 1644 case 56: 1645 #line 206 "mcparse.y" /* yacc.c:1648 */ 1646 { mc_fatal ("missing number after MessageId '+'"); } 1647 #line 1648 "mcparse.c" /* yacc.c:1648 */ 1648 break; 1649 1650 case 57: 1651 #line 211 "mcparse.y" /* yacc.c:1648 */ 1652 { 1653 (yyval.ival) = 0; 1654 mc_sefa_val = (mcset_custom_bit ? 1 : 0) << 29; 1655 mc_last_symbol = NULL; 1656 mc_cur_severity = NULL; 1657 mc_cur_facility = NULL; 1658 } 1659 #line 1660 "mcparse.c" /* yacc.c:1648 */ 1660 break; 1661 1662 case 58: 1663 #line 219 "mcparse.y" /* yacc.c:1648 */ 1664 { 1665 if ((yyvsp[-1].ival) & 1) 1666 mc_warn (_("duplicate definition of Severity")); 1667 (yyval.ival) = (yyvsp[-1].ival) | 1; 1668 } 1669 #line 1670 "mcparse.c" /* yacc.c:1648 */ 1670 break; 1671 1672 case 59: 1673 #line 225 "mcparse.y" /* yacc.c:1648 */ 1674 { 1675 if ((yyvsp[-1].ival) & 2) 1676 mc_warn (_("duplicate definition of Facility")); 1677 (yyval.ival) = (yyvsp[-1].ival) | 2; 1678 } 1679 #line 1680 "mcparse.c" /* yacc.c:1648 */ 1680 break; 1681 1682 case 60: 1683 #line 231 "mcparse.y" /* yacc.c:1648 */ 1684 { 1685 if ((yyvsp[-1].ival) & 4) 1686 mc_warn (_("duplicate definition of SymbolicName")); 1687 (yyval.ival) = (yyvsp[-1].ival) | 4; 1688 } 1689 #line 1690 "mcparse.c" /* yacc.c:1648 */ 1690 break; 1691 1692 case 61: 1693 #line 239 "mcparse.y" /* yacc.c:1648 */ 1694 { 1695 mc_sefa_val &= ~ (0x3UL << 30); 1696 mc_sefa_val |= (((yyvsp[0].tok)->nval & 0x3UL) << 30); 1697 mc_cur_severity = (yyvsp[0].tok); 1698 } 1699 #line 1700 "mcparse.c" /* yacc.c:1648 */ 1700 break; 1701 1702 case 62: 1703 #line 247 "mcparse.y" /* yacc.c:1648 */ 1704 { 1705 mc_sefa_val &= ~ (0xfffUL << 16); 1706 mc_sefa_val |= (((yyvsp[0].tok)->nval & 0xfffUL) << 16); 1707 mc_cur_facility = (yyvsp[0].tok); 1708 } 1709 #line 1710 "mcparse.c" /* yacc.c:1648 */ 1710 break; 1711 1712 case 63: 1713 #line 255 "mcparse.y" /* yacc.c:1648 */ 1714 { 1715 mc_last_symbol = (yyvsp[0].ustr); 1716 } 1717 #line 1718 "mcparse.c" /* yacc.c:1648 */ 1718 break; 1719 1720 case 66: 1721 #line 267 "mcparse.y" /* yacc.c:1648 */ 1722 { 1723 mc_node_lang *h; 1724 h = mc_add_node_lang (cur_node, (yyvsp[-3].tok), cur_node->vid); 1725 h->message = (yyvsp[-1].ustr); 1726 if (mcset_max_message_length != 0 && unichar_len (h->message) > mcset_max_message_length) 1727 mc_warn ("message length to long"); 1728 } 1729 #line 1730 "mcparse.c" /* yacc.c:1648 */ 1730 break; 1731 1732 case 67: 1733 #line 277 "mcparse.y" /* yacc.c:1648 */ 1734 { 1735 (yyval.ustr) = (yyvsp[0].ustr); 1736 } 1737 #line 1738 "mcparse.c" /* yacc.c:1648 */ 1738 break; 1739 1740 case 68: 1741 #line 281 "mcparse.y" /* yacc.c:1648 */ 1742 { 1743 unichar *h; 1744 rc_uint_type l1,l2; 1745 l1 = unichar_len ((yyvsp[-1].ustr)); 1746 l2 = unichar_len ((yyvsp[0].ustr)); 1747 h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar)); 1748 if (l1) memcpy (h, (yyvsp[-1].ustr), l1 * sizeof (unichar)); 1749 if (l2) memcpy (&h[l1], (yyvsp[0].ustr), l2 * sizeof (unichar)); 1750 h[l1 + l2] = 0; 1751 (yyval.ustr) = h; 1752 } 1753 #line 1754 "mcparse.c" /* yacc.c:1648 */ 1754 break; 1755 1756 case 69: 1757 #line 292 "mcparse.y" /* yacc.c:1648 */ 1758 { mc_fatal ("missing end of message text"); (yyval.ustr) = NULL; } 1759 #line 1760 "mcparse.c" /* yacc.c:1648 */ 1760 break; 1761 1762 case 70: 1763 #line 293 "mcparse.y" /* yacc.c:1648 */ 1764 { mc_fatal ("missing end of message text"); (yyval.ustr) = (yyvsp[-1].ustr); } 1765 #line 1766 "mcparse.c" /* yacc.c:1648 */ 1766 break; 1767 1768 case 71: 1769 #line 296 "mcparse.y" /* yacc.c:1648 */ 1770 { (yyval.ustr) = (yyvsp[0].ustr); } 1771 #line 1772 "mcparse.c" /* yacc.c:1648 */ 1772 break; 1773 1774 case 72: 1775 #line 298 "mcparse.y" /* yacc.c:1648 */ 1776 { 1777 unichar *h; 1778 rc_uint_type l1,l2; 1779 l1 = unichar_len ((yyvsp[-1].ustr)); 1780 l2 = unichar_len ((yyvsp[0].ustr)); 1781 h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar)); 1782 if (l1) memcpy (h, (yyvsp[-1].ustr), l1 * sizeof (unichar)); 1783 if (l2) memcpy (&h[l1], (yyvsp[0].ustr), l2 * sizeof (unichar)); 1784 h[l1 + l2] = 0; 1785 (yyval.ustr) = h; 1786 } 1787 #line 1788 "mcparse.c" /* yacc.c:1648 */ 1788 break; 1789 1790 case 73: 1791 #line 312 "mcparse.y" /* yacc.c:1648 */ 1792 { 1793 (yyval.tok) = (yyvsp[-1].tok); 1794 } 1795 #line 1796 "mcparse.c" /* yacc.c:1648 */ 1796 break; 1797 1798 case 74: 1799 #line 316 "mcparse.y" /* yacc.c:1648 */ 1800 { 1801 (yyval.tok) = NULL; 1802 mc_fatal (_("undeclared language identifier")); 1803 } 1804 #line 1805 "mcparse.c" /* yacc.c:1648 */ 1805 break; 1806 1807 case 75: 1808 #line 321 "mcparse.y" /* yacc.c:1648 */ 1809 { 1810 (yyval.tok) = NULL; 1811 mc_fatal ("missing newline after Language"); 1812 } 1813 #line 1814 "mcparse.c" /* yacc.c:1648 */ 1814 break; 1815 1816 case 76: 1817 #line 326 "mcparse.y" /* yacc.c:1648 */ 1818 { 1819 (yyval.tok) = NULL; 1820 mc_fatal ("missing ident for Language"); 1821 } 1822 #line 1823 "mcparse.c" /* yacc.c:1648 */ 1823 break; 1824 1825 case 77: 1826 #line 331 "mcparse.y" /* yacc.c:1648 */ 1827 { 1828 (yyval.tok) = NULL; 1829 mc_fatal ("missing '=' for Language"); 1830 } 1831 #line 1832 "mcparse.c" /* yacc.c:1648 */ 1832 break; 1833 1834 case 78: 1835 #line 337 "mcparse.y" /* yacc.c:1648 */ 1836 { (yyval.ustr) = (yyvsp[0].ustr); } 1837 #line 1838 "mcparse.c" /* yacc.c:1648 */ 1838 break; 1839 1840 case 79: 1841 #line 338 "mcparse.y" /* yacc.c:1648 */ 1842 { (yyval.ustr) = (yyvsp[0].tok)->usz; } 1843 #line 1844 "mcparse.c" /* yacc.c:1648 */ 1844 break; 1845 1846 case 80: 1847 #line 342 "mcparse.y" /* yacc.c:1648 */ 1848 { mclex_want_nl = 1; } 1849 #line 1850 "mcparse.c" /* yacc.c:1648 */ 1850 break; 1851 1852 case 81: 1853 #line 346 "mcparse.y" /* yacc.c:1648 */ 1854 { mclex_want_line = 1; } 1855 #line 1856 "mcparse.c" /* yacc.c:1648 */ 1856 break; 1857 1858 case 82: 1859 #line 350 "mcparse.y" /* yacc.c:1648 */ 1860 { mclex_want_filename = 1; } 1861 #line 1862 "mcparse.c" /* yacc.c:1648 */ 1862 break; 1863 1864 1865 #line 1866 "mcparse.c" /* yacc.c:1648 */ 1866 default: break; 1867 } 1868 /* User semantic actions sometimes alter yychar, and that requires 1869 that yytoken be updated with the new translation. We take the 1870 approach of translating immediately before every use of yytoken. 1871 One alternative is translating here after every semantic action, 1872 but that translation would be missed if the semantic action invokes 1873 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1874 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1875 incorrect destructor might then be invoked immediately. In the 1876 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1877 to an incorrect destructor call or verbose syntax error message 1878 before the lookahead is translated. */ 1879 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1880 1881 YYPOPSTACK (yylen); 1882 yylen = 0; 1883 YY_STACK_PRINT (yyss, yyssp); 1884 1885 *++yyvsp = yyval; 1886 1887 /* Now 'shift' the result of the reduction. Determine what state 1888 that goes to, based on the state we popped back to and the rule 1889 number reduced by. */ 1890 1891 yyn = yyr1[yyn]; 1892 1893 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1894 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1895 yystate = yytable[yystate]; 1896 else 1897 yystate = yydefgoto[yyn - YYNTOKENS]; 1898 1899 goto yynewstate; 1900 1901 1902 /*--------------------------------------. 1903 | yyerrlab -- here on detecting error. | 1904 `--------------------------------------*/ 1905 yyerrlab: 1906 /* Make sure we have latest lookahead translation. See comments at 1907 user semantic actions for why this is necessary. */ 1908 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 1909 1910 /* If not already recovering from an error, report this error. */ 1911 if (!yyerrstatus) 1912 { 1913 ++yynerrs; 1914 #if ! YYERROR_VERBOSE 1915 yyerror (YY_("syntax error")); 1916 #else 1917 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 1918 yyssp, yytoken) 1919 { 1920 char const *yymsgp = YY_("syntax error"); 1921 int yysyntax_error_status; 1922 yysyntax_error_status = YYSYNTAX_ERROR; 1923 if (yysyntax_error_status == 0) 1924 yymsgp = yymsg; 1925 else if (yysyntax_error_status == 1) 1926 { 1927 if (yymsg != yymsgbuf) 1928 YYSTACK_FREE (yymsg); 1929 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 1930 if (!yymsg) 1931 { 1932 yymsg = yymsgbuf; 1933 yymsg_alloc = sizeof yymsgbuf; 1934 yysyntax_error_status = 2; 1935 } 1936 else 1937 { 1938 yysyntax_error_status = YYSYNTAX_ERROR; 1939 yymsgp = yymsg; 1940 } 1941 } 1942 yyerror (yymsgp); 1943 if (yysyntax_error_status == 2) 1944 goto yyexhaustedlab; 1945 } 1946 # undef YYSYNTAX_ERROR 1947 #endif 1948 } 1949 1950 1951 1952 if (yyerrstatus == 3) 1953 { 1954 /* If just tried and failed to reuse lookahead token after an 1955 error, discard it. */ 1956 1957 if (yychar <= YYEOF) 1958 { 1959 /* Return failure if at end of input. */ 1960 if (yychar == YYEOF) 1961 YYABORT; 1962 } 1963 else 1964 { 1965 yydestruct ("Error: discarding", 1966 yytoken, &yylval); 1967 yychar = YYEMPTY; 1968 } 1969 } 1970 1971 /* Else will try to reuse lookahead token after shifting the error 1972 token. */ 1973 goto yyerrlab1; 1974 1975 1976 /*---------------------------------------------------. 1977 | yyerrorlab -- error raised explicitly by YYERROR. | 1978 `---------------------------------------------------*/ 1979 yyerrorlab: 1980 1981 /* Pacify compilers like GCC when the user code never invokes 1982 YYERROR and the label yyerrorlab therefore never appears in user 1983 code. */ 1984 if (/*CONSTCOND*/ 0) 1985 goto yyerrorlab; 1986 1987 /* Do not reclaim the symbols of the rule whose action triggered 1988 this YYERROR. */ 1989 YYPOPSTACK (yylen); 1990 yylen = 0; 1991 YY_STACK_PRINT (yyss, yyssp); 1992 yystate = *yyssp; 1993 goto yyerrlab1; 1994 1995 1996 /*-------------------------------------------------------------. 1997 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1998 `-------------------------------------------------------------*/ 1999 yyerrlab1: 2000 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2001 2002 for (;;) 2003 { 2004 yyn = yypact[yystate]; 2005 if (!yypact_value_is_default (yyn)) 2006 { 2007 yyn += YYTERROR; 2008 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2009 { 2010 yyn = yytable[yyn]; 2011 if (0 < yyn) 2012 break; 2013 } 2014 } 2015 2016 /* Pop the current state because it cannot handle the error token. */ 2017 if (yyssp == yyss) 2018 YYABORT; 2019 2020 2021 yydestruct ("Error: popping", 2022 yystos[yystate], yyvsp); 2023 YYPOPSTACK (1); 2024 yystate = *yyssp; 2025 YY_STACK_PRINT (yyss, yyssp); 2026 } 2027 2028 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2029 *++yyvsp = yylval; 2030 YY_IGNORE_MAYBE_UNINITIALIZED_END 2031 2032 2033 /* Shift the error token. */ 2034 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2035 2036 yystate = yyn; 2037 goto yynewstate; 2038 2039 2040 /*-------------------------------------. 2041 | yyacceptlab -- YYACCEPT comes here. | 2042 `-------------------------------------*/ 2043 yyacceptlab: 2044 yyresult = 0; 2045 goto yyreturn; 2046 2047 /*-----------------------------------. 2048 | yyabortlab -- YYABORT comes here. | 2049 `-----------------------------------*/ 2050 yyabortlab: 2051 yyresult = 1; 2052 goto yyreturn; 2053 2054 #if !defined yyoverflow || YYERROR_VERBOSE 2055 /*-------------------------------------------------. 2056 | yyexhaustedlab -- memory exhaustion comes here. | 2057 `-------------------------------------------------*/ 2058 yyexhaustedlab: 2059 yyerror (YY_("memory exhausted")); 2060 yyresult = 2; 2061 /* Fall through. */ 2062 #endif 2063 2064 yyreturn: 2065 if (yychar != YYEMPTY) 2066 { 2067 /* Make sure we have latest lookahead translation. See comments at 2068 user semantic actions for why this is necessary. */ 2069 yytoken = YYTRANSLATE (yychar); 2070 yydestruct ("Cleanup: discarding lookahead", 2071 yytoken, &yylval); 2072 } 2073 /* Do not reclaim the symbols of the rule whose action triggered 2074 this YYABORT or YYACCEPT. */ 2075 YYPOPSTACK (yylen); 2076 YY_STACK_PRINT (yyss, yyssp); 2077 while (yyssp != yyss) 2078 { 2079 yydestruct ("Cleanup: popping", 2080 yystos[*yyssp], yyvsp); 2081 YYPOPSTACK (1); 2082 } 2083 #ifndef yyoverflow 2084 if (yyss != yyssa) 2085 YYSTACK_FREE (yyss); 2086 #endif 2087 #if YYERROR_VERBOSE 2088 if (yymsg != yymsgbuf) 2089 YYSTACK_FREE (yymsg); 2090 #endif 2091 return yyresult; 2092 } 2093 #line 353 "mcparse.y" /* yacc.c:1907 */ 2094 2095 2096 /* Something else. */ 2097