[deliverable/linux.git] / tools / perf / util / parse-events.y

%pure-parser
%parse-param {void *_data}
%parse-param {void *scanner}
%lex-param {void* scanner}

%{

#define YYDEBUG 1

#include <linux/compiler.h>
#include <linux/list.h>
#include <linux/types.h>
#include "util.h"
#include "parse-events.h"
#include "parse-events-bison.h"

extern int parse_events_lex (YYSTYPE* lvalp, void* scanner);

#define ABORT_ON(val) \
do { \
	if (val) \
		YYABORT; \
} while (0)

#define ALLOC_LIST(list) \
do { \
	list = malloc(sizeof(*list)); \
	ABORT_ON(!list);              \
	INIT_LIST_HEAD(list);         \
} while (0)

static inc_group_count(struct list_head *list,
		       struct parse_events_evlist *data)
{
	/* Count groups only have more than 1 members */
	if (!list_is_last(list->next, list))
		data->nr_groups++;
}

%}

%token PE_START_EVENTS PE_START_TERMS
%token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
%token PE_EVENT_NAME
%token PE_NAME
%token PE_MODIFIER_EVENT PE_MODIFIER_BP
%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
%token PE_ERROR
%type <num> PE_VALUE
%type <num> PE_VALUE_SYM_HW
%type <num> PE_VALUE_SYM_SW
%type <num> PE_RAW
%type <num> PE_TERM
%type <str> PE_NAME
%type <str> PE_NAME_CACHE_TYPE
%type <str> PE_NAME_CACHE_OP_RESULT
%type <str> PE_MODIFIER_EVENT
%type <str> PE_MODIFIER_BP
%type <str> PE_EVENT_NAME
%type <num> value_sym
%type <head> event_config
%type <term> event_term
%type <head> event_pmu
%type <head> event_legacy_symbol
%type <head> event_legacy_cache
%type <head> event_legacy_mem
%type <head> event_legacy_tracepoint
%type <head> event_legacy_numeric
%type <head> event_legacy_raw
%type <head> event_def
%type <head> event_mod
%type <head> event_name
%type <head> event
%type <head> events
%type <head> group_def
%type <head> group
%type <head> groups

%union
{
	char *str;
	u64 num;
	struct list_head *head;
	struct parse_events_term *term;
}
%%

start:
PE_START_EVENTS start_events
|
PE_START_TERMS  start_terms

start_events: groups
{
	struct parse_events_evlist *data = _data;

	parse_events_update_lists($1, &data->list);
}

groups:
groups ',' group
{
	struct list_head *list  = $1;
	struct list_head *group = $3;

	parse_events_update_lists(group, list);
	$$ = list;
}
|
groups ',' event
{
	struct list_head *list  = $1;
	struct list_head *event = $3;

	parse_events_update_lists(event, list);
	$$ = list;
}
|
group
|
event

group:
group_def ':' PE_MODIFIER_EVENT
{
	struct list_head *list = $1;

	ABORT_ON(parse_events__modifier_group(list, $3));
	$$ = list;
}
|
group_def

group_def:
PE_NAME '{' events '}'
{
	struct list_head *list = $3;

	inc_group_count(list, _data);
	parse_events__set_leader($1, list);
	$$ = list;
}
|
'{' events '}'
{
	struct list_head *list = $2;

	inc_group_count(list, _data);
	parse_events__set_leader(NULL, list);
	$$ = list;
}

events:
events ',' event
{
	struct list_head *event = $3;
	struct list_head *list  = $1;

	parse_events_update_lists(event, list);
	$$ = list;
}
|
event

event: event_mod

event_mod:
event_name PE_MODIFIER_EVENT
{
	struct list_head *list = $1;

	/*
	 * Apply modifier on all events added by single event definition
	 * (there could be more events added for multiple tracepoint
	 * definitions via '*?'.
	 */
	ABORT_ON(parse_events__modifier_event(list, $2, false));
	$$ = list;
}
|
event_name

event_name:
PE_EVENT_NAME event_def
{
	ABORT_ON(parse_events_name($2, $1));
	free($1);
	$$ = $2;
}
|
event_def

