GNU Linux-libre 4.19.211-gnu1
[releases.git] / tools / perf / util / expr.y
1 /* Simple expression parser */
2 %{
3 #include "util.h"
4 #include "util/debug.h"
5 #define IN_EXPR_Y 1
6 #include "expr.h"
7 #include "smt.h"
8 #include <string.h>
9
10 #define MAXIDLEN 256
11 %}
12
13 %define api.pure full
14
15 %parse-param { double *final_val }
16 %parse-param { struct parse_ctx *ctx }
17 %parse-param { const char **pp }
18 %lex-param { const char **pp }
19
20 %union {
21         double num;
22         char id[MAXIDLEN+1];
23 }
24
25 %token <num> NUMBER
26 %token <id> ID
27 %token MIN MAX IF ELSE SMT_ON
28 %left MIN MAX IF
29 %left '|'
30 %left '^'
31 %left '&'
32 %left '-' '+'
33 %left '*' '/' '%'
34 %left NEG NOT
35 %type <num> expr if_expr
36
37 %{
38 static int expr__lex(YYSTYPE *res, const char **pp);
39
40 static void expr__error(double *final_val __maybe_unused,
41                        struct parse_ctx *ctx __maybe_unused,
42                        const char **pp __maybe_unused,
43                        const char *s)
44 {
45         pr_debug("%s\n", s);
46 }
47
48 static int lookup_id(struct parse_ctx *ctx, char *id, double *val)
49 {
50         int i;
51
52         for (i = 0; i < ctx->num_ids; i++) {
53                 if (!strcasecmp(ctx->ids[i].name, id)) {
54                         *val = ctx->ids[i].val;
55                         return 0;
56                 }
57         }
58         return -1;
59 }
60
61 %}
62 %%
63
64 all_expr: if_expr                       { *final_val = $1; }
65         ;
66
67 if_expr:
68         expr IF expr ELSE expr { $$ = $3 ? $1 : $5; }
69         | expr
70         ;
71
72 expr:     NUMBER
73         | ID                    { if (lookup_id(ctx, $1, &$$) < 0) {
74                                         pr_debug("%s not found\n", $1);
75                                         YYABORT;
76                                   }
77                                 }
78         | expr '|' expr         { $$ = (long)$1 | (long)$3; }
79         | expr '&' expr         { $$ = (long)$1 & (long)$3; }
80         | expr '^' expr         { $$ = (long)$1 ^ (long)$3; }
81         | expr '+' expr         { $$ = $1 + $3; }
82         | expr '-' expr         { $$ = $1 - $3; }
83         | expr '*' expr         { $$ = $1 * $3; }
84         | expr '/' expr         { if ($3 == 0) YYABORT; $$ = $1 / $3; }
85         | expr '%' expr         { if ((long)$3 == 0) YYABORT; $$ = (long)$1 % (long)$3; }
86         | '-' expr %prec NEG    { $$ = -$2; }
87         | '(' if_expr ')'       { $$ = $2; }
88         | MIN '(' expr ',' expr ')' { $$ = $3 < $5 ? $3 : $5; }
89         | MAX '(' expr ',' expr ')' { $$ = $3 > $5 ? $3 : $5; }
90         | SMT_ON                 { $$ = smt_on() > 0; }
91         ;
92
93 %%
94
95 static int expr__symbol(YYSTYPE *res, const char *p, const char **pp)
96 {
97         char *dst = res->id;
98         const char *s = p;
99
100         if (*p == '#')
101                 *dst++ = *p++;
102
103         while (isalnum(*p) || *p == '_' || *p == '.' || *p == ':' || *p == '@' || *p == '\\') {
104                 if (p - s >= MAXIDLEN)
105                         return -1;
106                 /*
107                  * Allow @ instead of / to be able to specify pmu/event/ without
108                  * conflicts with normal division.
109                  */
110                 if (*p == '@')
111                         *dst++ = '/';
112                 else if (*p == '\\')
113                         *dst++ = *++p;
114                 else
115                         *dst++ = *p;
116                 p++;
117         }
118         *dst = 0;
119         *pp = p;
120         dst = res->id;
121         switch (dst[0]) {
122         case 'm':
123                 if (!strcmp(dst, "min"))
124                         return MIN;
125                 if (!strcmp(dst, "max"))
126                         return MAX;
127                 break;
128         case 'i':
129                 if (!strcmp(dst, "if"))
130                         return IF;
131                 break;
132         case 'e':
133                 if (!strcmp(dst, "else"))
134                         return ELSE;
135                 break;
136         case '#':
137                 if (!strcasecmp(dst, "#smt_on"))
138                         return SMT_ON;
139                 break;
140         }
141         return ID;
142 }
143
144 static int expr__lex(YYSTYPE *res, const char **pp)
145 {
146         int tok;
147         const char *s;
148         const char *p = *pp;
149
150         while (isspace(*p))
151                 p++;
152         s = p;
153         switch (*p++) {
154         case '#':
155         case 'a' ... 'z':
156         case 'A' ... 'Z':
157                 return expr__symbol(res, p - 1, pp);
158         case '0' ... '9': case '.':
159                 res->num = strtod(s, (char **)&p);
160                 tok = NUMBER;
161                 break;
162         default:
163                 tok = *s;
164                 break;
165         }
166         *pp = p;
167         return tok;
168 }
169
170 /* Caller must make sure id is allocated */
171 void expr__add_id(struct parse_ctx *ctx, const char *name, double val)
172 {
173         int idx;
174         assert(ctx->num_ids < MAX_PARSE_ID);
175         idx = ctx->num_ids++;
176         ctx->ids[idx].name = name;
177         ctx->ids[idx].val = val;
178 }
179
180 void expr__ctx_init(struct parse_ctx *ctx)
181 {
182         ctx->num_ids = 0;
183 }
184
185 static bool already_seen(const char *val, const char *one, const char **other,
186                          int num_other)
187 {
188         int i;
189
190         if (one && !strcasecmp(one, val))
191                 return true;
192         for (i = 0; i < num_other; i++)
193                 if (!strcasecmp(other[i], val))
194                         return true;
195         return false;
196 }
197
198 int expr__find_other(const char *p, const char *one, const char ***other,
199                      int *num_otherp)
200 {
201         const char *orig = p;
202         int err = -1;
203         int num_other;
204
205         *other = malloc((EXPR_MAX_OTHER + 1) * sizeof(char *));
206         if (!*other)
207                 return -1;
208
209         num_other = 0;
210         for (;;) {
211                 YYSTYPE val;
212                 int tok = expr__lex(&val, &p);
213                 if (tok == 0) {
214                         err = 0;
215                         break;
216                 }
217                 if (tok == ID && !already_seen(val.id, one, *other, num_other)) {
218                         if (num_other >= EXPR_MAX_OTHER - 1) {
219                                 pr_debug("Too many extra events in %s\n", orig);
220                                 break;
221                         }
222                         (*other)[num_other] = strdup(val.id);
223                         if (!(*other)[num_other])
224                                 return -1;
225                         num_other++;
226                 }
227         }
228         (*other)[num_other] = NULL;
229         *num_otherp = num_other;
230         if (err) {
231                 *num_otherp = 0;
232                 free(*other);
233                 *other = NULL;
234         }
235         return err;
236 }