Home | History | Annotate | Line # | Download | only in expr
expr.y revision 1.44 
      1 /* $NetBSD: expr.y,v 1.44 2018/06/27 17:12:49 kamil 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 (at) NetBSD.org> and J.T. Conklin <jtc (at) 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.44 2018/06/27 17:12:49 kamil 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, l, r;
    277 
    278 	res = 0;
    279 
    280 	if (!is_integer(left)) {
    281 		yyerror("non-integer argument '%s'", left);
    282 		/* NOTREACHED */
    283 	}
    284 	if (!is_integer(right)) {
    285 		yyerror("non-integer argument '%s'", right);
    286 		/* NOTREACHED */
    287 	}
    288 
    289 	errno = 0;
    290 	l = strtoll(left, NULL, 10);
    291 	if (errno == ERANGE) {
    292 		yyerror("value '%s' is %s is %lld", left,
    293 		    (l > 0) ? "too big, maximum" : "too small, minimum",
    294 		    (l > 0) ? LLONG_MAX : LLONG_MIN);
    295 		/* NOTREACHED */
    296 	}
    297 
    298 	errno = 0;
    299 	r = strtoll(right, NULL, 10);
    300 	if (errno == ERANGE) {
    301 		yyerror("value '%s' is %s is %lld", right,
    302 		    (l > 0) ? "too big, maximum" : "too small, minimum",
    303 	  	    (l > 0) ? LLONG_MAX : LLONG_MIN);
    304 		/* NOTREACHED */
    305 	}
    306 
    307 	switch(op[0]) {
    308 	case '+':
    309 		/*
    310 		 * Check for over-& underflow.
    311 		 */
    312 		if ((l >= 0 && r <= INT64_MAX - l) ||
    313 		    (l <= 0 && r >= INT64_MIN - l)) {
    314 			res = l + r;
    315 		} else {
    316 			yyerror("integer overflow or underflow occurred for "
    317                             "operation '%s %s %s'", left, op, right);
    318 		}
    319 		break;
    320 	case '-':
    321 		/*
    322 		 * Check for over-& underflow.
    323 		 */
    324 		if ((r > 0 && l < INT64_MIN + r) ||
    325 		    (r < 0 && l > INT64_MAX + r)) {
    326 			yyerror("integer overflow or underflow occurred for "
    327 			    "operation '%s %s %s'", left, op, right);
    328 		} else {
    329 			res = l - r;
    330 		}
    331 		break;
    332 	case '/':
    333 		if (r == 0)
    334 			yyerror("second argument to '%s' must not be zero", op);
    335 		if (l == INT64_MIN && r == -1)
    336 			yyerror("integer overflow or underflow occurred for "
    337 			    "operation '%s %s %s'", left, op, right);
    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 		if (l == INT64_MIN && r == -1)
    345 			yyerror("integer overflow or underflow occurred for "
    346 			    "operation '%s %s %s'", left, op, right);
    347 		res = l % r;
    348 		break;
    349 	case '*':
    350 		/*
    351 		 * Check for over-& underflow.
    352 		 */
    353 
    354 		/*
    355 		 * Simplify the conditions:
    356 		 *  - remove the case of both negative arguments
    357 		 *    unless the operation will cause an overflow
    358 		 */
    359 		if (l < 0 && r < 0 && l != INT64_MIN && r != INT64_MIN) {
    360 			l = -l;
    361 			r = -r;
    362 		}
    363 
    364 		/* - remove the case of legative l and positive r */
    365 		if (l < 0 && r >= 0) {
    366 			/* Use res as a temporary variable */
    367 			res = l;
    368 			l = r;
    369 			r = res;
    370 		}
    371 
    372 		if ((l < 0 && r < 0) ||
    373 		    (r > 0 && l > INT64_MAX / r) ||
    374 		    (r <= 0 && r < INT64_MIN / l)) {
    375 			yyerror("integer overflow or underflow occurred for "
    376 			    "operation '%s %s %s'", left, op, right);
    377 			/* NOTREACHED */
    378 		} else {
    379 			res = l * r;
    380 		}
    381 		break;
    382 	}
    383 	return res;
    384 }
    385 
    386 static const char *x = "|&=<>+-*/%:()";
    387 static const int x_token[] = {
    388 	SPEC_OR, SPEC_AND, COMPARE, COMPARE, COMPARE, ADD_SUB_OPERATOR,
    389 	ADD_SUB_OPERATOR, MUL_DIV_MOD_OPERATOR, MUL_DIV_MOD_OPERATOR,
    390 	MUL_DIV_MOD_OPERATOR, SPEC_REG, LEFT_PARENT, RIGHT_PARENT
    391 };
    392 
    393 static int handle_ddash = 1;
    394 
    395 int
    396 yylex(void)
    397 {
    398 	const char *p = *av++;
    399 	int retval;
    400 
    401 	if (!p)
    402 		retval = 0;
    403 	else if (p[1] == '\0') {
    404 		const char *w = strchr(x, p[0]);
    405 		if (w) {
    406 			retval = x_token[w-x];
    407 		} else {
    408 			retval = STRING;
    409 		}
    410 	} else if (p[1] == '=' && p[2] == '\0'
    411 			&& (p[0] == '>' || p[0] == '<' || p[0] == '!'))
    412 		retval = COMPARE;
    413 	else if (handle_ddash && p[0] == '-' && p[1] == '-' && p[2] == '\0') {
    414 		/* ignore "--" if passed as first argument and isn't followed
    415 		 * by another STRING */
    416 		retval = yylex();
    417 		if (retval != STRING && retval != LEFT_PARENT
    418 		    && retval != RIGHT_PARENT) {
    419 			/* is not followed by string or parenthesis, use as
    420 			 * STRING */
    421 			retval = STRING;
    422 			av--;	/* was increased in call to yylex() above */
    423 			p = "--";
    424 		} else {
    425 			/* "--" is to be ignored */
    426 			p = yylval;
    427 		}
    428 	} else if (strcmp(p, "length") == 0)
    429 		retval = LENGTH;
    430 	else
    431 		retval = STRING;
    432 
    433 	handle_ddash = 0;
    434 	yylval = p;
    435 
    436 	return retval;
    437 }
    438 
    439 /*
    440  * Print error message and exit with error 2 (syntax error).
    441  */
    442 static __printflike(1, 2) void
    443 yyerror(const char *fmt, ...)
    444 {
    445 	va_list arg;
    446 
    447 	va_start(arg, fmt);
    448 	verrx(2, fmt, arg);
    449 	va_end(arg);
    450 }
    451 
    452 int
    453 main(int argc, const char * const *argv)
    454 {
    455 	setprogname(argv[0]);
    456 	(void)setlocale(LC_ALL, "");
    457 
    458 	if (argc == 1) {
    459 		(void)fprintf(stderr, "usage: %s expression\n",
    460 		    getprogname());
    461 		exit(2);
    462 	}
    463 
    464 	av = argv + 1;
    465 
    466 	return yyparse();
    467 }
    468