event_def: event_pmu |
	   event_legacy_symbol |
	   event_legacy_cache sep_dc |
	   event_legacy_mem |
	   event_legacy_tracepoint sep_dc |
	   event_legacy_numeric sep_dc |
	   event_legacy_raw sep_dc

event_pmu:
PE_NAME '/' event_config '/'
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(list, &data->idx, $1, $3));
	parse_events__free_terms($3);
	$$ = list;
}

value_sym:
PE_VALUE_SYM_HW
|
PE_VALUE_SYM_SW

event_legacy_symbol:
value_sym '/' event_config '/'
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;
	int type = $1 >> 16;
	int config = $1 & 255;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx,
					  type, config, $3));
	parse_events__free_terms($3);
	$$ = list;
}
|
value_sym sep_slash_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;
	int type = $1 >> 16;
	int config = $1 & 255;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx,
					  type, config, NULL));
	$$ = list;
}

event_legacy_cache:
PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, $5));
	$$ = list;
}
|
PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, NULL));
	$$ = list;
}
|
PE_NAME_CACHE_TYPE
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL));
	$$ = list;
}

event_legacy_mem:
PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
					     (void *) $2, $4));
	$$ = list;
}
|
PE_PREFIX_MEM PE_VALUE sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
					     (void *) $2, NULL));
	$$ = list;
}

event_legacy_tracepoint:
PE_NAME '-' PE_NAME ':' PE_NAME
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;
	char sys_name[128];
	snprintf(&sys_name, 128, "%s-%s", $1, $3);

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_tracepoint(list, &data->idx, &sys_name, $5));
	$$ = list;
}
|
PE_NAME ':' PE_NAME
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_tracepoint(list, &data->idx, $1, $3));
	$$ = list;
}

event_legacy_numeric:
PE_VALUE ':' PE_VALUE
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx, (u32)$1, $3, NULL));
	$$ = list;
}

event_legacy_raw:
PE_RAW
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx,
					  PERF_TYPE_RAW, $1, NULL));
	$$ = list;
}

start_terms: event_config
{
	struct parse_events_terms *data = _data;
	data->terms = $1;
}

event_config:
event_config ',' event_term
{
	struct list_head *head = $1;
	struct parse_events_term *term = $3;

	ABORT_ON(!head);
	list_add_tail(&term->list, head);
	$$ = $1;
}
|
event_term
{
	struct list_head *head = malloc(sizeof(*head));
	struct parse_events_term *term = $1;

	ABORT_ON(!head);
	INIT_LIST_HEAD(head);
	list_add_tail(&term->list, head);
	$$ = head;
}

event_term:
PE_NAME '=' PE_NAME
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, $3));
	$$ = term;
}
|
PE_NAME '=' PE_VALUE
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, $3));
	$$ = term;
}
|
PE_NAME '=' PE_VALUE_SYM_HW
{
	struct parse_events_term *term;
	int config = $3 & 255;

	ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
	$$ = term;
}
|
PE_NAME
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, 1));
	$$ = term;
}
|
PE_VALUE_SYM_HW
{
	struct parse_events_term *term;
	int config = $1 & 255;

	ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
	$$ = term;
}
|
PE_TERM '=' PE_NAME
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3));
	$$ = term;
}
|
PE_TERM '=' PE_VALUE
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3));
	$$ = term;
}
|
PE_TERM
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1));
	$$ = term;
}

sep_dc: ':' |

sep_slash_dc: '/' | ':' |

%%

