summaryrefslogtreecommitdiff
path: root/libbb/arith.c
blob: d79501cc46cf71dd10484426c59117fcbeec3ea2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
/* Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
   
   Permission is hereby granted, free of charge, to any person obtaining
   a copy of this software and associated documentation files (the
   "Software"), to deal in the Software without restriction, including
   without limitation the rights to use, copy, modify, merge, publish,
   distribute, sublicense, and/or sell copies of the Software, and to
   permit persons to whom the Software is furnished to do so, subject to
   the following conditions:
   
   The above copyright notice and this permission notice shall be
   included in all copies or substantial portions of the Software.
   
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

/* This is my infix parser/evaluator. It is optimized for size, intended
 * as a replacement for yacc-based parsers. However, it may well be faster
 * than a comparable parser writen in yacc. The supported operators are
 * listed in #defines below. Parens, order of operations, and error handling
 * are supported. This code is threadsafe. The exact expression format should
 * be that which POSIX specifies for shells. */

/* The code uses a simple two-stack algorithm. See
 * http://www.onthenet.com.au/~grahamis/int2008/week02/lect02.html
 * for a detailed explaination of the infix-to-postfix algorithm on which
 * this is based (this code differs in that it applies operators immediately
 * to the stack instead of adding them to a queue to end up with an
 * expression). */

/* To use the routine, call it with an expression string and error return
 * pointer */

/*
 * Aug 24, 2001              Manuel Novoa III
 *
 * Reduced the generated code size by about 30% (i386) and fixed several bugs.
 *
 * 1) In arith_apply():
 *    a) Cached values of *numptr and &(numptr[-1]).
 *    b) Removed redundant test for zero denominator.
 *
 * 2) In arith():
 *    a) Eliminated redundant code for processing operator tokens by moving
 *       to a table-based implementation.  Also folded handling of parens
 *       into the table.
 *    b) Combined all 3 loops which called arith_apply to reduce generated
 *       code size at the cost of speed.
 *
 * 3) The following expressions were treated as valid by the original code:
 *       1()  ,    0!  ,    1 ( *3 )   .
 *    These bugs have been fixed by internally enclosing the expression in
 *    parens and then checking that all binary ops and right parens are
 *    preceded by a valid expression (NUM_TOKEN).
 *
 * Note: It may be desireable to replace Aaron's test for whitespace with
 * ctype's isspace() if it is used by another busybox applet or if additional
 * whitespace chars should be considered.  Look below the "#include"s for a
 * precompiler test.
 */

/*
 * Aug 26, 2001              Manuel Novoa III
 *
 * Return 0 for null expressions.  Pointed out by vodz.
 *
 * Merge in Aaron's comments previously posted to the busybox list,
 * modified slightly to take account of my changes to the code.
 *
 * TODO: May want to allow access to variables in the arith code.
 *       This would:
 *       1) allow us to evaluate $A as 0 if A isn't set (although this
 *          would require changes to ash.c too).
 *       2) allow us to write expressions as $(( A + 2 )).
 *       This could be done using a callback function passed to the
 *       arith() function of by requiring such a function with fixed
 *       name as an extern.
 */

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "libbb.h"

/* 
 * Use "#if 1" below for Aaron's original test for whitespace.
 * Use "#if 0" for ctype's isspace().
 * */
#if 1
#undef isspace
#define isspace(arithval) \
	(arithval == ' ' || arithval == '\n' || arithval == '\t')
#endif

typedef char operator;

/* An operator's token id is a bit of a bitfield. The lower 5 bits are the
 * precedence, and high 3 are an ID unique accross operators of that
 * precedence. The ID portion is so that multiple operators can have the
 * same precedence, ensuring that the leftmost one is evaluated first.
 * Consider * and /. */

#define tok_decl(prec,id) (((id)<<5)|(prec))
#define PREC(op) ((op)&0x1F)

#define TOK_LPAREN tok_decl(0,0)

#define TOK_OR tok_decl(1,0)

#define TOK_AND tok_decl(2,0)

#define TOK_BOR tok_decl(3,0)

#define TOK_BXOR tok_decl(4,0)

#define TOK_BAND tok_decl(5,0)

#define TOK_EQ tok_decl(6,0)
#define TOK_NE tok_decl(6,1)

#define TOK_LT tok_decl(7,0)
#define TOK_GT tok_decl(7,1)
#define TOK_GE tok_decl(7,2)
#define TOK_LE tok_decl(7,3)

#define TOK_LSHIFT tok_decl(8,0)
#define TOK_RSHIFT tok_decl(8,1)

#define TOK_ADD tok_decl(9,0)
#define TOK_SUB tok_decl(9,1)

#define TOK_MUL tok_decl(10,0)
#define TOK_DIV tok_decl(10,1)
#define TOK_REM tok_decl(10,2)

