1 /* A Bison parser, made by GNU Bison 2.5. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2011 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 "2.5" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 /* Using locations. */ 62 #define YYLSP_NEEDED 0 63 64 /* Substitute the variable and function names. */ 65 #define yyparse perf_pmu_parse 66 #define yylex perf_pmu_lex 67 #define yyerror perf_pmu_error 68 #define yylval perf_pmu_lval 69 #define yychar perf_pmu_char 70 #define yydebug perf_pmu_debug 71 #define yynerrs perf_pmu_nerrs 72 73 74 /* Copy the first part of user declarations. */ 75 76 /* Line 268 of yacc.c */ 77 #line 5 "util/pmu.y" 78 79 80 #include <linux/compiler.h> 81 #include <linux/list.h> 82 #include <linux/bitmap.h> 83 #include <string.h> 84 #include "pmu.h" 85 86 extern int perf_pmu_lex (void); 87 88 #define ABORT_ON(val) \ 89 do { \ 90 if (val) \ 91 YYABORT; \ 92 } while (0) 93 94 95 96 /* Line 268 of yacc.c */ 97 #line 98 "util/pmu-bison.c" 98 99 /* Enabling traces. */ 100 #ifndef YYDEBUG 101 # define YYDEBUG 0 102 #endif 103 104 /* Enabling verbose error messages. */ 105 #ifdef YYERROR_VERBOSE 106 # undef YYERROR_VERBOSE 107 # define YYERROR_VERBOSE 1 108 #else 109 # define YYERROR_VERBOSE 0 110 #endif 111 112 /* Enabling the token table. */ 113 #ifndef YYTOKEN_TABLE 114 # define YYTOKEN_TABLE 0 115 #endif 116 117 118 /* Tokens. */ 119 #ifndef YYTOKENTYPE 120 # define YYTOKENTYPE 121 /* Put the tokens into the symbol table, so that GDB and other debuggers 122 know about them. */ 123 enum yytokentype { 124 PP_CONFIG = 258, 125 PP_CONFIG1 = 259, 126 PP_CONFIG2 = 260, 127 PP_VALUE = 261, 128 PP_ERROR = 262 129 }; 130 #endif 131 132 133 134 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 135 typedef union YYSTYPE 136 { 137 138 /* Line 293 of yacc.c */ 139 #line 30 "util/pmu.y" 140 141 unsigned long num; 142 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 143 144 145 146 /* Line 293 of yacc.c */ 147 #line 148 "util/pmu-bison.c" 148 } YYSTYPE; 149 # define YYSTYPE_IS_TRIVIAL 1 150 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 151 # define YYSTYPE_IS_DECLARED 1 152 #endif 153 154 155 /* Copy the second part of user declarations. */ 156 157 158 /* Line 343 of yacc.c */ 159 #line 160 "util/pmu-bison.c" 160 161 #ifdef short 162 # undef short 163 #endif 164 165 #ifdef YYTYPE_UINT8 166 typedef YYTYPE_UINT8 yytype_uint8; 167 #else 168 typedef unsigned char yytype_uint8; 169 #endif 170 171 #ifdef YYTYPE_INT8 172 typedef YYTYPE_INT8 yytype_int8; 173 #elif (defined __STDC__ || defined __C99__FUNC__ \ 174 || defined __cplusplus || defined _MSC_VER) 175 typedef signed char yytype_int8; 176 #else 177 typedef short int yytype_int8; 178 #endif 179 180 #ifdef YYTYPE_UINT16 181 typedef YYTYPE_UINT16 yytype_uint16; 182 #else 183 typedef unsigned short int yytype_uint16; 184 #endif 185 186 #ifdef YYTYPE_INT16 187 typedef YYTYPE_INT16 yytype_int16; 188 #else 189 typedef short int yytype_int16; 190 #endif 191 192 #ifndef YYSIZE_T 193 # ifdef __SIZE_TYPE__ 194 # define YYSIZE_T __SIZE_TYPE__ 195 # elif defined size_t 196 # define YYSIZE_T size_t 197 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 198 || defined __cplusplus || defined _MSC_VER) 199 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 200 # define YYSIZE_T size_t 201 # else 202 # define YYSIZE_T unsigned int 203 # endif 204 #endif 205 206 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 207 208 #ifndef YY_ 209 # if defined YYENABLE_NLS && YYENABLE_NLS 210 # if ENABLE_NLS 211 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 212 # define YY_(msgid) dgettext ("bison-runtime", msgid) 213 # endif 214 # endif 215 # ifndef YY_ 216 # define YY_(msgid) msgid 217 # endif 218 #endif 219 220 /* Suppress unused-variable warnings by "using" E. */ 221 #if ! defined lint || defined __GNUC__ 222 # define YYUSE(e) ((void) (e)) 223 #else 224 # define YYUSE(e) /* empty */ 225 #endif 226 227 /* Identity function, used to suppress warnings about constant conditions. */ 228 #ifndef lint 229 # define YYID(n) (n) 230 #else 231 #if (defined __STDC__ || defined __C99__FUNC__ \ 232 || defined __cplusplus || defined _MSC_VER) 233 static int 234 YYID (int yyi) 235 #else 236 static int 237 YYID (yyi) 238 int yyi; 239 #endif 240 { 241 return yyi; 242 } 243 #endif 244 245 #if ! defined yyoverflow || YYERROR_VERBOSE 246 247 /* The parser invokes alloca or malloc; define the necessary symbols. */ 248 249 # ifdef YYSTACK_USE_ALLOCA 250 # if YYSTACK_USE_ALLOCA 251 # ifdef __GNUC__ 252 # define YYSTACK_ALLOC __builtin_alloca 253 # elif defined __BUILTIN_VA_ARG_INCR 254 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 255 # elif defined _AIX 256 # define YYSTACK_ALLOC __alloca 257 # elif defined _MSC_VER 258 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 259 # define alloca _alloca 260 # else 261 # define YYSTACK_ALLOC alloca 262 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 263 || defined __cplusplus || defined _MSC_VER) 264 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 265 # ifndef EXIT_SUCCESS 266 # define EXIT_SUCCESS 0 267 # endif 268 # endif 269 # endif 270 # endif 271 # endif 272 273 # ifdef YYSTACK_ALLOC 274 /* Pacify GCC's `empty if-body' warning. */ 275 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 276 # ifndef YYSTACK_ALLOC_MAXIMUM 277 /* The OS might guarantee only one guard page at the bottom of the stack, 278 and a page size can be as small as 4096 bytes. So we cannot safely 279 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 280 to allow for a few compiler-allocated temporary stack slots. */ 281 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 282 # endif 283 # else 284 # define YYSTACK_ALLOC YYMALLOC 285 # define YYSTACK_FREE YYFREE 286 # ifndef YYSTACK_ALLOC_MAXIMUM 287 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 288 # endif 289 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 290 && ! ((defined YYMALLOC || defined malloc) \ 291 && (defined YYFREE || defined free))) 292 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 293 # ifndef EXIT_SUCCESS 294 # define EXIT_SUCCESS 0 295 # endif 296 # endif 297 # ifndef YYMALLOC 298 # define YYMALLOC malloc 299 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 300 || defined __cplusplus || defined _MSC_VER) 301 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 302 # endif 303 # endif 304 # ifndef YYFREE 305 # define YYFREE free 306 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 307 || defined __cplusplus || defined _MSC_VER) 308 void free (void *); /* INFRINGES ON USER NAME SPACE */ 309 # endif 310 # endif 311 # endif 312 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 313 314 315 #if (! defined yyoverflow \ 316 && (! defined __cplusplus \ 317 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 318 319 /* A type that is properly aligned for any stack member. */ 320 union yyalloc 321 { 322 yytype_int16 yyss_alloc; 323 YYSTYPE yyvs_alloc; 324 }; 325 326 /* The size of the maximum gap between one aligned stack and the next. */ 327 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 328 329 /* The size of an array large to enough to hold all stacks, each with 330 N elements. */ 331 # define YYSTACK_BYTES(N) \ 332 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 333 + YYSTACK_GAP_MAXIMUM) 334 335 # define YYCOPY_NEEDED 1 336 337 /* Relocate STACK from its old location to the new one. The 338 local variables YYSIZE and YYSTACKSIZE give the old and new number of 339 elements in the stack, and YYPTR gives the new location of the 340 stack. Advance YYPTR to a properly aligned location for the next 341 stack. */ 342 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 343 do \ 344 { \ 345 YYSIZE_T yynewbytes; \ 346 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 347 Stack = &yyptr->Stack_alloc; \ 348 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 349 yyptr += yynewbytes / sizeof (*yyptr); \ 350 } \ 351 while (YYID (0)) 352 353 #endif 354 355 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 356 /* Copy COUNT objects from FROM to TO. The source and destination do 357 not overlap. */ 358 # ifndef YYCOPY 359 # if defined __GNUC__ && 1 < __GNUC__ 360 # define YYCOPY(To, From, Count) \ 361 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 362 # else 363 # define YYCOPY(To, From, Count) \ 364 do \ 365 { \ 366 YYSIZE_T yyi; \ 367 for (yyi = 0; yyi < (Count); yyi++) \ 368 (To)[yyi] = (From)[yyi]; \ 369 } \ 370 while (YYID (0)) 371 # endif 372 # endif 373 #endif /* !YYCOPY_NEEDED */ 374 375 /* YYFINAL -- State number of the termination state. */ 376 #define YYFINAL 9 377 /* YYLAST -- Last index in YYTABLE. */ 378 #define YYLAST 17 379 380 /* YYNTOKENS -- Number of terminals. */ 381 #define YYNTOKENS 11 382 /* YYNNTS -- Number of nonterminals. */ 383 #define YYNNTS 5 384 /* YYNRULES -- Number of rules. */ 385 #define YYNRULES 10 386 /* YYNRULES -- Number of states. */ 387 #define YYNSTATES 20 388 389 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 390 #define YYUNDEFTOK 2 391 #define YYMAXUTOK 262 392 393 #define YYTRANSLATE(YYX) \ 394 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 395 396 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 397 static const yytype_uint8 yytranslate[] = 398 { 399 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 400 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 401 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 402 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 403 2, 2, 2, 2, 9, 10, 2, 2, 2, 2, 404 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, 405 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 406 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 407 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 408 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 409 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 410 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 411 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 412 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 414 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 424 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 425 5, 6, 7 426 }; 427 428 #if YYDEBUG 429 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 430 YYRHS. */ 431 static const yytype_uint8 yyprhs[] = 432 { 433 0, 0, 3, 6, 8, 12, 16, 20, 24, 26, 434 30 435 }; 436 437 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 438 static const yytype_int8 yyrhs[] = 439 { 440 12, 0, -1, 12, 13, -1, 13, -1, 3, 8, 441 14, -1, 4, 8, 14, -1, 5, 8, 14, -1, 442 14, 9, 15, -1, 15, -1, 6, 10, 6, -1, 443 6, -1 444 }; 445 446 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 447 static const yytype_uint8 yyrline[] = 448 { 449 0, 38, 38, 40, 43, 50, 57, 65, 70, 76, 450 81 451 }; 452 #endif 453 454 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 455 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 456 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 457 static const char *const yytname[] = 458 { 459 "$end", "error", "$undefined", "PP_CONFIG", "PP_CONFIG1", "PP_CONFIG2", 460 "PP_VALUE", "PP_ERROR", "':'", "','", "'-'", "$accept", "format", 461 "format_term", "bits", "bit_term", 0 462 }; 463 #endif 464 465 # ifdef YYPRINT 466 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 467 token YYLEX-NUM. */ 468 static const yytype_uint16 yytoknum[] = 469 { 470 0, 256, 257, 258, 259, 260, 261, 262, 58, 44, 471 45 472 }; 473 # endif 474 475 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 476 static const yytype_uint8 yyr1[] = 477 { 478 0, 11, 12, 12, 13, 13, 13, 14, 14, 15, 479 15 480 }; 481 482 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 483 static const yytype_uint8 yyr2[] = 484 { 485 0, 2, 2, 1, 3, 3, 3, 3, 1, 3, 486 1 487 }; 488 489 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 490 Performed when YYTABLE doesn't specify something else to do. Zero 491 means the default is an error. */ 492 static const yytype_uint8 yydefact[] = 493 { 494 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 495 2, 10, 4, 8, 5, 6, 0, 0, 9, 7 496 }; 497 498 /* YYDEFGOTO[NTERM-NUM]. */ 499 static const yytype_int8 yydefgoto[] = 500 { 501 -1, 4, 5, 12, 13 502 }; 503 504 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 505 STATE-NUM. */ 506 #define YYPACT_NINF -7 507 static const yytype_int8 yypact[] = 508 { 509 3, 1, 2, 4, 0, -7, 5, 5, 5, -7, 510 -7, 6, 8, -7, 8, 8, 7, 5, -7, -7 511 }; 512 513 /* YYPGOTO[NTERM-NUM]. */ 514 static const yytype_int8 yypgoto[] = 515 { 516 -7, -7, 10, -6, -2 517 }; 518 519 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 520 positive, shift that token. If negative, reduce the rule which 521 number is the opposite. If YYTABLE_NINF, syntax error. */ 522 #define YYTABLE_NINF -1 523 static const yytype_uint8 yytable[] = 524 { 525 9, 14, 15, 1, 2, 3, 1, 2, 3, 6, 526 7, 11, 8, 18, 10, 19, 16, 17 527 }; 528 529 #define yypact_value_is_default(yystate) \ 530 ((yystate) == (-7)) 531 532 #define yytable_value_is_error(yytable_value) \ 533 YYID (0) 534 535 static const yytype_uint8 yycheck[] = 536 { 537 0, 7, 8, 3, 4, 5, 3, 4, 5, 8, 538 8, 6, 8, 6, 4, 17, 10, 9 539 }; 540 541 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 542 symbol of state STATE-NUM. */ 543 static const yytype_uint8 yystos[] = 544 { 545 0, 3, 4, 5, 12, 13, 8, 8, 8, 0, 546 13, 6, 14, 15, 14, 14, 10, 9, 6, 15 547 }; 548 549 #define yyerrok (yyerrstatus = 0) 550 #define yyclearin (yychar = YYEMPTY) 551 #define YYEMPTY (-2) 552 #define YYEOF 0 553 554 #define YYACCEPT goto yyacceptlab 555 #define YYABORT goto yyabortlab 556 #define YYERROR goto yyerrorlab 557 558 559 /* Like YYERROR except do call yyerror. This remains here temporarily 560 to ease the transition to the new meaning of YYERROR, for GCC. 561 Once GCC version 2 has supplanted version 1, this can go. However, 562 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 563 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 564 discussed. */ 565 566 #define YYFAIL goto yyerrlab 567 #if defined YYFAIL 568 /* This is here to suppress warnings from the GCC cpp's 569 -Wunused-macros. Normally we don't worry about that warning, but 570 some users do, and we want to make it easy for users to remove 571 YYFAIL uses, which will produce warnings from Bison 2.5. */ 572 #endif 573 574 #define YYRECOVERING() (!!yyerrstatus) 575 576 #define YYBACKUP(Token, Value) \ 577 do \ 578 if (yychar == YYEMPTY && yylen == 1) \ 579 { \ 580 yychar = (Token); \ 581 yylval = (Value); \ 582 YYPOPSTACK (1); \ 583 goto yybackup; \ 584 } \ 585 else \ 586 { \ 587 yyerror (format, name, YY_("syntax error: cannot back up")); \ 588 YYERROR; \ 589 } \ 590 while (YYID (0)) 591 592 593 #define YYTERROR 1 594 #define YYERRCODE 256 595 596 597 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 598 If N is 0, then set CURRENT to the empty location which ends 599 the previous symbol: RHS[0] (always defined). */ 600 601 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 602 #ifndef YYLLOC_DEFAULT 603 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 604 do \ 605 if (YYID (N)) \ 606 { \ 607 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 608 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 609 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 610 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 611 } \ 612 else \ 613 { \ 614 (Current).first_line = (Current).last_line = \ 615 YYRHSLOC (Rhs, 0).last_line; \ 616 (Current).first_column = (Current).last_column = \ 617 YYRHSLOC (Rhs, 0).last_column; \ 618 } \ 619 while (YYID (0)) 620 #endif 621 622 623 /* This macro is provided for backward compatibility. */ 624 625 #ifndef YY_LOCATION_PRINT 626 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 627 #endif 628 629 630 /* YYLEX -- calling `yylex' with the right arguments. */ 631 632 #ifdef YYLEX_PARAM 633 # define YYLEX yylex (YYLEX_PARAM) 634 #else 635 # define YYLEX yylex () 636 #endif 637 638 /* Enable debugging if requested. */ 639 #if YYDEBUG 640 641 # ifndef YYFPRINTF 642 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 643 # define YYFPRINTF fprintf 644 # endif 645 646 # define YYDPRINTF(Args) \ 647 do { \ 648 if (yydebug) \ 649 YYFPRINTF Args; \ 650 } while (YYID (0)) 651 652 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 653 do { \ 654 if (yydebug) \ 655 { \ 656 YYFPRINTF (stderr, "%s ", Title); \ 657 yy_symbol_print (stderr, \ 658 Type, Value, format, name); \ 659 YYFPRINTF (stderr, "\n"); \ 660 } \ 661 } while (YYID (0)) 662 663 664 /*--------------------------------. 665 | Print this symbol on YYOUTPUT. | 666 `--------------------------------*/ 667 668 /*ARGSUSED*/ 669 #if (defined __STDC__ || defined __C99__FUNC__ \ 670 || defined __cplusplus || defined _MSC_VER) 671 static void 672 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name) 673 #else 674 static void 675 yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name) 676 FILE *yyoutput; 677 int yytype; 678 YYSTYPE const * const yyvaluep; 679 struct list_head *format; 680 char *name; 681 #endif 682 { 683 if (!yyvaluep) 684 return; 685 YYUSE (format); 686 YYUSE (name); 687 # ifdef YYPRINT 688 if (yytype < YYNTOKENS) 689 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 690 # else 691 YYUSE (yyoutput); 692 # endif 693 switch (yytype) 694 { 695 default: 696 break; 697 } 698 } 699 700 701 /*--------------------------------. 702 | Print this symbol on YYOUTPUT. | 703 `--------------------------------*/ 704 705 #if (defined __STDC__ || defined __C99__FUNC__ \ 706 || defined __cplusplus || defined _MSC_VER) 707 static void 708 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name) 709 #else 710 static void 711 yy_symbol_print (yyoutput, yytype, yyvaluep, format, name) 712 FILE *yyoutput; 713 int yytype; 714 YYSTYPE const * const yyvaluep; 715 struct list_head *format; 716 char *name; 717 #endif 718 { 719 if (yytype < YYNTOKENS) 720 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 721 else 722 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 723 724 yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name); 725 YYFPRINTF (yyoutput, ")"); 726 } 727 728 /*------------------------------------------------------------------. 729 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 730 | TOP (included). | 731 `------------------------------------------------------------------*/ 732 733 #if (defined __STDC__ || defined __C99__FUNC__ \ 734 || defined __cplusplus || defined _MSC_VER) 735 static void 736 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 737 #else 738 static void 739 yy_stack_print (yybottom, yytop) 740 yytype_int16 *yybottom; 741 yytype_int16 *yytop; 742 #endif 743 { 744 YYFPRINTF (stderr, "Stack now"); 745 for (; yybottom <= yytop; yybottom++) 746 { 747 int yybot = *yybottom; 748 YYFPRINTF (stderr, " %d", yybot); 749 } 750 YYFPRINTF (stderr, "\n"); 751 } 752 753 # define YY_STACK_PRINT(Bottom, Top) \ 754 do { \ 755 if (yydebug) \ 756 yy_stack_print ((Bottom), (Top)); \ 757 } while (YYID (0)) 758 759 760 /*------------------------------------------------. 761 | Report that the YYRULE is going to be reduced. | 762 `------------------------------------------------*/ 763 764 #if (defined __STDC__ || defined __C99__FUNC__ \ 765 || defined __cplusplus || defined _MSC_VER) 766 static void 767 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct list_head *format, char *name) 768 #else 769 static void 770 yy_reduce_print (yyvsp, yyrule, format, name) 771 YYSTYPE *yyvsp; 772 int yyrule; 773 struct list_head *format; 774 char *name; 775 #endif 776 { 777 int yynrhs = yyr2[yyrule]; 778 int yyi; 779 unsigned long int yylno = yyrline[yyrule]; 780 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 781 yyrule - 1, yylno); 782 /* The symbols being reduced. */ 783 for (yyi = 0; yyi < yynrhs; yyi++) 784 { 785 YYFPRINTF (stderr, " $%d = ", yyi + 1); 786 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 787 &(yyvsp[(yyi + 1) - (yynrhs)]) 788 , format, name); 789 YYFPRINTF (stderr, "\n"); 790 } 791 } 792 793 # define YY_REDUCE_PRINT(Rule) \ 794 do { \ 795 if (yydebug) \ 796 yy_reduce_print (yyvsp, Rule, format, name); \ 797 } while (YYID (0)) 798 799 /* Nonzero means print parse trace. It is left uninitialized so that 800 multiple parsers can coexist. */ 801 int yydebug; 802 #else /* !YYDEBUG */ 803 # define YYDPRINTF(Args) 804 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 805 # define YY_STACK_PRINT(Bottom, Top) 806 # define YY_REDUCE_PRINT(Rule) 807 #endif /* !YYDEBUG */ 808 809 810 /* YYINITDEPTH -- initial size of the parser's stacks. */ 811 #ifndef YYINITDEPTH 812 # define YYINITDEPTH 200 813 #endif 814 815 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 816 if the built-in stack extension method is used). 817 818 Do not make this value too large; the results are undefined if 819 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 820 evaluated with infinite-precision integer arithmetic. */ 821 822 #ifndef YYMAXDEPTH 823 # define YYMAXDEPTH 10000 824 #endif 825 826 827 #if YYERROR_VERBOSE 828 829 # ifndef yystrlen 830 # if defined __GLIBC__ && defined _STRING_H 831 # define yystrlen strlen 832 # else 833 /* Return the length of YYSTR. */ 834 #if (defined __STDC__ || defined __C99__FUNC__ \ 835 || defined __cplusplus || defined _MSC_VER) 836 static YYSIZE_T 837 yystrlen (const char *yystr) 838 #else 839 static YYSIZE_T 840 yystrlen (yystr) 841 const char *yystr; 842 #endif 843 { 844 YYSIZE_T yylen; 845 for (yylen = 0; yystr[yylen]; yylen++) 846 continue; 847 return yylen; 848 } 849 # endif 850 # endif 851 852 # ifndef yystpcpy 853 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 854 # define yystpcpy stpcpy 855 # else 856 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 857 YYDEST. */ 858 #if (defined __STDC__ || defined __C99__FUNC__ \ 859 || defined __cplusplus || defined _MSC_VER) 860 static char * 861 yystpcpy (char *yydest, const char *yysrc) 862 #else 863 static char * 864 yystpcpy (yydest, yysrc) 865 char *yydest; 866 const char *yysrc; 867 #endif 868 { 869 char *yyd = yydest; 870 const char *yys = yysrc; 871 872 while ((*yyd++ = *yys++) != '\0') 873 continue; 874 875 return yyd - 1; 876 } 877 # endif 878 # endif 879 880 # ifndef yytnamerr 881 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 882 quotes and backslashes, so that it's suitable for yyerror. The 883 heuristic is that double-quoting is unnecessary unless the string 884 contains an apostrophe, a comma, or backslash (other than 885 backslash-backslash). YYSTR is taken from yytname. If YYRES is 886 null, do not copy; instead, return the length of what the result 887 would have been. */ 888 static YYSIZE_T 889 yytnamerr (char *yyres, const char *yystr) 890 { 891 if (*yystr == '"') 892 { 893 YYSIZE_T yyn = 0; 894 char const *yyp = yystr; 895 896 for (;;) 897 switch (*++yyp) 898 { 899 case '\'': 900 case ',': 901 goto do_not_strip_quotes; 902 903 case '\\': 904 if (*++yyp != '\\') 905 goto do_not_strip_quotes; 906 /* Fall through. */ 907 default: 908 if (yyres) 909 yyres[yyn] = *yyp; 910 yyn++; 911 break; 912 913 case '"': 914 if (yyres) 915 yyres[yyn] = '\0'; 916 return yyn; 917 } 918 do_not_strip_quotes: ; 919 } 920 921 if (! yyres) 922 return yystrlen (yystr); 923 924 return yystpcpy (yyres, yystr) - yyres; 925 } 926 # endif 927 928 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 929 about the unexpected token YYTOKEN for the state stack whose top is 930 YYSSP. 931 932 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 933 not large enough to hold the message. In that case, also set 934 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 935 required number of bytes is too large to store. */ 936 static int 937 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 938 yytype_int16 *yyssp, int yytoken) 939 { 940 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 941 YYSIZE_T yysize = yysize0; 942 YYSIZE_T yysize1; 943 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 944 /* Internationalized format string. */ 945 const char *yyformat = 0; 946 /* Arguments of yyformat. */ 947 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 948 /* Number of reported tokens (one for the "unexpected", one per 949 "expected"). */ 950 int yycount = 0; 951 952 /* There are many possibilities here to consider: 953 - Assume YYFAIL is not used. It's too flawed to consider. See 954 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 955 for details. YYERROR is fine as it does not invoke this 956 function. 957 - If this state is a consistent state with a default action, then 958 the only way this function was invoked is if the default action 959 is an error action. In that case, don't check for expected 960 tokens because there are none. 961 - The only way there can be no lookahead present (in yychar) is if 962 this state is a consistent state with a default action. Thus, 963 detecting the absence of a lookahead is sufficient to determine 964 that there is no unexpected or expected token to report. In that 965 case, just report a simple "syntax error". 966 - Don't assume there isn't a lookahead just because this state is a 967 consistent state with a default action. There might have been a 968 previous inconsistent state, consistent state with a non-default 969 action, or user semantic action that manipulated yychar. 970 - Of course, the expected token list depends on states to have 971 correct lookahead information, and it depends on the parser not 972 to perform extra reductions after fetching a lookahead from the 973 scanner and before detecting a syntax error. Thus, state merging 974 (from LALR or IELR) and default reductions corrupt the expected 975 token list. However, the list is correct for canonical LR with 976 one exception: it will still contain any token that will not be 977 accepted due to an error action in a later state. 978 */ 979 if (yytoken != YYEMPTY) 980 { 981 int yyn = yypact[*yyssp]; 982 yyarg[yycount++] = yytname[yytoken]; 983 if (!yypact_value_is_default (yyn)) 984 { 985 /* Start YYX at -YYN if negative to avoid negative indexes in 986 YYCHECK. In other words, skip the first -YYN actions for 987 this state because they are default actions. */ 988 int yyxbegin = yyn < 0 ? -yyn : 0; 989 /* Stay within bounds of both yycheck and yytname. */ 990 int yychecklim = YYLAST - yyn + 1; 991 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 992 int yyx; 993 994 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 995 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 996 && !yytable_value_is_error (yytable[yyx + yyn])) 997 { 998 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 999 { 1000 yycount = 1; 1001 yysize = yysize0; 1002 break; 1003 } 1004 yyarg[yycount++] = yytname[yyx]; 1005 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1006 if (! (yysize <= yysize1 1007 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1008 return 2; 1009 yysize = yysize1; 1010 } 1011 } 1012 } 1013 1014 switch (yycount) 1015 { 1016 # define YYCASE_(N, S) \ 1017 case N: \ 1018 yyformat = S; \ 1019 break 1020 YYCASE_(0, YY_("syntax error")); 1021 YYCASE_(1, YY_("syntax error, unexpected %s")); 1022 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1023 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1024 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1025 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1026 # undef YYCASE_ 1027 } 1028 1029 yysize1 = yysize + yystrlen (yyformat); 1030 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1031 return 2; 1032 yysize = yysize1; 1033 1034 if (*yymsg_alloc < yysize) 1035 { 1036 *yymsg_alloc = 2 * yysize; 1037 if (! (yysize <= *yymsg_alloc 1038 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1039 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1040 return 1; 1041 } 1042 1043 /* Avoid sprintf, as that infringes on the user's name space. 1044 Don't have undefined behavior even if the translation 1045 produced a string with the wrong number of "%s"s. */ 1046 { 1047 char *yyp = *yymsg; 1048 int yyi = 0; 1049 while ((*yyp = *yyformat) != '\0') 1050 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1051 { 1052 yyp += yytnamerr (yyp, yyarg[yyi++]); 1053 yyformat += 2; 1054 } 1055 else 1056 { 1057 yyp++; 1058 yyformat++; 1059 } 1060 } 1061 return 0; 1062 } 1063 #endif /* YYERROR_VERBOSE */ 1064 1065 /*-----------------------------------------------. 1066 | Release the memory associated to this symbol. | 1067 `-----------------------------------------------*/ 1068 1069 /*ARGSUSED*/ 1070 #if (defined __STDC__ || defined __C99__FUNC__ \ 1071 || defined __cplusplus || defined _MSC_VER) 1072 static void 1073 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct list_head *format, char *name) 1074 #else 1075 static void 1076 yydestruct (yymsg, yytype, yyvaluep, format, name) 1077 const char *yymsg; 1078 int yytype; 1079 YYSTYPE *yyvaluep; 1080 struct list_head *format; 1081 char *name; 1082 #endif 1083 { 1084 YYUSE (yyvaluep); 1085 YYUSE (format); 1086 YYUSE (name); 1087 1088 if (!yymsg) 1089 yymsg = "Deleting"; 1090 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1091 1092 switch (yytype) 1093 { 1094 1095 default: 1096 break; 1097 } 1098 } 1099 1100 1101 /* Prevent warnings from -Wmissing-prototypes. */ 1102 #ifdef YYPARSE_PARAM 1103 #if defined __STDC__ || defined __cplusplus 1104 int yyparse (void *YYPARSE_PARAM); 1105 #else 1106 int yyparse (); 1107 #endif 1108 #else /* ! YYPARSE_PARAM */ 1109 #if defined __STDC__ || defined __cplusplus 1110 int yyparse (struct list_head *format, char *name); 1111 #else 1112 int yyparse (); 1113 #endif 1114 #endif /* ! YYPARSE_PARAM */ 1115 1116 1117 /* The lookahead symbol. */ 1118 int yychar; 1119 1120 /* The semantic value of the lookahead symbol. */ 1121 YYSTYPE yylval; 1122 1123 /* Number of syntax errors so far. */ 1124 int yynerrs; 1125 1126 1127 /*----------. 1128 | yyparse. | 1129 `----------*/ 1130 1131 #ifdef YYPARSE_PARAM 1132 #if (defined __STDC__ || defined __C99__FUNC__ \ 1133 || defined __cplusplus || defined _MSC_VER) 1134 int 1135 yyparse (void *YYPARSE_PARAM) 1136 #else 1137 int 1138 yyparse (YYPARSE_PARAM) 1139 void *YYPARSE_PARAM; 1140 #endif 1141 #else /* ! YYPARSE_PARAM */ 1142 #if (defined __STDC__ || defined __C99__FUNC__ \ 1143 || defined __cplusplus || defined _MSC_VER) 1144 int 1145 yyparse (struct list_head *format, char *name) 1146 #else 1147 int 1148 yyparse (format, name) 1149 struct list_head *format; 1150 char *name; 1151 #endif 1152 #endif 1153 { 1154 int yystate; 1155 /* Number of tokens to shift before error messages enabled. */ 1156 int yyerrstatus; 1157 1158 /* The stacks and their tools: 1159 `yyss': related to states. 1160 `yyvs': related to semantic values. 1161 1162 Refer to the stacks thru separate pointers, to allow yyoverflow 1163 to reallocate them elsewhere. */ 1164 1165 /* The state stack. */ 1166 yytype_int16 yyssa[YYINITDEPTH]; 1167 yytype_int16 *yyss; 1168 yytype_int16 *yyssp; 1169 1170 /* The semantic value stack. */ 1171 YYSTYPE yyvsa[YYINITDEPTH]; 1172 YYSTYPE *yyvs; 1173 YYSTYPE *yyvsp; 1174 1175 YYSIZE_T yystacksize; 1176 1177 int yyn; 1178 int yyresult; 1179 /* Lookahead token as an internal (translated) token number. */ 1180 int yytoken; 1181 /* The variables used to return semantic value and location from the 1182 action routines. */ 1183 YYSTYPE yyval; 1184 1185 #if YYERROR_VERBOSE 1186 /* Buffer for error messages, and its allocated size. */ 1187 char yymsgbuf[128]; 1188 char *yymsg = yymsgbuf; 1189 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1190 #endif 1191 1192 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1193 1194 /* The number of symbols on the RHS of the reduced rule. 1195 Keep to zero when no symbol should be popped. */ 1196 int yylen = 0; 1197 1198 yytoken = 0; 1199 yyss = yyssa; 1200 yyvs = yyvsa; 1201 yystacksize = YYINITDEPTH; 1202 1203 YYDPRINTF ((stderr, "Starting parse\n")); 1204 1205 yystate = 0; 1206 yyerrstatus = 0; 1207 yynerrs = 0; 1208 yychar = YYEMPTY; /* Cause a token to be read. */ 1209 1210 /* Initialize stack pointers. 1211 Waste one element of value and location stack 1212 so that they stay on the same level as the state stack. 1213 The wasted elements are never initialized. */ 1214 yyssp = yyss; 1215 yyvsp = yyvs; 1216 1217 goto yysetstate; 1218 1219 /*------------------------------------------------------------. 1220 | yynewstate -- Push a new state, which is found in yystate. | 1221 `------------------------------------------------------------*/ 1222 yynewstate: 1223 /* In all cases, when you get here, the value and location stacks 1224 have just been pushed. So pushing a state here evens the stacks. */ 1225 yyssp++; 1226 1227 yysetstate: 1228 *yyssp = yystate; 1229 1230 if (yyss + yystacksize - 1 <= yyssp) 1231 { 1232 /* Get the current used size of the three stacks, in elements. */ 1233 YYSIZE_T yysize = yyssp - yyss + 1; 1234 1235 #ifdef yyoverflow 1236 { 1237 /* Give user a chance to reallocate the stack. Use copies of 1238 these so that the &'s don't force the real ones into 1239 memory. */ 1240 YYSTYPE *yyvs1 = yyvs; 1241 yytype_int16 *yyss1 = yyss; 1242 1243 /* Each stack pointer address is followed by the size of the 1244 data in use in that stack, in bytes. This used to be a 1245 conditional around just the two extra args, but that might 1246 be undefined if yyoverflow is a macro. */ 1247 yyoverflow (YY_("memory exhausted"), 1248 &yyss1, yysize * sizeof (*yyssp), 1249 &yyvs1, yysize * sizeof (*yyvsp), 1250 &yystacksize); 1251 1252 yyss = yyss1; 1253 yyvs = yyvs1; 1254 } 1255 #else /* no yyoverflow */ 1256 # ifndef YYSTACK_RELOCATE 1257 goto yyexhaustedlab; 1258 # else 1259 /* Extend the stack our own way. */ 1260 if (YYMAXDEPTH <= yystacksize) 1261 goto yyexhaustedlab; 1262 yystacksize *= 2; 1263 if (YYMAXDEPTH < yystacksize) 1264 yystacksize = YYMAXDEPTH; 1265 1266 { 1267 yytype_int16 *yyss1 = yyss; 1268 union yyalloc *yyptr = 1269 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1270 if (! yyptr) 1271 goto yyexhaustedlab; 1272 YYSTACK_RELOCATE (yyss_alloc, yyss); 1273 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1274 # undef YYSTACK_RELOCATE 1275 if (yyss1 != yyssa) 1276 YYSTACK_FREE (yyss1); 1277 } 1278 # endif 1279 #endif /* no yyoverflow */ 1280 1281 yyssp = yyss + yysize - 1; 1282 yyvsp = yyvs + yysize - 1; 1283 1284 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1285 (unsigned long int) yystacksize)); 1286 1287 if (yyss + yystacksize - 1 <= yyssp) 1288 YYABORT; 1289 } 1290 1291 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1292 1293 if (yystate == YYFINAL) 1294 YYACCEPT; 1295 1296 goto yybackup; 1297 1298 /*-----------. 1299 | yybackup. | 1300 `-----------*/ 1301 yybackup: 1302 1303 /* Do appropriate processing given the current state. Read a 1304 lookahead token if we need one and don't already have one. */ 1305 1306 /* First try to decide what to do without reference to lookahead token. */ 1307 yyn = yypact[yystate]; 1308 if (yypact_value_is_default (yyn)) 1309 goto yydefault; 1310 1311 /* Not known => get a lookahead token if don't already have one. */ 1312 1313 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1314 if (yychar == YYEMPTY) 1315 { 1316 YYDPRINTF ((stderr, "Reading a token: ")); 1317 yychar = YYLEX; 1318 } 1319 1320 if (yychar <= YYEOF) 1321 { 1322 yychar = yytoken = YYEOF; 1323 YYDPRINTF ((stderr, "Now at end of input.\n")); 1324 } 1325 else 1326 { 1327 yytoken = YYTRANSLATE (yychar); 1328 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1329 } 1330 1331 /* If the proper action on seeing token YYTOKEN is to reduce or to 1332 detect an error, take that action. */ 1333 yyn += yytoken; 1334 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1335 goto yydefault; 1336 yyn = yytable[yyn]; 1337 if (yyn <= 0) 1338 { 1339 if (yytable_value_is_error (yyn)) 1340 goto yyerrlab; 1341 yyn = -yyn; 1342 goto yyreduce; 1343 } 1344 1345 /* Count tokens shifted since error; after three, turn off error 1346 status. */ 1347 if (yyerrstatus) 1348 yyerrstatus--; 1349 1350 /* Shift the lookahead token. */ 1351 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1352 1353 /* Discard the shifted token. */ 1354 yychar = YYEMPTY; 1355 1356 yystate = yyn; 1357 *++yyvsp = yylval; 1358 1359 goto yynewstate; 1360 1361 1362 /*-----------------------------------------------------------. 1363 | yydefault -- do the default action for the current state. | 1364 `-----------------------------------------------------------*/ 1365 yydefault: 1366 yyn = yydefact[yystate]; 1367 if (yyn == 0) 1368 goto yyerrlab; 1369 goto yyreduce; 1370 1371 1372 /*-----------------------------. 1373 | yyreduce -- Do a reduction. | 1374 `-----------------------------*/ 1375 yyreduce: 1376 /* yyn is the number of a rule to reduce with. */ 1377 yylen = yyr2[yyn]; 1378 1379 /* If YYLEN is nonzero, implement the default value of the action: 1380 `$$ = $1'. 1381 1382 Otherwise, the following line sets YYVAL to garbage. 1383 This behavior is undocumented and Bison 1384 users should not rely upon it. Assigning to YYVAL 1385 unconditionally makes the parser a bit smaller, and it avoids a 1386 GCC warning that YYVAL may be used uninitialized. */ 1387 yyval = yyvsp[1-yylen]; 1388 1389 1390 YY_REDUCE_PRINT (yyn); 1391 switch (yyn) 1392 { 1393 case 4: 1394 1395 /* Line 1806 of yacc.c */ 1396 #line 44 "util/pmu.y" 1397 { 1398 ABORT_ON(perf_pmu__new_format(format, name, 1399 PERF_PMU_FORMAT_VALUE_CONFIG, 1400 (yyvsp[(3) - (3)].bits))); 1401 } 1402 break; 1403 1404 case 5: 1405 1406 /* Line 1806 of yacc.c */ 1407 #line 51 "util/pmu.y" 1408 { 1409 ABORT_ON(perf_pmu__new_format(format, name, 1410 PERF_PMU_FORMAT_VALUE_CONFIG1, 1411 (yyvsp[(3) - (3)].bits))); 1412 } 1413 break; 1414 1415 case 6: 1416 1417 /* Line 1806 of yacc.c */ 1418 #line 58 "util/pmu.y" 1419 { 1420 ABORT_ON(perf_pmu__new_format(format, name, 1421 PERF_PMU_FORMAT_VALUE_CONFIG2, 1422 (yyvsp[(3) - (3)].bits))); 1423 } 1424 break; 1425 1426 case 7: 1427 1428 /* Line 1806 of yacc.c */ 1429 #line 66 "util/pmu.y" 1430 { 1431 bitmap_or((yyval.bits), (yyvsp[(1) - (3)].bits), (yyvsp[(3) - (3)].bits), 64); 1432 } 1433 break; 1434 1435 case 8: 1436 1437 /* Line 1806 of yacc.c */ 1438 #line 71 "util/pmu.y" 1439 { 1440 memcpy((yyval.bits), (yyvsp[(1) - (1)].bits), sizeof((yyvsp[(1) - (1)].bits))); 1441 } 1442 break; 1443 1444 case 9: 1445 1446 /* Line 1806 of yacc.c */ 1447 #line 77 "util/pmu.y" 1448 { 1449 perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num)); 1450 } 1451 break; 1452 1453 case 10: 1454 1455 /* Line 1806 of yacc.c */ 1456 #line 82 "util/pmu.y" 1457 { 1458 perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (1)].num), 0); 1459 } 1460 break; 1461 1462 1463 1464 /* Line 1806 of yacc.c */ 1465 #line 1466 "util/pmu-bison.c" 1466 default: break; 1467 } 1468 /* User semantic actions sometimes alter yychar, and that requires 1469 that yytoken be updated with the new translation. We take the 1470 approach of translating immediately before every use of yytoken. 1471 One alternative is translating here after every semantic action, 1472 but that translation would be missed if the semantic action invokes 1473 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1474 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1475 incorrect destructor might then be invoked immediately. In the 1476 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1477 to an incorrect destructor call or verbose syntax error message 1478 before the lookahead is translated. */ 1479 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1480 1481 YYPOPSTACK (yylen); 1482 yylen = 0; 1483 YY_STACK_PRINT (yyss, yyssp); 1484 1485 *++yyvsp = yyval; 1486 1487 /* Now `shift' the result of the reduction. Determine what state 1488 that goes to, based on the state we popped back to and the rule 1489 number reduced by. */ 1490 1491 yyn = yyr1[yyn]; 1492 1493 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1494 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1495 yystate = yytable[yystate]; 1496 else 1497 yystate = yydefgoto[yyn - YYNTOKENS]; 1498 1499 goto yynewstate; 1500 1501 1502 /*------------------------------------. 1503 | yyerrlab -- here on detecting error | 1504 `------------------------------------*/ 1505 yyerrlab: 1506 /* Make sure we have latest lookahead translation. See comments at 1507 user semantic actions for why this is necessary. */ 1508 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 1509 1510 /* If not already recovering from an error, report this error. */ 1511 if (!yyerrstatus) 1512 { 1513 ++yynerrs; 1514 #if ! YYERROR_VERBOSE 1515 yyerror (format, name, YY_("syntax error")); 1516 #else 1517 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 1518 yyssp, yytoken) 1519 { 1520 char const *yymsgp = YY_("syntax error"); 1521 int yysyntax_error_status; 1522 yysyntax_error_status = YYSYNTAX_ERROR; 1523 if (yysyntax_error_status == 0) 1524 yymsgp = yymsg; 1525 else if (yysyntax_error_status == 1) 1526 { 1527 if (yymsg != yymsgbuf) 1528 YYSTACK_FREE (yymsg); 1529 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 1530 if (!yymsg) 1531 { 1532 yymsg = yymsgbuf; 1533 yymsg_alloc = sizeof yymsgbuf; 1534 yysyntax_error_status = 2; 1535 } 1536 else 1537 { 1538 yysyntax_error_status = YYSYNTAX_ERROR; 1539 yymsgp = yymsg; 1540 } 1541 } 1542 yyerror (format, name, yymsgp); 1543 if (yysyntax_error_status == 2) 1544 goto yyexhaustedlab; 1545 } 1546 # undef YYSYNTAX_ERROR 1547 #endif 1548 } 1549 1550 1551 1552 if (yyerrstatus == 3) 1553 { 1554 /* If just tried and failed to reuse lookahead token after an 1555 error, discard it. */ 1556 1557 if (yychar <= YYEOF) 1558 { 1559 /* Return failure if at end of input. */ 1560 if (yychar == YYEOF) 1561 YYABORT; 1562 } 1563 else 1564 { 1565 yydestruct ("Error: discarding", 1566 yytoken, &yylval, format, name); 1567 yychar = YYEMPTY; 1568 } 1569 } 1570 1571 /* Else will try to reuse lookahead token after shifting the error 1572 token. */ 1573 goto yyerrlab1; 1574 1575 1576 /*---------------------------------------------------. 1577 | yyerrorlab -- error raised explicitly by YYERROR. | 1578 `---------------------------------------------------*/ 1579 yyerrorlab: 1580 1581 /* Pacify compilers like GCC when the user code never invokes 1582 YYERROR and the label yyerrorlab therefore never appears in user 1583 code. */ 1584 if (/*CONSTCOND*/ 0) 1585 goto yyerrorlab; 1586 1587 /* Do not reclaim the symbols of the rule which action triggered 1588 this YYERROR. */ 1589 YYPOPSTACK (yylen); 1590 yylen = 0; 1591 YY_STACK_PRINT (yyss, yyssp); 1592 yystate = *yyssp; 1593 goto yyerrlab1; 1594 1595 1596 /*-------------------------------------------------------------. 1597 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1598 `-------------------------------------------------------------*/ 1599 yyerrlab1: 1600 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1601 1602 for (;;) 1603 { 1604 yyn = yypact[yystate]; 1605 if (!yypact_value_is_default (yyn)) 1606 { 1607 yyn += YYTERROR; 1608 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1609 { 1610 yyn = yytable[yyn]; 1611 if (0 < yyn) 1612 break; 1613 } 1614 } 1615 1616 /* Pop the current state because it cannot handle the error token. */ 1617 if (yyssp == yyss) 1618 YYABORT; 1619 1620 1621 yydestruct ("Error: popping", 1622 yystos[yystate], yyvsp, format, name); 1623 YYPOPSTACK (1); 1624 yystate = *yyssp; 1625 YY_STACK_PRINT (yyss, yyssp); 1626 } 1627 1628 *++yyvsp = yylval; 1629 1630 1631 /* Shift the error token. */ 1632 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1633 1634 yystate = yyn; 1635 goto yynewstate; 1636 1637 1638 /*-------------------------------------. 1639 | yyacceptlab -- YYACCEPT comes here. | 1640 `-------------------------------------*/ 1641 yyacceptlab: 1642 yyresult = 0; 1643 goto yyreturn; 1644 1645 /*-----------------------------------. 1646 | yyabortlab -- YYABORT comes here. | 1647 `-----------------------------------*/ 1648 yyabortlab: 1649 yyresult = 1; 1650 goto yyreturn; 1651 1652 #if !defined(yyoverflow) || YYERROR_VERBOSE 1653 /*-------------------------------------------------. 1654 | yyexhaustedlab -- memory exhaustion comes here. | 1655 `-------------------------------------------------*/ 1656 yyexhaustedlab: 1657 yyerror (format, name, YY_("memory exhausted")); 1658 yyresult = 2; 1659 /* Fall through. */ 1660 #endif 1661 1662 yyreturn: 1663 if (yychar != YYEMPTY) 1664 { 1665 /* Make sure we have latest lookahead translation. See comments at 1666 user semantic actions for why this is necessary. */ 1667 yytoken = YYTRANSLATE (yychar); 1668 yydestruct ("Cleanup: discarding lookahead", 1669 yytoken, &yylval, format, name); 1670 } 1671 /* Do not reclaim the symbols of the rule which action triggered 1672 this YYABORT or YYACCEPT. */ 1673 YYPOPSTACK (yylen); 1674 YY_STACK_PRINT (yyss, yyssp); 1675 while (yyssp != yyss) 1676 { 1677 yydestruct ("Cleanup: popping", 1678 yystos[*yyssp], yyvsp, format, name); 1679 YYPOPSTACK (1); 1680 } 1681 #ifndef yyoverflow 1682 if (yyss != yyssa) 1683 YYSTACK_FREE (yyss); 1684 #endif 1685 #if YYERROR_VERBOSE 1686 if (yymsg != yymsgbuf) 1687 YYSTACK_FREE (yymsg); 1688 #endif 1689 /* Make sure YYID is used. */ 1690 return YYID (yyresult); 1691 } 1692 1693 1694 1695 /* Line 2067 of yacc.c */ 1696 #line 86 "util/pmu.y" 1697 1698 1699 void perf_pmu_error(struct list_head *list __maybe_unused, 1700 char *name __maybe_unused, 1701 char const *msg __maybe_unused) 1702 { 1703 } 1704 1705