void parse_events_error(void *data __maybe_unused, void *scanner __maybe_unused,
			char const *msg __maybe_unused)
{
}
Commit	Line	Data
ac20de6f	1	%pure-parser
46010ab2	2	%parse-param {void *_data}
ac20de6f ZY	3	%parse-param {void *scanner}
ac20de6f ZY	4	%lex-param {void* scanner}
89812fc8 JO	5
	6	%{
	7
	8	#define YYDEBUG 1
	9
	10	#include <linux/compiler.h>
	11	#include <linux/list.h>
d944c4ee	12	#include <linux/types.h>
89812fc8 JO	13	#include "util.h"
89812fc8 JO	14	#include "parse-events.h"
ac20de6f	15	#include "parse-events-bison.h"
89812fc8	16
ac20de6f	17	extern int parse_events_lex (YYSTYPE* lvalp, void* scanner);
89812fc8 JO	18
	19	#define ABORT_ON(val) \
	20	do { \
	21	if (val) \
	22	YYABORT; \
	23	} while (0)
	24
c5cd8ac0 DA	25	#define ALLOC_LIST(list) \
	26	do { \
	27	list = malloc(sizeof(*list)); \
	28	ABORT_ON(!list); \
	29	INIT_LIST_HEAD(list); \
	30	} while (0)
	31
97f63e4a NK	32	static inc_group_count(struct list_head *list,
	33	struct parse_events_evlist *data)
	34	{
	35	/* Count groups only have more than 1 members */
	36	if (!list_is_last(list->next, list))
	37	data->nr_groups++;
	38	}
	39
89812fc8 JO	40	%}
89812fc8 JO	41
90e2b22d	42	%token PE_START_EVENTS PE_START_TERMS
cf3506dc	43	%token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
ac2ba9f3	44	%token PE_EVENT_NAME
89812fc8 JO	45	%token PE_NAME
	46	%token PE_MODIFIER_EVENT PE_MODIFIER_BP
	47	%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
89efb029	48	%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
89812fc8 JO	49	%token PE_ERROR
89812fc8 JO	50	%type <num> PE_VALUE
cf3506dc JO	51	%type <num> PE_VALUE_SYM_HW
cf3506dc JO	52	%type <num> PE_VALUE_SYM_SW
89812fc8	53	%type <num> PE_RAW
8f707d84	54	%type <num> PE_TERM
89812fc8 JO	55	%type <str> PE_NAME
	56	%type <str> PE_NAME_CACHE_TYPE
	57	%type <str> PE_NAME_CACHE_OP_RESULT
	58	%type <str> PE_MODIFIER_EVENT
	59	%type <str> PE_MODIFIER_BP
ac2ba9f3	60	%type <str> PE_EVENT_NAME
cf3506dc	61	%type <num> value_sym
8f707d84 JO	62	%type <head> event_config
8f707d84 JO	63	%type <term> event_term
b847cbdc JO	64	%type <head> event_pmu
	65	%type <head> event_legacy_symbol
	66	%type <head> event_legacy_cache
	67	%type <head> event_legacy_mem
	68	%type <head> event_legacy_tracepoint
	69	%type <head> event_legacy_numeric
	70	%type <head> event_legacy_raw
	71	%type <head> event_def
ac2ba9f3 RR	72	%type <head> event_mod
ac2ba9f3 RR	73	%type <head> event_name
89efb029 JO	74	%type <head> event
	75	%type <head> events
	76	%type <head> group_def
	77	%type <head> group
	78	%type <head> groups
89812fc8 JO	79
	80	%union
	81	{
	82	char *str;
b527bab5	83	u64 num;
8f707d84	84	struct list_head *head;
6cee6cd3	85	struct parse_events_term *term;
89812fc8 JO	86	}
	87	%%
	88
90e2b22d	89	start:
89efb029	90	PE_START_EVENTS start_events
90e2b22d	91	\|
89efb029 JO	92	PE_START_TERMS start_terms
	93
	94	start_events: groups
	95	{
23b6339b	96	struct parse_events_evlist *data = _data;
89efb029 JO	97
	98	parse_events_update_lists($1, &data->list);
	99	}
	100
	101	groups:
	102	groups ',' group
	103	{
	104	struct list_head *list = $1;
	105	struct list_head *group = $3;
	106
	107	parse_events_update_lists(group, list);
	108	$$ = list;
	109	}
	110	\|
	111	groups ',' event
	112	{
	113	struct list_head *list = $1;
	114	struct list_head *event = $3;
	115
	116	parse_events_update_lists(event, list);
	117	$$ = list;
	118	}
	119	\|
	120	group
	121	\|
	122	event
	123
	124	group:
	125	group_def ':' PE_MODIFIER_EVENT
	126	{
	127	struct list_head *list = $1;
	128
	129	ABORT_ON(parse_events__modifier_group(list, $3));
	130	$$ = list;
	131	}
	132	\|
	133	group_def
	134
	135	group_def:
	136	PE_NAME '{' events '}'
	137	{
	138	struct list_head *list = $3;
	139
97f63e4a	140	inc_group_count(list, _data);
63dab225	141	parse_events__set_leader($1, list);
89efb029 JO	142	$$ = list;
	143	}
	144	\|
	145	'{' events '}'
	146	{
	147	struct list_head *list = $2;
	148
97f63e4a	149	inc_group_count(list, _data);
63dab225	150	parse_events__set_leader(NULL, list);
89efb029 JO	151	$$ = list;
89efb029 JO	152	}
90e2b22d	153
89812fc8	154	events:
89efb029 JO	155	events ',' event
	156	{
	157	struct list_head *event = $3;
	158	struct list_head *list = $1;
	159
	160	parse_events_update_lists(event, list);
	161	$$ = list;
	162	}
	163	\|
	164	event