/* For now all unary operators have the same precedence, and that's used to
 * identify them as unary operators
 */
#define UNARYPREC 14
#define TOK_BNOT tok_decl(UNARYPREC,0)
#define TOK_NOT tok_decl(UNARYPREC,1)
#define TOK_UMINUS tok_decl(UNARYPREC,2)
#define TOK_UPLUS tok_decl(UNARYPREC,3)

#define TOK_NUM tok_decl(15,0)
#define TOK_RPAREN tok_decl(15,1)
#define TOK_ERROR  tok_decl(15,2)	/* just a place-holder really */

#define ARITH_APPLY(op) arith_apply(op, numstack, &numstackptr)
#define NUMPTR (*numstackptr)

/* "applying" a token means performing it on the top elements on the integer
 * stack. For a unary operator it will only change the top element, but a
 * binary operator will pop two arguments and push a result
 */
static short arith_apply(operator    op, long *numstack, long **numstackptr)
{
	long numptr_val;
	long *NUMPTR_M1;

	/* There is no operator that can work without arguments */
	if (NUMPTR == numstack) {
		goto err;
	}

	NUMPTR_M1 = NUMPTR - 1;
	if (op == TOK_UMINUS) {
		*NUMPTR_M1 *= -1;
	} else if (op == TOK_NOT) {
		*NUMPTR_M1 = !(*NUMPTR_M1);
	} else if (op == TOK_BNOT) {
		*NUMPTR_M1 = ~(*NUMPTR_M1);
	} else if (op != TOK_UPLUS) {
		/* Binary operators */

		/* ... and binary operators need two arguments */
		if (NUMPTR_M1 == numstack) {
			goto err;
		}
		/* ... and they pop one */
		numptr_val = *--NUMPTR;

		NUMPTR_M1 = NUMPTR - 1;

		if (op == TOK_BOR) {
			*NUMPTR_M1 |= numptr_val;
		} else if (op == TOK_OR) {
			*NUMPTR_M1 = numptr_val || *NUMPTR_M1;
		} else if (op == TOK_BAND) {
			*NUMPTR_M1 &= numptr_val;
		} else if (op == TOK_AND) {
			*NUMPTR_M1 = *NUMPTR_M1 && numptr_val;
		} else if (op == TOK_EQ) {
			*NUMPTR_M1 = (*NUMPTR_M1 == numptr_val);
		} else if (op == TOK_NE) {
			*NUMPTR_M1 = (*NUMPTR_M1 != numptr_val);
		} else if (op == TOK_GE) {
			*NUMPTR_M1 = (*NUMPTR_M1 >= numptr_val);
		} else if (op == TOK_RSHIFT) {
			*NUMPTR_M1 >>= numptr_val;
		} else if (op == TOK_LSHIFT) {
			*NUMPTR_M1 <<= numptr_val;
		} else if (op == TOK_GT) {
			*NUMPTR_M1 = (*NUMPTR_M1 > numptr_val);
		} else if (op == TOK_LT) {
			*NUMPTR_M1 = (*NUMPTR_M1 < numptr_val);
		} else if (op == TOK_LE) {
			*NUMPTR_M1 = (*NUMPTR_M1 <= numptr_val);
		} else if (op == TOK_MUL) {
			*NUMPTR_M1 *= numptr_val;
		} else if (op == TOK_ADD) {
			*NUMPTR_M1 += numptr_val;
		} else if (op == TOK_SUB) {
			*NUMPTR_M1 -= numptr_val;
		}
		/* zero divisor check */
		else if (numptr_val == 0) {
			return -2;
		} else if (op == TOK_DIV) {
			*NUMPTR_M1 /= numptr_val;
		} else if (op == TOK_REM) {
			*NUMPTR_M1 %= numptr_val;
		}
		/* WARNING!!!  WARNING!!!  WARNING!!! */
		/* Any new operators should be added BEFORE the zero divisor check! */
	}
	return 0;
  err:
	return (-1);
}

static const char endexpression[] = ")";

/* + and - (in that order) must be last */
static const char op_char[] = "!<>=|&*/%~()+-";
static const char op_token[] = {
	/* paired with equal */
	TOK_NE, TOK_LE, TOK_GE,
	/* paired with self -- note: ! is special-cased below */
	TOK_ERROR, TOK_LSHIFT, TOK_RSHIFT, TOK_EQ, TOK_OR, TOK_AND,
	/* singles */
	TOK_NOT, TOK_LT, TOK_GT, TOK_ERROR, TOK_BOR, TOK_BAND,
	TOK_MUL, TOK_DIV, TOK_REM, TOK_BNOT, TOK_LPAREN, TOK_RPAREN,
	TOK_ADD, TOK_SUB, TOK_UPLUS, TOK_UMINUS
};

