1 /* A Bison parser, made by GNU Bison 3.0.4. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015 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.4" 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-2018 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 YYCASE_(0, YY_("syntax error")); 1058 YYCASE_(1, YY_("syntax error, unexpected %s")); 1059 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1060 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1061 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1062 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1063 # undef YYCASE_ 1064 } 1065 1066 { 1067 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 1068 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1069 return 2; 1070 yysize = yysize1; 1071 } 1072 1073 if (*yymsg_alloc < yysize) 1074 { 1075 *yymsg_alloc = 2 * yysize; 1076 if (! (yysize <= *yymsg_alloc 1077 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1078 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1079 return 1; 1080 } 1081 1082 /* Avoid sprintf, as that infringes on the user's name space. 1083 Don't have undefined behavior even if the translation 1084 produced a string with the wrong number of "%s"s. */ 1085 { 1086 char *yyp = *yymsg; 1087 int yyi = 0; 1088 while ((*yyp = *yyformat) != '\0') 1089 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1090 { 1091 yyp += yytnamerr (yyp, yyarg[yyi++]); 1092 yyformat += 2; 1093 } 1094 else 1095 { 1096 yyp++; 1097 yyformat++; 1098 } 1099 } 1100 return 0; 1101 } 1102 #endif /* YYERROR_VERBOSE */ 1103 1104 /*-----------------------------------------------. 1105 | Release the memory associated to this symbol. | 1106 `-----------------------------------------------*/ 1107 1108 static void 1109 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1110 { 1111 YYUSE (yyvaluep); 1112 if (!yymsg) 1113 yymsg = "Deleting"; 1114 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1115 1116 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1117 YYUSE (yytype); 1118 YY_IGNORE_MAYBE_UNINITIALIZED_END 1119 } 1120 1121 1122 1123 1124 /* The lookahead symbol. */ 1125 int yychar; 1126 1127 /* The semantic value of the lookahead symbol. */ 1128 YYSTYPE yylval; 1129 /* Number of syntax errors so far. */ 1130 int yynerrs; 1131 1132 1133 /*----------. 1134 | yyparse. | 1135 `----------*/ 1136 1137 int 1138 yyparse (void) 1139 { 1140 int yystate; 1141 /* Number of tokens to shift before error messages enabled. */ 1142 int yyerrstatus; 1143 1144 /* The stacks and their tools: 1145 'yyss': related to states. 1146 'yyvs': related to semantic values. 1147 1148 Refer to the stacks through separate pointers, to allow yyoverflow 1149 to reallocate them elsewhere. */ 1150 1151 /* The state stack. */ 1152 yytype_int16 yyssa[YYINITDEPTH]; 1153 yytype_int16 *yyss; 1154 yytype_int16 *yyssp; 1155 1156 /* The semantic value stack. */ 1157 YYSTYPE yyvsa[YYINITDEPTH]; 1158 YYSTYPE *yyvs; 1159 YYSTYPE *yyvsp; 1160 1161 YYSIZE_T yystacksize; 1162 1163 int yyn; 1164 int yyresult; 1165 /* Lookahead token as an internal (translated) token number. */ 1166 int yytoken = 0; 1167 /* The variables used to return semantic value and location from the 1168 action routines. */ 1169 YYSTYPE yyval; 1170 1171 #if YYERROR_VERBOSE 1172 /* Buffer for error messages, and its allocated size. */ 1173 char yymsgbuf[128]; 1174 char *yymsg = yymsgbuf; 1175 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1176 #endif 1177 1178 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1179 1180 /* The number of symbols on the RHS of the reduced rule. 1181 Keep to zero when no symbol should be popped. */ 1182 int yylen = 0; 1183 1184 yyssp = yyss = yyssa; 1185 yyvsp = yyvs = yyvsa; 1186 yystacksize = YYINITDEPTH; 1187 1188 YYDPRINTF ((stderr, "Starting parse\n")); 1189 1190 yystate = 0; 1191 yyerrstatus = 0; 1192 yynerrs = 0; 1193 yychar = YYEMPTY; /* Cause a token to be read. */ 1194 goto yysetstate; 1195 1196 /*------------------------------------------------------------. 1197 | yynewstate -- Push a new state, which is found in yystate. | 1198 `------------------------------------------------------------*/ 1199 yynewstate: 1200 /* In all cases, when you get here, the value and location stacks 1201 have just been pushed. So pushing a state here evens the stacks. */ 1202 yyssp++; 1203 1204 yysetstate: 1205 *yyssp = yystate; 1206 1207 if (yyss + yystacksize - 1 <= yyssp) 1208 { 1209 /* Get the current used size of the three stacks, in elements. */ 1210 YYSIZE_T yysize = yyssp - yyss + 1; 1211 1212 #ifdef yyoverflow 1213 { 1214 /* Give user a chance to reallocate the stack. Use copies of 1215 these so that the &'s don't force the real ones into 1216 memory. */ 1217 YYSTYPE *yyvs1 = yyvs; 1218 yytype_int16 *yyss1 = yyss; 1219 1220 /* Each stack pointer address is followed by the size of the 1221 data in use in that stack, in bytes. This used to be a 1222 conditional around just the two extra args, but that might 1223 be undefined if yyoverflow is a macro. */ 1224 yyoverflow (YY_("memory exhausted"), 1225 &yyss1, yysize * sizeof (*yyssp), 1226 &yyvs1, yysize * sizeof (*yyvsp), 1227 &yystacksize); 1228 1229 yyss = yyss1; 1230 yyvs = yyvs1; 1231 } 1232 #else /* no yyoverflow */ 1233 # ifndef YYSTACK_RELOCATE 1234 goto yyexhaustedlab; 1235 # else 1236 /* Extend the stack our own way. */ 1237 if (YYMAXDEPTH <= yystacksize) 1238 goto yyexhaustedlab; 1239 yystacksize *= 2; 1240 if (YYMAXDEPTH < yystacksize) 1241 yystacksize = YYMAXDEPTH; 1242 1243 { 1244 yytype_int16 *yyss1 = yyss; 1245 union yyalloc *yyptr = 1246 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1247 if (! yyptr) 1248 goto yyexhaustedlab; 1249 YYSTACK_RELOCATE (yyss_alloc, yyss); 1250 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1251 # undef YYSTACK_RELOCATE 1252 if (yyss1 != yyssa) 1253 YYSTACK_FREE (yyss1); 1254 } 1255 # endif 1256 #endif /* no yyoverflow */ 1257 1258 yyssp = yyss + yysize - 1; 1259 yyvsp = yyvs + yysize - 1; 1260 1261 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1262 (unsigned long int) yystacksize)); 1263 1264 if (yyss + yystacksize - 1 <= yyssp) 1265 YYABORT; 1266 } 1267 1268 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1269 1270 if (yystate == YYFINAL) 1271 YYACCEPT; 1272 1273 goto yybackup; 1274 1275 /*-----------. 1276 | yybackup. | 1277 `-----------*/ 1278 yybackup: 1279 1280 /* Do appropriate processing given the current state. Read a 1281 lookahead token if we need one and don't already have one. */ 1282 1283 /* First try to decide what to do without reference to lookahead token. */ 1284 yyn = yypact[yystate]; 1285 if (yypact_value_is_default (yyn)) 1286 goto yydefault; 1287 1288 /* Not known => get a lookahead token if don't already have one. */ 1289 1290 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1291 if (yychar == YYEMPTY) 1292 { 1293 YYDPRINTF ((stderr, "Reading a token: ")); 1294 yychar = yylex (); 1295 } 1296 1297 if (yychar <= YYEOF) 1298 { 1299 yychar = yytoken = YYEOF; 1300 YYDPRINTF ((stderr, "Now at end of input.\n")); 1301 } 1302 else 1303 { 1304 yytoken = YYTRANSLATE (yychar); 1305 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1306 } 1307 1308 /* If the proper action on seeing token YYTOKEN is to reduce or to 1309 detect an error, take that action. */ 1310 yyn += yytoken; 1311 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1312 goto yydefault; 1313 yyn = yytable[yyn]; 1314 if (yyn <= 0) 1315 { 1316 if (yytable_value_is_error (yyn)) 1317 goto yyerrlab; 1318 yyn = -yyn; 1319 goto yyreduce; 1320 } 1321 1322 /* Count tokens shifted since error; after three, turn off error 1323 status. */ 1324 if (yyerrstatus) 1325 yyerrstatus--; 1326 1327 /* Shift the lookahead token. */ 1328 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1329 1330 /* Discard the shifted token. */ 1331 yychar = YYEMPTY; 1332 1333 yystate = yyn; 1334 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1335 *++yyvsp = yylval; 1336 YY_IGNORE_MAYBE_UNINITIALIZED_END 1337 1338 goto yynewstate; 1339 1340 1341 /*-----------------------------------------------------------. 1342 | yydefault -- do the default action for the current state. | 1343 `-----------------------------------------------------------*/ 1344 yydefault: 1345 yyn = yydefact[yystate]; 1346 if (yyn == 0) 1347 goto yyerrlab; 1348 goto yyreduce; 1349 1350 1351 /*-----------------------------. 1352 | yyreduce -- Do a reduction. | 1353 `-----------------------------*/ 1354 yyreduce: 1355 /* yyn is the number of a rule to reduce with. */ 1356 yylen = yyr2[yyn]; 1357 1358 /* If YYLEN is nonzero, implement the default value of the action: 1359 '$$ = $1'. 1360 1361 Otherwise, the following line sets YYVAL to garbage. 1362 This behavior is undocumented and Bison 1363 users should not rely upon it. Assigning to YYVAL 1364 unconditionally makes the parser a bit smaller, and it avoids a 1365 GCC warning that YYVAL may be used uninitialized. */ 1366 yyval = yyvsp[1-yylen]; 1367 1368 1369 YY_REDUCE_PRINT (yyn); 1370 switch (yyn) 1371 { 1372 case 7: 1373 #line 76 "mcparse.y" /* yacc.c:1646 */ 1374 { 1375 cur_node = mc_add_node (); 1376 cur_node->user_text = (yyvsp[0].ustr); 1377 } 1378 #line 1379 "mcparse.c" /* yacc.c:1646 */ 1379 break; 1380 1381 case 8: 1382 #line 80 "mcparse.y" /* yacc.c:1646 */ 1383 { mc_fatal ("syntax error"); } 1384 #line 1385 "mcparse.c" /* yacc.c:1646 */ 1385 break; 1386 1387 case 10: 1388 #line 85 "mcparse.y" /* yacc.c:1646 */ 1389 { mc_fatal ("missing ')' in SeverityNames"); } 1390 #line 1391 "mcparse.c" /* yacc.c:1646 */ 1391 break; 1392 1393 case 11: 1394 #line 86 "mcparse.y" /* yacc.c:1646 */ 1395 { mc_fatal ("missing '(' in SeverityNames"); } 1396 #line 1397 "mcparse.c" /* yacc.c:1646 */ 1397 break; 1398 1399 case 12: 1400 #line 87 "mcparse.y" /* yacc.c:1646 */ 1401 { mc_fatal ("missing '=' for SeverityNames"); } 1402 #line 1403 "mcparse.c" /* yacc.c:1646 */ 1403 break; 1404 1405 case 14: 1406 #line 89 "mcparse.y" /* yacc.c:1646 */ 1407 { mc_fatal ("missing ')' in LanguageNames"); } 1408 #line 1409 "mcparse.c" /* yacc.c:1646 */ 1409 break; 1410 1411 case 15: 1412 #line 90 "mcparse.y" /* yacc.c:1646 */ 1413 { mc_fatal ("missing '(' in LanguageNames"); } 1414 #line 1415 "mcparse.c" /* yacc.c:1646 */ 1415 break; 1416 1417 case 16: 1418 #line 91 "mcparse.y" /* yacc.c:1646 */ 1419 { mc_fatal ("missing '=' for LanguageNames"); } 1420 #line 1421 "mcparse.c" /* yacc.c:1646 */ 1421 break; 1422 1423 case 18: 1424 #line 93 "mcparse.y" /* yacc.c:1646 */ 1425 { mc_fatal ("missing ')' in FacilityNames"); } 1426 #line 1427 "mcparse.c" /* yacc.c:1646 */ 1427 break; 1428 1429 case 19: 1430 #line 94 "mcparse.y" /* yacc.c:1646 */ 1431 { mc_fatal ("missing '(' in FacilityNames"); } 1432 #line 1433 "mcparse.c" /* yacc.c:1646 */ 1433 break; 1434 1435 case 20: 1436 #line 95 "mcparse.y" /* yacc.c:1646 */ 1437 { mc_fatal ("missing '=' for FacilityNames"); } 1438 #line 1439 "mcparse.c" /* yacc.c:1646 */ 1439 break; 1440 1441 case 21: 1442 #line 97 "mcparse.y" /* yacc.c:1646 */ 1443 { 1444 if ((yyvsp[0].ival) != 10 && (yyvsp[0].ival) != 16) 1445 mc_fatal ("OutputBase allows 10 or 16 as value"); 1446 mcset_out_values_are_decimal = ((yyvsp[0].ival) == 10 ? 1 : 0); 1447 } 1448 #line 1449 "mcparse.c" /* yacc.c:1646 */ 1449 break; 1450 1451 case 22: 1452 #line 103 "mcparse.y" /* yacc.c:1646 */ 1453 { 1454 mcset_msg_id_typedef = (yyvsp[0].ustr); 1455 } 1456 #line 1457 "mcparse.c" /* yacc.c:1646 */ 1457 break; 1458 1459 case 23: 1460 #line 107 "mcparse.y" /* yacc.c:1646 */ 1461 { 1462 mc_fatal ("MessageIdTypedef expects an identifier"); 1463 } 1464 #line 1465 "mcparse.c" /* yacc.c:1646 */ 1465 break; 1466 1467 case 24: 1468 #line 111 "mcparse.y" /* yacc.c:1646 */ 1469 { 1470 mc_fatal ("missing '=' for MessageIdTypedef"); 1471 } 1472 #line 1473 "mcparse.c" /* yacc.c:1646 */ 1473 break; 1474 1475 case 27: 1476 #line 119 "mcparse.y" /* yacc.c:1646 */ 1477 { mc_fatal ("severity ident missing"); } 1478 #line 1479 "mcparse.c" /* yacc.c:1646 */ 1479 break; 1480 1481 case 28: 1482 #line 124 "mcparse.y" /* yacc.c:1646 */ 1483 { 1484 mc_add_keyword ((yyvsp[-3].ustr), MCTOKEN, "severity", (yyvsp[-1].ival), (yyvsp[0].ustr)); 1485 } 1486 #line 1487 "mcparse.c" /* yacc.c:1646 */ 1487 break; 1488 1489 case 29: 1490 #line 127 "mcparse.y" /* yacc.c:1646 */ 1491 { mc_fatal ("severity number missing"); } 1492 #line 1493 "mcparse.c" /* yacc.c:1646 */ 1493 break; 1494 1495 case 30: 1496 #line 128 "mcparse.y" /* yacc.c:1646 */ 1497 { mc_fatal ("severity missing '='"); } 1498 #line 1499 "mcparse.c" /* yacc.c:1646 */ 1499 break; 1500 1501 case 33: 1502 #line 134 "mcparse.y" /* yacc.c:1646 */ 1503 { mc_fatal ("missing ident in FacilityNames"); } 1504 #line 1505 "mcparse.c" /* yacc.c:1646 */ 1505 break; 1506 1507 case 34: 1508 #line 139 "mcparse.y" /* yacc.c:1646 */ 1509 { 1510 mc_add_keyword ((yyvsp[-3].ustr), MCTOKEN, "facility", (yyvsp[-1].ival), (yyvsp[0].ustr)); 1511 } 1512 #line 1513 "mcparse.c" /* yacc.c:1646 */ 1513 break; 1514 1515 case 35: 1516 #line 142 "mcparse.y" /* yacc.c:1646 */ 1517 { mc_fatal ("facility number missing"); } 1518 #line 1519 "mcparse.c" /* yacc.c:1646 */ 1519 break; 1520 1521 case 36: 1522 #line 143 "mcparse.y" /* yacc.c:1646 */ 1523 { mc_fatal ("facility missing '='"); } 1524 #line 1525 "mcparse.c" /* yacc.c:1646 */ 1525 break; 1526 1527 case 39: 1528 #line 149 "mcparse.y" /* yacc.c:1646 */ 1529 { mc_fatal ("missing ident in LanguageNames"); } 1530 #line 1531 "mcparse.c" /* yacc.c:1646 */ 1531 break; 1532 1533 case 40: 1534 #line 154 "mcparse.y" /* yacc.c:1646 */ 1535 { 1536 mc_add_keyword ((yyvsp[-5].ustr), MCTOKEN, "language", (yyvsp[-3].ival), (yyvsp[0].ustr)); 1537 } 1538 #line 1539 "mcparse.c" /* yacc.c:1646 */ 1539 break; 1540 1541 case 41: 1542 #line 157 "mcparse.y" /* yacc.c:1646 */ 1543 { mc_fatal ("missing filename in LanguageNames"); } 1544 #line 1545 "mcparse.c" /* yacc.c:1646 */ 1545 break; 1546 1547 case 42: 1548 #line 158 "mcparse.y" /* yacc.c:1646 */ 1549 { mc_fatal ("missing ':' in LanguageNames"); } 1550 #line 1551 "mcparse.c" /* yacc.c:1646 */ 1551 break; 1552 1553 case 43: 1554 #line 159 "mcparse.y" /* yacc.c:1646 */ 1555 { mc_fatal ("missing language code in LanguageNames"); } 1556 #line 1557 "mcparse.c" /* yacc.c:1646 */ 1557 break; 1558 1559 case 44: 1560 #line 160 "mcparse.y" /* yacc.c:1646 */ 1561 { mc_fatal ("missing '=' for LanguageNames"); } 1562 #line 1563 "mcparse.c" /* yacc.c:1646 */ 1563 break; 1564 1565 case 45: 1566 #line 165 "mcparse.y" /* yacc.c:1646 */ 1567 { 1568 (yyval.ustr) = NULL; 1569 } 1570 #line 1571 "mcparse.c" /* yacc.c:1646 */ 1571 break; 1572 1573 case 46: 1574 #line 169 "mcparse.y" /* yacc.c:1646 */ 1575 { 1576 (yyval.ustr) = (yyvsp[0].ustr); 1577 } 1578 #line 1579 "mcparse.c" /* yacc.c:1646 */ 1579 break; 1580 1581 case 47: 1582 #line 172 "mcparse.y" /* yacc.c:1646 */ 1583 { mc_fatal ("illegal token in identifier"); (yyval.ustr) = NULL; } 1584 #line 1585 "mcparse.c" /* yacc.c:1646 */ 1585 break; 1586 1587 case 48: 1588 #line 177 "mcparse.y" /* yacc.c:1646 */ 1589 { 1590 cur_node = mc_add_node (); 1591 cur_node->symbol = mc_last_symbol; 1592 cur_node->facility = mc_cur_facility; 1593 cur_node->severity = mc_cur_severity; 1594 cur_node->id = ((yyvsp[-1].ival) & 0xffffUL); 1595 cur_node->vid = ((yyvsp[-1].ival) & 0xffffUL) | mc_sefa_val; 1596 mc_last_id = (yyvsp[-1].ival); 1597 } 1598 #line 1599 "mcparse.c" /* yacc.c:1646 */ 1599 break; 1600 1601 case 50: 1602 #line 189 "mcparse.y" /* yacc.c:1646 */ 1603 { (yyval.ival) = (yyvsp[0].ival); } 1604 #line 1605 "mcparse.c" /* yacc.c:1646 */ 1605 break; 1606 1607 case 51: 1608 #line 190 "mcparse.y" /* yacc.c:1646 */ 1609 { mc_fatal ("missing number in MessageId"); (yyval.ival) = 0; } 1610 #line 1611 "mcparse.c" /* yacc.c:1646 */ 1611 break; 1612 1613 case 52: 1614 #line 191 "mcparse.y" /* yacc.c:1646 */ 1615 { mc_fatal ("missing '=' for MessageId"); (yyval.ival) = 0; } 1616 #line 1617 "mcparse.c" /* yacc.c:1646 */ 1617 break; 1618 1619 case 53: 1620 #line 195 "mcparse.y" /* yacc.c:1646 */ 1621 { 1622 (yyval.ival) = ++mc_last_id; 1623 } 1624 #line 1625 "mcparse.c" /* yacc.c:1646 */ 1625 break; 1626 1627 case 54: 1628 #line 199 "mcparse.y" /* yacc.c:1646 */ 1629 { 1630 (yyval.ival) = (yyvsp[0].ival); 1631 } 1632 #line 1633 "mcparse.c" /* yacc.c:1646 */ 1633 break; 1634 1635 case 55: 1636 #line 203 "mcparse.y" /* yacc.c:1646 */ 1637 { 1638 (yyval.ival) = mc_last_id + (yyvsp[0].ival); 1639 } 1640 #line 1641 "mcparse.c" /* yacc.c:1646 */ 1641 break; 1642 1643 case 56: 1644 #line 206 "mcparse.y" /* yacc.c:1646 */ 1645 { mc_fatal ("missing number after MessageId '+'"); } 1646 #line 1647 "mcparse.c" /* yacc.c:1646 */ 1647 break; 1648 1649 case 57: 1650 #line 211 "mcparse.y" /* yacc.c:1646 */ 1651 { 1652 (yyval.ival) = 0; 1653 mc_sefa_val = (mcset_custom_bit ? 1 : 0) << 29; 1654 mc_last_symbol = NULL; 1655 mc_cur_severity = NULL; 1656 mc_cur_facility = NULL; 1657 } 1658 #line 1659 "mcparse.c" /* yacc.c:1646 */ 1659 break; 1660 1661 case 58: 1662 #line 219 "mcparse.y" /* yacc.c:1646 */ 1663 { 1664 if ((yyvsp[-1].ival) & 1) 1665 mc_warn (_("duplicate definition of Severity")); 1666 (yyval.ival) = (yyvsp[-1].ival) | 1; 1667 } 1668 #line 1669 "mcparse.c" /* yacc.c:1646 */ 1669 break; 1670 1671 case 59: 1672 #line 225 "mcparse.y" /* yacc.c:1646 */ 1673 { 1674 if ((yyvsp[-1].ival) & 2) 1675 mc_warn (_("duplicate definition of Facility")); 1676 (yyval.ival) = (yyvsp[-1].ival) | 2; 1677 } 1678 #line 1679 "mcparse.c" /* yacc.c:1646 */ 1679 break; 1680 1681 case 60: 1682 #line 231 "mcparse.y" /* yacc.c:1646 */ 1683 { 1684 if ((yyvsp[-1].ival) & 4) 1685 mc_warn (_("duplicate definition of SymbolicName")); 1686 (yyval.ival) = (yyvsp[-1].ival) | 4; 1687 } 1688 #line 1689 "mcparse.c" /* yacc.c:1646 */ 1689 break; 1690 1691 case 61: 1692 #line 239 "mcparse.y" /* yacc.c:1646 */ 1693 { 1694 mc_sefa_val &= ~ (0x3UL << 30); 1695 mc_sefa_val |= (((yyvsp[0].tok)->nval & 0x3UL) << 30); 1696 mc_cur_severity = (yyvsp[0].tok); 1697 } 1698 #line 1699 "mcparse.c" /* yacc.c:1646 */ 1699 break; 1700 1701 case 62: 1702 #line 247 "mcparse.y" /* yacc.c:1646 */ 1703 { 1704 mc_sefa_val &= ~ (0xfffUL << 16); 1705 mc_sefa_val |= (((yyvsp[0].tok)->nval & 0xfffUL) << 16); 1706 mc_cur_facility = (yyvsp[0].tok); 1707 } 1708 #line 1709 "mcparse.c" /* yacc.c:1646 */ 1709 break; 1710 1711 case 63: 1712 #line 255 "mcparse.y" /* yacc.c:1646 */ 1713 { 1714 mc_last_symbol = (yyvsp[0].ustr); 1715 } 1716 #line 1717 "mcparse.c" /* yacc.c:1646 */ 1717 break; 1718 1719 case 66: 1720 #line 267 "mcparse.y" /* yacc.c:1646 */ 1721 { 1722 mc_node_lang *h; 1723 h = mc_add_node_lang (cur_node, (yyvsp[-3].tok), cur_node->vid); 1724 h->message = (yyvsp[-1].ustr); 1725 if (mcset_max_message_length != 0 && unichar_len (h->message) > mcset_max_message_length) 1726 mc_warn ("message length to long"); 1727 } 1728 #line 1729 "mcparse.c" /* yacc.c:1646 */ 1729 break; 1730 1731 case 67: 1732 #line 277 "mcparse.y" /* yacc.c:1646 */ 1733 { 1734 (yyval.ustr) = (yyvsp[0].ustr); 1735 } 1736 #line 1737 "mcparse.c" /* yacc.c:1646 */ 1737 break; 1738 1739 case 68: 1740 #line 281 "mcparse.y" /* yacc.c:1646 */ 1741 { 1742 unichar *h; 1743 rc_uint_type l1,l2; 1744 l1 = unichar_len ((yyvsp[-1].ustr)); 1745 l2 = unichar_len ((yyvsp[0].ustr)); 1746 h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar)); 1747 if (l1) memcpy (h, (yyvsp[-1].ustr), l1 * sizeof (unichar)); 1748 if (l2) memcpy (&h[l1], (yyvsp[0].ustr), l2 * sizeof (unichar)); 1749 h[l1 + l2] = 0; 1750 (yyval.ustr) = h; 1751 } 1752 #line 1753 "mcparse.c" /* yacc.c:1646 */ 1753 break; 1754 1755 case 69: 1756 #line 292 "mcparse.y" /* yacc.c:1646 */ 1757 { mc_fatal ("missing end of message text"); (yyval.ustr) = NULL; } 1758 #line 1759 "mcparse.c" /* yacc.c:1646 */ 1759 break; 1760 1761 case 70: 1762 #line 293 "mcparse.y" /* yacc.c:1646 */ 1763 { mc_fatal ("missing end of message text"); (yyval.ustr) = (yyvsp[-1].ustr); } 1764 #line 1765 "mcparse.c" /* yacc.c:1646 */ 1765 break; 1766 1767 case 71: 1768 #line 296 "mcparse.y" /* yacc.c:1646 */ 1769 { (yyval.ustr) = (yyvsp[0].ustr); } 1770 #line 1771 "mcparse.c" /* yacc.c:1646 */ 1771 break; 1772 1773 case 72: 1774 #line 298 "mcparse.y" /* yacc.c:1646 */ 1775 { 1776 unichar *h; 1777 rc_uint_type l1,l2; 1778 l1 = unichar_len ((yyvsp[-1].ustr)); 1779 l2 = unichar_len ((yyvsp[0].ustr)); 1780 h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar)); 1781 if (l1) memcpy (h, (yyvsp[-1].ustr), l1 * sizeof (unichar)); 1782 if (l2) memcpy (&h[l1], (yyvsp[0].ustr), l2 * sizeof (unichar)); 1783 h[l1 + l2] = 0; 1784 (yyval.ustr) = h; 1785 } 1786 #line 1787 "mcparse.c" /* yacc.c:1646 */ 1787 break; 1788 1789 case 73: 1790 #line 312 "mcparse.y" /* yacc.c:1646 */ 1791 { 1792 (yyval.tok) = (yyvsp[-1].tok); 1793 } 1794 #line 1795 "mcparse.c" /* yacc.c:1646 */ 1795 break; 1796 1797 case 74: 1798 #line 316 "mcparse.y" /* yacc.c:1646 */ 1799 { 1800 (yyval.tok) = NULL; 1801 mc_fatal (_("undeclared language identifier")); 1802 } 1803 #line 1804 "mcparse.c" /* yacc.c:1646 */ 1804 break; 1805 1806 case 75: 1807 #line 321 "mcparse.y" /* yacc.c:1646 */ 1808 { 1809 (yyval.tok) = NULL; 1810 mc_fatal ("missing newline after Language"); 1811 } 1812 #line 1813 "mcparse.c" /* yacc.c:1646 */ 1813 break; 1814 1815 case 76: 1816 #line 326 "mcparse.y" /* yacc.c:1646 */ 1817 { 1818 (yyval.tok) = NULL; 1819 mc_fatal ("missing ident for Language"); 1820 } 1821 #line 1822 "mcparse.c" /* yacc.c:1646 */ 1822 break; 1823 1824 case 77: 1825 #line 331 "mcparse.y" /* yacc.c:1646 */ 1826 { 1827 (yyval.tok) = NULL; 1828 mc_fatal ("missing '=' for Language"); 1829 } 1830 #line 1831 "mcparse.c" /* yacc.c:1646 */ 1831 break; 1832 1833 case 78: 1834 #line 337 "mcparse.y" /* yacc.c:1646 */ 1835 { (yyval.ustr) = (yyvsp[0].ustr); } 1836 #line 1837 "mcparse.c" /* yacc.c:1646 */ 1837 break; 1838 1839 case 79: 1840 #line 338 "mcparse.y" /* yacc.c:1646 */ 1841 { (yyval.ustr) = (yyvsp[0].tok)->usz; } 1842 #line 1843 "mcparse.c" /* yacc.c:1646 */ 1843 break; 1844 1845 case 80: 1846 #line 342 "mcparse.y" /* yacc.c:1646 */ 1847 { mclex_want_nl = 1; } 1848 #line 1849 "mcparse.c" /* yacc.c:1646 */ 1849 break; 1850 1851 case 81: 1852 #line 346 "mcparse.y" /* yacc.c:1646 */ 1853 { mclex_want_line = 1; } 1854 #line 1855 "mcparse.c" /* yacc.c:1646 */ 1855 break; 1856 1857 case 82: 1858 #line 350 "mcparse.y" /* yacc.c:1646 */ 1859 { mclex_want_filename = 1; } 1860 #line 1861 "mcparse.c" /* yacc.c:1646 */ 1861 break; 1862 1863 1864 #line 1865 "mcparse.c" /* yacc.c:1646 */ 1865 default: break; 1866 } 1867 /* User semantic actions sometimes alter yychar, and that requires 1868 that yytoken be updated with the new translation. We take the 1869 approach of translating immediately before every use of yytoken. 1870 One alternative is translating here after every semantic action, 1871 but that translation would be missed if the semantic action invokes 1872 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1873 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1874 incorrect destructor might then be invoked immediately. In the 1875 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1876 to an incorrect destructor call or verbose syntax error message 1877 before the lookahead is translated. */ 1878 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1879 1880 YYPOPSTACK (yylen); 1881 yylen = 0; 1882 YY_STACK_PRINT (yyss, yyssp); 1883 1884 *++yyvsp = yyval; 1885 1886 /* Now 'shift' the result of the reduction. Determine what state 1887 that goes to, based on the state we popped back to and the rule 1888 number reduced by. */ 1889 1890 yyn = yyr1[yyn]; 1891 1892 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1893 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1894 yystate = yytable[yystate]; 1895 else 1896 yystate = yydefgoto[yyn - YYNTOKENS]; 1897 1898 goto yynewstate; 1899 1900 1901 /*--------------------------------------. 1902 | yyerrlab -- here on detecting error. | 1903 `--------------------------------------*/ 1904 yyerrlab: 1905 /* Make sure we have latest lookahead translation. See comments at 1906 user semantic actions for why this is necessary. */ 1907 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 1908 1909 /* If not already recovering from an error, report this error. */ 1910 if (!yyerrstatus) 1911 { 1912 ++yynerrs; 1913 #if ! YYERROR_VERBOSE 1914 yyerror (YY_("syntax error")); 1915 #else 1916 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 1917 yyssp, yytoken) 1918 { 1919 char const *yymsgp = YY_("syntax error"); 1920 int yysyntax_error_status; 1921 yysyntax_error_status = YYSYNTAX_ERROR; 1922 if (yysyntax_error_status == 0) 1923 yymsgp = yymsg; 1924 else if (yysyntax_error_status == 1) 1925 { 1926 if (yymsg != yymsgbuf) 1927 YYSTACK_FREE (yymsg); 1928 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 1929 if (!yymsg) 1930 { 1931 yymsg = yymsgbuf; 1932 yymsg_alloc = sizeof yymsgbuf; 1933 yysyntax_error_status = 2; 1934 } 1935 else 1936 { 1937 yysyntax_error_status = YYSYNTAX_ERROR; 1938 yymsgp = yymsg; 1939 } 1940 } 1941 yyerror (yymsgp); 1942 if (yysyntax_error_status == 2) 1943 goto yyexhaustedlab; 1944 } 1945 # undef YYSYNTAX_ERROR 1946 #endif 1947 } 1948 1949 1950 1951 if (yyerrstatus == 3) 1952 { 1953 /* If just tried and failed to reuse lookahead token after an 1954 error, discard it. */ 1955 1956 if (yychar <= YYEOF) 1957 { 1958 /* Return failure if at end of input. */ 1959 if (yychar == YYEOF) 1960 YYABORT; 1961 } 1962 else 1963 { 1964 yydestruct ("Error: discarding", 1965 yytoken, &yylval); 1966 yychar = YYEMPTY; 1967 } 1968 } 1969 1970 /* Else will try to reuse lookahead token after shifting the error 1971 token. */ 1972 goto yyerrlab1; 1973 1974 1975 /*---------------------------------------------------. 1976 | yyerrorlab -- error raised explicitly by YYERROR. | 1977 `---------------------------------------------------*/ 1978 yyerrorlab: 1979 1980 /* Pacify compilers like GCC when the user code never invokes 1981 YYERROR and the label yyerrorlab therefore never appears in user 1982 code. */ 1983 if (/*CONSTCOND*/ 0) 1984 goto yyerrorlab; 1985 1986 /* Do not reclaim the symbols of the rule whose action triggered 1987 this YYERROR. */ 1988 YYPOPSTACK (yylen); 1989 yylen = 0; 1990 YY_STACK_PRINT (yyss, yyssp); 1991 yystate = *yyssp; 1992 goto yyerrlab1; 1993 1994 1995 /*-------------------------------------------------------------. 1996 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1997 `-------------------------------------------------------------*/ 1998 yyerrlab1: 1999 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2000 2001 for (;;) 2002 { 2003 yyn = yypact[yystate]; 2004 if (!yypact_value_is_default (yyn)) 2005 { 2006 yyn += YYTERROR; 2007 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2008 { 2009 yyn = yytable[yyn]; 2010 if (0 < yyn) 2011 break; 2012 } 2013 } 2014 2015 /* Pop the current state because it cannot handle the error token. */ 2016 if (yyssp == yyss) 2017 YYABORT; 2018 2019 2020 yydestruct ("Error: popping", 2021 yystos[yystate], yyvsp); 2022 YYPOPSTACK (1); 2023 yystate = *yyssp; 2024 YY_STACK_PRINT (yyss, yyssp); 2025 } 2026 2027 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2028 *++yyvsp = yylval; 2029 YY_IGNORE_MAYBE_UNINITIALIZED_END 2030 2031 2032 /* Shift the error token. */ 2033 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2034 2035 yystate = yyn; 2036 goto yynewstate; 2037 2038 2039 /*-------------------------------------. 2040 | yyacceptlab -- YYACCEPT comes here. | 2041 `-------------------------------------*/ 2042 yyacceptlab: 2043 yyresult = 0; 2044 goto yyreturn; 2045 2046 /*-----------------------------------. 2047 | yyabortlab -- YYABORT comes here. | 2048 `-----------------------------------*/ 2049 yyabortlab: 2050 yyresult = 1; 2051 goto yyreturn; 2052 2053 #if !defined yyoverflow || YYERROR_VERBOSE 2054 /*-------------------------------------------------. 2055 | yyexhaustedlab -- memory exhaustion comes here. | 2056 `-------------------------------------------------*/ 2057 yyexhaustedlab: 2058 yyerror (YY_("memory exhausted")); 2059 yyresult = 2; 2060 /* Fall through. */ 2061 #endif 2062 2063 yyreturn: 2064 if (yychar != YYEMPTY) 2065 { 2066 /* Make sure we have latest lookahead translation. See comments at 2067 user semantic actions for why this is necessary. */ 2068 yytoken = YYTRANSLATE (yychar); 2069 yydestruct ("Cleanup: discarding lookahead", 2070 yytoken, &yylval); 2071 } 2072 /* Do not reclaim the symbols of the rule whose action triggered 2073 this YYABORT or YYACCEPT. */ 2074 YYPOPSTACK (yylen); 2075 YY_STACK_PRINT (yyss, yyssp); 2076 while (yyssp != yyss) 2077 { 2078 yydestruct ("Cleanup: popping", 2079 yystos[*yyssp], yyvsp); 2080 YYPOPSTACK (1); 2081 } 2082 #ifndef yyoverflow 2083 if (yyss != yyssa) 2084 YYSTACK_FREE (yyss); 2085 #endif 2086 #if YYERROR_VERBOSE 2087 if (yymsg != yymsgbuf) 2088 YYSTACK_FREE (yymsg); 2089 #endif 2090 return yyresult; 2091 } 2092 #line 353 "mcparse.y" /* yacc.c:1906 */ 2093 2094 2095 /* Something else. */ 2096