89812fc8	165
ac2ba9f3 RR	166	event: event_mod
	167
	168	event_mod:
	169	event_name PE_MODIFIER_EVENT
89812fc8	170	{
89efb029	171	struct list_head *list = $1;
46010ab2	172
5d7be90e JO	173	/*
	174	* Apply modifier on all events added by single event definition
	175	* (there could be more events added for multiple tracepoint
	176	* definitions via '*?'.
	177	*/
f5b1135b	178	ABORT_ON(parse_events__modifier_event(list, $2, false));
89efb029	179	$$ = list;
89812fc8 JO	180	}
89812fc8 JO	181	\|
ac2ba9f3 RR	182	event_name
	183
	184	event_name:
	185	PE_EVENT_NAME event_def
	186	{
	187	ABORT_ON(parse_events_name($2, $1));
	188	free($1);
	189	$$ = $2;
	190	}
	191	\|
89812fc8 JO	192	event_def
89812fc8 JO	193
5f537a26 JO	194	event_def: event_pmu \|
5f537a26 JO	195	event_legacy_symbol \|
89812fc8 JO	196	event_legacy_cache sep_dc \|
	197	event_legacy_mem \|
	198	event_legacy_tracepoint sep_dc \|
	199	event_legacy_numeric sep_dc \|
	200	event_legacy_raw sep_dc
	201
5f537a26 JO	202	event_pmu:
	203	PE_NAME '/' event_config '/'
	204	{
23b6339b	205	struct parse_events_evlist *data = _data;
c5cd8ac0	206	struct list_head *list;
b847cbdc	207
c5cd8ac0 DA	208	ALLOC_LIST(list);
c5cd8ac0 DA	209	ABORT_ON(parse_events_add_pmu(list, &data->idx, $1, $3));
5f537a26	210	parse_events__free_terms($3);
b847cbdc	211	$$ = list;
5f537a26 JO	212	}
5f537a26 JO	213
cf3506dc JO	214	value_sym:
	215	PE_VALUE_SYM_HW
	216	\|
	217	PE_VALUE_SYM_SW
	218
