tools/perf/util/expr.y

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