#define NUM_PAIR_EQUAL  3
#define NUM_PAIR_SAME   6

extern long arith(const char *expr, int *errcode)
{
	register char arithval;	/* Current character under analysis */
	operator    lasttok, op;
	unsigned char prec;
	const char *p = endexpression;
	size_t datasizes = strlen(expr);

	/* Stack of integers */
	/* The proof that there can be no more than strlen(startbuf)/2+1 integers
	 * in any given correct or incorrect expression is left as an excersize to
	 * the reader. */
	long *numstack = alloca(((datasizes + 1) / 2) * sizeof(long));
	long *numstackptr = numstack;

	/* Stack of operator tokens */
	operator * stack = alloca((datasizes + 1) * sizeof(operator));
	operator * stackptr = stack;

	/* start off with a left paren */
	*stackptr++ = lasttok = TOK_LPAREN;

  loop:
	if ((arithval = *expr) == 0) {
		/* Null expression. */
		if (p == endexpression) {
			return (*errcode = 0);
		}

		/* This is only reached after all tokens have been extracted from the
		 * input stream. If there are still tokens on the operator stack, they
		 * are to be applied in order. At the end, there should be a final
		 * result on the integer stack */

		if (expr != endexpression + 1) {	/* If we haven't done so already, */
			expr = endexpression;	/* append a closing right paren */
			goto loop;	/* and let the loop process it. */
		}
		/* At this point, we're done with the expression. */
		if (numstackptr != numstack + 1) {	/* ... but if there isn't, it's bad */
		  err:
			return (*errcode = -1);
			/* NOTREACHED */
		}
		return *numstack;
	} else {
		/* Continue processing the expression.  */
		/* Skip whitespace */
		if (isspace(arithval)) {
			goto prologue;
		}
		/* isdigit ? */
		if ((unsigned) arithval - '0' <= 9) {
			*numstackptr++ = strtol(expr, (char **) &expr, 10);
			lasttok = TOK_NUM;
			goto loop;
		}
#if 1
		if ((p = strchr(op_char, arithval)) == NULL) {
			goto err;
		}
#else
		for (p = op_char; *p != arithval; p++) {
			if (!*p) {
				goto err;
			}
		}
#endif
		p = op_token + (int) (p - op_char);
		++expr;
		if ((p >= op_token + NUM_PAIR_EQUAL) || (*expr != '=')) {
			p += NUM_PAIR_EQUAL;
			if ((p >= op_token + NUM_PAIR_SAME + NUM_PAIR_EQUAL)
				|| (*expr != arithval) || (arithval == '!')) {
				--expr;
				/* single = */
				if (arithval == '=') {
					goto err;
				}
				p += NUM_PAIR_SAME;
				/* Plus and minus are binary (not unary) _only_ if the last
				 * token was as number, or a right paren (which pretends to be
				 * a number, since it evaluates to one). Think about it.
				 * It makes sense. */
				if ((lasttok != TOK_NUM)
					&& (p >=
						(op_token + NUM_PAIR_SAME + NUM_PAIR_EQUAL +
						 sizeof(op_char) - 2))) {
					/* Unary plus or minus */
					p += 2;
				}
			}
		}
		op = *p;

		/* We don't want a unary operator to cause recursive descent on the
		 * stack, because there can be many in a row and it could cause an
		 * operator to be evaluated before its argument is pushed onto the
		 * integer stack. */
		/* But for binary operators, "apply" everything on the operator
		 * stack until we find an operator with a lesser priority than the
		 * one we have just extracted. */
		/* Left paren is given the lowest priority so it will never be
		 * "applied" in this way */
		prec = PREC(op);

		/* not left paren or unary */
		if ((prec > 0) && (prec != UNARYPREC)) {
			/* binary op must be preceded by a num */
			if (lasttok != TOK_NUM) {
				goto err;
			}
			while (stackptr != stack) {
				if (op == TOK_RPAREN) {
					/* The algorithm employed here is simple: while we don't
					 * hit an open paren nor the bottom of the stack, pop
					 * tokens and apply them */
					if (stackptr[-1] == TOK_LPAREN) {
						--stackptr;

						/* Any operator directly after a */
						lasttok = TOK_NUM;

						/* close paren should consider itself binary */
						goto prologue;
					}
				} else if (PREC(stackptr[-1]) < prec) {
					break;
				}
				*errcode = ARITH_APPLY(*--stackptr);
				if (*errcode) {
					return *errcode;
				}
			}
			if (op == TOK_RPAREN) {
				goto err;
			}
		}

		/* Push this operator to the stack and remember it. */
		*stackptr++ = lasttok = op;

	  prologue:
		++expr;
		goto loop;
	}
}