89812fc8	219	event_legacy_symbol:
cf3506dc	220	value_sym '/' event_config '/'
89812fc8	221	{
23b6339b	222	struct parse_events_evlist *data = _data;
c5cd8ac0	223	struct list_head *list;
89812fc8 JO	224	int type = $1 >> 16;
	225	int config = $1 & 255;
	226
c5cd8ac0 DA	227	ALLOC_LIST(list);
c5cd8ac0 DA	228	ABORT_ON(parse_events_add_numeric(list, &data->idx,
46010ab2	229	type, config, $3));
8f707d84	230	parse_events__free_terms($3);
b847cbdc	231	$$ = list;
8f707d84 JO	232	}
8f707d84 JO	233	\|
cf3506dc	234	value_sym sep_slash_dc
8f707d84	235	{
23b6339b	236	struct parse_events_evlist *data = _data;
c5cd8ac0	237	struct list_head *list;
8f707d84 JO	238	int type = $1 >> 16;
	239	int config = $1 & 255;
	240
c5cd8ac0 DA	241	ALLOC_LIST(list);
c5cd8ac0 DA	242	ABORT_ON(parse_events_add_numeric(list, &data->idx,
46010ab2	243	type, config, NULL));
b847cbdc	244	$$ = list;
89812fc8 JO	245	}
	246
	247	event_legacy_cache:
	248	PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
	249	{
23b6339b	250	struct parse_events_evlist *data = _data;
c5cd8ac0	251	struct list_head *list;
b847cbdc	252
c5cd8ac0 DA	253	ALLOC_LIST(list);
c5cd8ac0 DA	254	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, $5));
b847cbdc	255	$$ = list;
89812fc8 JO	256	}
	257	\|
	258	PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
	259	{
23b6339b	260	struct parse_events_evlist *data = _data;
c5cd8ac0	261	struct list_head *list;
b847cbdc	262
c5cd8ac0 DA	263	ALLOC_LIST(list);
c5cd8ac0 DA	264	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, NULL));
b847cbdc	265	$$ = list;
89812fc8 JO	266	}
	267	\|
	268	PE_NAME_CACHE_TYPE
	269	{
23b6339b	270	struct parse_events_evlist *data = _data;
c5cd8ac0	271	struct list_head *list;
b847cbdc	272
c5cd8ac0 DA	273	ALLOC_LIST(list);
c5cd8ac0 DA	274	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL));
b847cbdc	275	$$ = list;
89812fc8 JO	276	}
	277
	278	event_legacy_mem:
	279	PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
	280	{
23b6339b	281	struct parse_events_evlist *data = _data;
c5cd8ac0	282	struct list_head *list;
b847cbdc	283
c5cd8ac0 DA	284	ALLOC_LIST(list);
c5cd8ac0 DA	285	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
46010ab2	286	(void *) $2, $4));
b847cbdc	287	$$ = list;
89812fc8 JO	288	}
	289	\|
	290	PE_PREFIX_MEM PE_VALUE sep_dc
	291	{
23b6339b	292	struct parse_events_evlist *data = _data;
c5cd8ac0	293	struct list_head *list;
b847cbdc	294
c5cd8ac0 DA	295	ALLOC_LIST(list);
c5cd8ac0 DA	296	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
46010ab2	297	(void *) $2, NULL));
b847cbdc	298	$$ = list;
89812fc8 JO	299	}
	300
	301	event_legacy_tracepoint:
2b9032e0 AY	302	PE_NAME '-' PE_NAME ':' PE_NAME
	303	{
	304	struct parse_events_evlist *data = _data;
	305	struct list_head *list;
	306	char sys_name[128];
	307	snprintf(&sys_name, 128, "%s-%s", $1, $3);
	308
	309	ALLOC_LIST(list);
	310	ABORT_ON(parse_events_add_tracepoint(list, &data->idx, &sys_name, $5));
	311	$$ = list;
	312	}
	313	\|
89812fc8 JO	314	PE_NAME ':' PE_NAME
89812fc8 JO	315	{
23b6339b	316	struct parse_events_evlist *data = _data;
c5cd8ac0	317	struct list_head *list;
b847cbdc	318
c5cd8ac0 DA	319	ALLOC_LIST(list);
c5cd8ac0 DA	320	ABORT_ON(parse_events_add_tracepoint(list, &data->idx, $1, $3));
b847cbdc	321	$$ = list;
89812fc8 JO	322	}
	323
	324	event_legacy_numeric:
	325	PE_VALUE ':' PE_VALUE
	326	{
23b6339b	327	struct parse_events_evlist *data = _data;
c5cd8ac0	328	struct list_head *list;
b847cbdc	329
c5cd8ac0 DA	330	ALLOC_LIST(list);
c5cd8ac0 DA	331	ABORT_ON(parse_events_add_numeric(list, &data->idx, (u32)$1, $3, NULL));
b847cbdc	332	$$ = list;
89812fc8 JO	333	}
	334
	335	event_legacy_raw:
	336	PE_RAW
	337	{
23b6339b	338	struct parse_events_evlist *data = _data;
c5cd8ac0	339	struct list_head *list;
b847cbdc	340
c5cd8ac0 DA	341	ALLOC_LIST(list);
c5cd8ac0 DA	342	ABORT_ON(parse_events_add_numeric(list, &data->idx,
46010ab2	343	PERF_TYPE_RAW, $1, NULL));
b847cbdc	344	$$ = list;
8f707d84 JO	345	}
8f707d84 JO	346
89efb029	347	start_terms: event_config
90e2b22d	348	{
23b6339b	349	struct parse_events_terms *data = _data;
90e2b22d JO	350	data->terms = $1;
	351	}
	352
