xref: /minix3/bin/expr/expr.y (revision 4322f20d76933bba96f46b4e10b56aa19f85c1d5) 
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 }
458