bin/expr/expr.y

   1 /* $NetBSD: expr.y,v 1.39 2016/09/05 01:00:07 sevan Exp $ */
   2
   3 /*_
   4  * Copyright (c) 2000 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jaromir Dolecek <jdolecek@NetBSD.org> and J.T. Conklin <jtc@NetBSD.org>.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 %{
  33 #include <sys/cdefs.h>
  34 #ifndef lint
  35 __RCSID("$NetBSD: expr.y,v 1.39 2016/09/05 01:00:07 sevan Exp $");
  36 #endif /* not lint */
  37
  38 #include <sys/types.h>
  39
  40 #include <err.h>
  41 #include <errno.h>
  42 #include <limits.h>
  43 #include <locale.h>
  44 #include <regex.h>
  45 #include <stdarg.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49
  50 static const char * const *av;
  51
  52 static void yyerror(const char *, ...) __dead;
  53 static int yylex(void);
  54 static int is_zero_or_null(const char *);
  55 static int is_integer(const char *);
  56 static int64_t perform_arith_op(const char *, const char *, const char *);
  57
  58 #define YYSTYPE const char *
  59
  60 %}
  61 %token STRING
  62 %left SPEC_OR
  63 %left SPEC_AND
  64 %left COMPARE
  65 %left ADD_SUB_OPERATOR
  66 %left MUL_DIV_MOD_OPERATOR
  67 %left SPEC_REG
  68 %left LENGTH
  69 %left LEFT_PARENT RIGHT_PARENT
  70
  71 %%
  72
  73 exp:    expr = {
  74                 (void) printf("%s\n", $1);
  75                 return (is_zero_or_null($1));
  76                 }
  77         ;
  78
  79 expr:   item { $$ = $1; }
  80         | expr SPEC_OR expr = {
  81                 /*
  82                  * Return evaluation of first expression if it is neither
  83                  * an empty string nor zero; otherwise, returns the evaluation
  84                  * of second expression.
  85                  */
  86                 if (!is_zero_or_null($1))
  87                         $$ = $1;
  88                 else
  89                         $$ = $3;
  90                 }
  91         | expr SPEC_AND expr = {
  92                 /*
  93                  * Returns the evaluation of first expr if neither expression
  94                  * evaluates to an empty string or zero; otherwise, returns
  95                  * zero.
  96                  */
  97                 if (!is_zero_or_null($1) && !is_zero_or_null($3))
  98                         $$ = $1;
  99                 else
 100                         $$ = "0";
 101                 }
 102         | expr SPEC_REG expr = {
 103                 /*
 104                  * The ``:'' operator matches first expr against the second,
 105                  * which must be a regular expression.
 106                  */
 107                 regex_t rp;
 108                 regmatch_t rm[2];
 109                 int eval;
 110
 111                 /* compile regular expression */
 112                 if ((eval = regcomp(&rp, $3, REG_BASIC)) != 0) {
 113                         char errbuf[256];
 114                         (void)regerror(eval, &rp, errbuf, sizeof(errbuf));
 115                         yyerror("%s", errbuf);
 116                         /* NOT REACHED */
 117                 }
 118
 119                 /* compare string against pattern --  remember that patterns
 120                    are anchored to the beginning of the line */
 121                 if (regexec(&rp, $1, 2, rm, 0) == 0 && rm[0].rm_so == 0) {
 122                         char *val;
 123                         if (rm[1].rm_so >= 0) {
 124                                 (void) asprintf(&val, "%.*s",
 125                                         (int) (rm[1].rm_eo - rm[1].rm_so),
 126                                         $1 + rm[1].rm_so);
 127                         } else {
 128                                 (void) asprintf(&val, "%d",
 129                                         (int)(rm[0].rm_eo - rm[0].rm_so));
 130                         }
 131                         if (val == NULL)
 132                                 err(1, NULL);
 133                         $$ = val;
 134                 } else {
 135                         if (rp.re_nsub == 0) {
 136                                 $$ = "0";
 137                         } else {
 138                                 $$ = "";
 139                         }
 140                 }
 141
 142                 }
 143         | expr ADD_SUB_OPERATOR expr = {
 144                 /* Returns the results of addition, subtraction */
 145                 char *val;
 146                 int64_t res;
 147
 148                 res = perform_arith_op($1, $2, $3);
 149                 (void) asprintf(&val, "%lld", (long long int) res);
 150                 if (val == NULL)
 151                         err(1, NULL);
 152                 $$ = val;
 153                 }
 154
 155         | expr MUL_DIV_MOD_OPERATOR expr = {
 156                 /*
 157                  * Returns the results of multiply, divide or remainder of
 158                  * numeric-valued arguments.
 159                  */
 160                 char *val;
 161                 int64_t res;
 162
 163                 res = perform_arith_op($1, $2, $3);
 164                 (void) asprintf(&val, "%lld", (long long int) res);
 165                 if (val == NULL)
 166                         err(1, NULL);
 167                 $$ = val;
 168
 169                 }
 170         | expr COMPARE expr = {
 171                 /*
 172                  * Returns the results of integer comparison if both arguments
 173                  * are integers; otherwise, returns the results of string
 174                  * comparison using the locale-specific collation sequence.
 175                  * The result of each comparison is 1 if the specified relation
 176                  * is true, or 0 if the relation is false.
 177                  */
 178
 179                 int64_t l, r;
 180                 int res;
 181
 182                 res = 0;
 183
 184                 /*
 185                  * Slight hack to avoid differences in the compare code
 186                  * between string and numeric compare.
 187                  */
 188                 if (is_integer($1) && is_integer($3)) {
 189                         /* numeric comparison */
 190                         l = strtoll($1, NULL, 10);
 191                         r = strtoll($3, NULL, 10);
 192                 } else {
 193                         /* string comparison */
 194                         l = strcoll($1, $3);
 195                         r = 0;
 196                 }
 197
 198                 switch($2[0]) {
 199                 case '=': /* equal */
 200                         res = (l == r);
 201                         break;
 202                 case '>': /* greater or greater-equal */
 203                         if ($2[1] == '=')
 204                                 res = (l >= r);
 205                         else
 206                                 res = (l > r);
 207                         break;
 208                 case '<': /* lower or lower-equal */
 209                         if ($2[1] == '=')
 210                                 res = (l <= r);
 211                         else
 212                                 res = (l < r);
 213                         break;
 214                 case '!': /* not equal */
 215                         /* the check if this is != was done in yylex() */
 216                         res = (l != r);
 217                 }
 218
 219                 $$ = (res) ? "1" : "0";
 220
 221                 }
 222         | LEFT_PARENT expr RIGHT_PARENT { $$ = $2; }
 223         | LENGTH expr {
 224                 /*
 225                  * Return length of 'expr' in bytes.
 226                  */
 227                 char *ln;
 228
 229                 asprintf(&ln, "%ld", (long) strlen($2));
 230                 if (ln == NULL)
 231                         err(1, NULL);
 232                 $$ = ln;
 233                 }
 234         ;
 235
 236 item:   STRING
 237         | ADD_SUB_OPERATOR
 238         | MUL_DIV_MOD_OPERATOR
 239         | COMPARE
 240         | SPEC_OR
 241         | SPEC_AND
 242         | SPEC_REG
 243         | LENGTH
 244         ;
 245 %%
 246
 247 /*
 248  * Returns 1 if the string is empty or contains only numeric zero.
 249  */
 250 static int
 251 is_zero_or_null(const char *str)
 252 {
 253         char *endptr;
 254
 255         return str[0] == '\0'
 256                 || ( strtoll(str, &endptr, 10) == 0LL
 257                         && endptr[0] == '\0');
 258 }
 259
 260 /*
 261  * Returns 1 if the string is an integer.
 262  */
 263 static int
 264 is_integer(const char *str)
 265 {
 266         char *endptr;
 267
 268         (void) strtoll(str, &endptr, 10);
 269         /* note we treat empty string as valid number */
 270         return (endptr[0] == '\0');
 271 }
 272
 273 static int64_t
 274 perform_arith_op(const char *left, const char *op, const char *right)
 275 {
 276         int64_t res, sign, l, r;
 277         u_int64_t temp;
 278
 279         res = 0;
 280
 281         if (!is_integer(left)) {
 282                 yyerror("non-integer argument '%s'", left);
 283                 /* NOTREACHED */
 284         }
 285         if (!is_integer(right)) {
 286                 yyerror("non-integer argument '%s'", right);
 287                 /* NOTREACHED */
 288         }
 289
 290         errno = 0;
 291         l = strtoll(left, NULL, 10);
 292         if (errno == ERANGE) {
 293                 yyerror("value '%s' is %s is %lld", left,
 294                     (l > 0) ? "too big, maximum" : "too small, minimum",
 295                     (l > 0) ? LLONG_MAX : LLONG_MIN);
 296                 /* NOTREACHED */
 297         }
 298
 299         errno = 0;
 300         r = strtoll(right, NULL, 10);
 301         if (errno == ERANGE) {
 302                 yyerror("value '%s' is %s is %lld", right,
 303                     (l > 0) ? "too big, maximum" : "too small, minimum",
 304                     (l > 0) ? LLONG_MAX : LLONG_MIN);
 305                 /* NOTREACHED */
 306         }
 307
 308         switch(op[0]) {
 309         case '+':
 310                 /*
 311                  * Do the op into an unsigned to avoid overflow and then cast
 312                  * back to check the resulting signage.
 313                  */
 314                 temp = l + r;
 315                 res = (int64_t) temp;
 316                 /* very simplistic check for over-& underflow */
 317                 if ((res < 0 && l > 0 && r > 0)
 318                     || (res > 0 && l < 0 && r < 0))
 319                         yyerror("integer overflow or underflow occurred for "
 320                             "operation '%s %s %s'", left, op, right);
 321                 break;
 322         case '-':
 323                 /*
 324                  * Do the op into an unsigned to avoid overflow and then cast
 325                  * back to check the resulting signage.
 326                  */
 327                 temp = l - r;
 328                 res = (int64_t) temp;
 329                 /* very simplistic check for over-& underflow */
 330                 if ((res < 0 && l > 0 && l > r)
 331                     || (res > 0 && l < 0 && l < r) )
 332                         yyerror("integer overflow or underflow occurred for "
 333                             "operation '%s %s %s'", left, op, right);
 334                 break;
 335         case '/':
 336                 if (r == 0)
 337                         yyerror("second argument to '%s' must not be zero", op);
 338                 res = l / r;
 339
 340                 break;
 341         case '%':
 342                 if (r == 0)
 343                         yyerror("second argument to '%s' must not be zero", op);
 344                 res = l % r;
 345                 break;
 346         case '*':
 347                 /* shortcut */
 348                 if ((l == 0) || (r == 0)) {
 349                         res = 0;
 350                         break;
 351                 }
 352
 353                 sign = 1;
 354                 if (l < 0)
 355                         sign *= -1;
 356                 if (r < 0)
 357                         sign *= -1;
 358
 359                 res = l * r;
 360                 /*
 361                  * XXX: not the most portable but works on anything with 2's
 362                  * complement arithmetic. If the signs don't match or the
 363                  * result was 0 on 2's complement this overflowed.
 364                  */
 365                 if ((res < 0 && sign > 0) || (res > 0 && sign < 0) ||
 366                     (res == 0))
 367                         yyerror("integer overflow or underflow occurred for "
 368                             "operation '%s %s %s'", left, op, right);
 369                         /* NOTREACHED */
 370                 break;
 371         }
 372         return res;
 373 }
 374
 375 static const char *x = "|&=<>+-*/%:()";
 376 static const int x_token[] = {
 377         SPEC_OR, SPEC_AND, COMPARE, COMPARE, COMPARE, ADD_SUB_OPERATOR,
 378         ADD_SUB_OPERATOR, MUL_DIV_MOD_OPERATOR, MUL_DIV_MOD_OPERATOR,
 379         MUL_DIV_MOD_OPERATOR, SPEC_REG, LEFT_PARENT, RIGHT_PARENT
 380 };
 381
 382 static int handle_ddash = 1;
 383
 384 int
 385 yylex(void)
 386 {
 387         const char *p = *av++;
 388         int retval;
 389
 390         if (!p)
 391                 retval = 0;
 392         else if (p[1] == '\0') {
 393                 const char *w = strchr(x, p[0]);
 394                 if (w) {
 395                         retval = x_token[w-x];
 396                 } else {
 397                         retval = STRING;
 398                 }
 399         } else if (p[1] == '=' && p[2] == '\0'
 400                         && (p[0] == '>' || p[0] == '<' || p[0] == '!'))
 401                 retval = COMPARE;
 402         else if (handle_ddash && p[0] == '-' && p[1] == '-' && p[2] == '\0') {
 403                 /* ignore "--" if passed as first argument and isn't followed
 404                  * by another STRING */
 405                 retval = yylex();
 406                 if (retval != STRING && retval != LEFT_PARENT
 407                     && retval != RIGHT_PARENT) {
 408                         /* is not followed by string or parenthesis, use as
 409                          * STRING */
 410                         retval = STRING;
 411                         av--;   /* was increased in call to yylex() above */
 412                         p = "--";
 413                 } else {
 414                         /* "--" is to be ignored */
 415                         p = yylval;
 416                 }
 417         } else if (strcmp(p, "length") == 0)
 418                 retval = LENGTH;
 419         else
 420                 retval = STRING;
 421
 422         handle_ddash = 0;
 423         yylval = p;
 424
 425         return retval;
 426 }
 427
 428 /*
 429  * Print error message and exit with error 2 (syntax error).
 430  */
 431 static __printflike(1, 2) void
 432 yyerror(const char *fmt, ...)
 433 {
 434         va_list arg;
 435
 436         va_start(arg, fmt);
 437         verrx(2, fmt, arg);
 438         va_end(arg);
 439 }
 440
 441 int
 442 main(int argc, const char * const *argv)
 443 {
 444         setprogname(argv[0]);
 445         (void)setlocale(LC_ALL, "");
 446
 447         if (argc == 1) {
 448                 (void)fprintf(stderr, "usage: %s expression\n",
 449                     getprogname());
 450                 exit(2);
 451         }
 452
 453         av = argv + 1;
 454
 455         exit(yyparse());
 456         /* NOTREACHED */
 457 }