8f707d84 JO	353	event_config:
	354	event_config ',' event_term
	355	{
	356	struct list_head *head = $1;
6cee6cd3	357	struct parse_events_term *term = $3;
8f707d84 JO	358
	359	ABORT_ON(!head);
	360	list_add_tail(&term->list, head);
	361	$$ = $1;
	362	}
	363	\|
	364	event_term
	365	{
	366	struct list_head head = malloc(sizeof(head));
6cee6cd3	367	struct parse_events_term *term = $1;
8f707d84 JO	368
	369	ABORT_ON(!head);
	370	INIT_LIST_HEAD(head);
	371	list_add_tail(&term->list, head);
	372	$$ = head;
	373	}
	374
	375	event_term:
	376	PE_NAME '=' PE_NAME
	377	{
6cee6cd3	378	struct parse_events_term *term;
8f707d84	379
6cee6cd3	380	ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
16fa7e82	381	$1, $3));
8f707d84 JO	382	$$ = term;
	383	}
	384	\|
	385	PE_NAME '=' PE_VALUE
	386	{
6cee6cd3	387	struct parse_events_term *term;
8f707d84	388
6cee6cd3	389	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
16fa7e82	390	$1, $3));
8f707d84 JO	391	$$ = term;
	392	}
	393	\|
1d33d6dc JO	394	PE_NAME '=' PE_VALUE_SYM_HW
1d33d6dc JO	395	{
6cee6cd3	396	struct parse_events_term *term;
1d33d6dc JO	397	int config = $3 & 255;
1d33d6dc JO	398
6cee6cd3	399	ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
1d33d6dc JO	400	$$ = term;
	401	}
	402	\|
8f707d84 JO	403	PE_NAME
8f707d84 JO	404	{
6cee6cd3	405	struct parse_events_term *term;
8f707d84	406
6cee6cd3	407	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
16fa7e82	408	$1, 1));
8f707d84 JO	409	$$ = term;
	410	}
	411	\|
1d33d6dc JO	412	PE_VALUE_SYM_HW
1d33d6dc JO	413	{
6cee6cd3	414	struct parse_events_term *term;
1d33d6dc JO	415	int config = $1 & 255;
1d33d6dc JO	416
6cee6cd3	417	ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
1d33d6dc JO	418	$$ = term;
	419	}
	420	\|
6b5fc39b JO	421	PE_TERM '=' PE_NAME
6b5fc39b JO	422	{
6cee6cd3	423	struct parse_events_term *term;
6b5fc39b	424
6cee6cd3	425	ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3));
6b5fc39b JO	426	$$ = term;
	427	}
	428	\|
8f707d84 JO	429	PE_TERM '=' PE_VALUE
8f707d84 JO	430	{
6cee6cd3	431	struct parse_events_term *term;
8f707d84	432
6cee6cd3	433	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3));
8f707d84 JO	434	$$ = term;
	435	}
	436	\|
	437	PE_TERM
	438	{
6cee6cd3	439	struct parse_events_term *term;
8f707d84	440
6cee6cd3	441	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1));
8f707d84	442	$$ = term;
89812fc8 JO	443	}
	444
	445	sep_dc: ':' \|
	446
8f707d84 JO	447	sep_slash_dc: '/' \| ':' \|
8f707d84 JO	448
89812fc8 JO	449	%%
89812fc8 JO	450
1d037ca1 IT	451	void parse_events_error(void data __maybe_unused, void scanner __maybe_unused,
1d037ca1 IT	452	char const *msg __maybe_unused)
89812fc8 JO	453	{
89812fc8 JO	454	}