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