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