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