source: branches/3.2/mindi-busybox/coreutils/expr.c @ 3232

Last change on this file since 3232 was 3232, checked in by bruno, 5 years ago
  • Update mindi-busybox to 1.21.1
File size: 11.5 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Mini expr implementation for busybox
4 *
5 * based on GNU expr Mike Parker.
6 * Copyright (C) 86, 1991-1997, 1999 Free Software Foundation, Inc.
7 *
8 * Busybox modifications
9 * Copyright (c) 2000  Edward Betts <edward@debian.org>.
10 * Copyright (C) 2003-2005  Vladimir Oleynik <dzo@simtreas.ru>
11 *  - reduced 464 bytes.
12 *  - 64 math support
13 *
14 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
15 */
16
17/* This program evaluates expressions.  Each token (operator, operand,
18 * parenthesis) of the expression must be a separate argument.  The
19 * parser used is a reasonably general one, though any incarnation of
20 * it is language-specific.  It is especially nice for expressions.
21 *
22 * No parse tree is needed; a new node is evaluated immediately.
23 * One function can handle multiple operators all of equal precedence,
24 * provided they all associate ((x op x) op x). */
25
26/* no getopt needed */
27
28//usage:#define expr_trivial_usage
29//usage:       "EXPRESSION"
30//usage:#define expr_full_usage "\n\n"
31//usage:       "Print the value of EXPRESSION to stdout\n"
32//usage:    "\n"
33//usage:       "EXPRESSION may be:\n"
34//usage:       "    ARG1 | ARG2 ARG1 if it is neither null nor 0, otherwise ARG2\n"
35//usage:       "    ARG1 & ARG2 ARG1 if neither argument is null or 0, otherwise 0\n"
36//usage:       "    ARG1 < ARG2 1 if ARG1 is less than ARG2, else 0. Similarly:\n"
37//usage:       "    ARG1 <= ARG2\n"
38//usage:       "    ARG1 = ARG2\n"
39//usage:       "    ARG1 != ARG2\n"
40//usage:       "    ARG1 >= ARG2\n"
41//usage:       "    ARG1 > ARG2\n"
42//usage:       "    ARG1 + ARG2 Sum of ARG1 and ARG2. Similarly:\n"
43//usage:       "    ARG1 - ARG2\n"
44//usage:       "    ARG1 * ARG2\n"
45//usage:       "    ARG1 / ARG2\n"
46//usage:       "    ARG1 % ARG2\n"
47//usage:       "    STRING : REGEXP     Anchored pattern match of REGEXP in STRING\n"
48//usage:       "    match STRING REGEXP Same as STRING : REGEXP\n"
49//usage:       "    substr STRING POS LENGTH Substring of STRING, POS counted from 1\n"
50//usage:       "    index STRING CHARS  Index in STRING where any CHARS is found, or 0\n"
51//usage:       "    length STRING       Length of STRING\n"
52//usage:       "    quote TOKEN     Interpret TOKEN as a string, even if\n"
53//usage:       "                it is a keyword like 'match' or an\n"
54//usage:       "                operator like '/'\n"
55//usage:       "    (EXPRESSION)        Value of EXPRESSION\n"
56//usage:       "\n"
57//usage:       "Beware that many operators need to be escaped or quoted for shells.\n"
58//usage:       "Comparisons are arithmetic if both ARGs are numbers, else\n"
59//usage:       "lexicographical. Pattern matches return the string matched between\n"
60//usage:       "\\( and \\) or null; if \\( and \\) are not used, they return the number\n"
61//usage:       "of characters matched or 0."
62
63#include "libbb.h"
64#include "xregex.h"
65
66#if ENABLE_EXPR_MATH_SUPPORT_64
67typedef int64_t arith_t;
68
69#define PF_REZ      "ll"
70#define PF_REZ_TYPE (long long)
71#define STRTOL(s, e, b) strtoll(s, e, b)
72#else
73typedef long arith_t;
74
75#define PF_REZ      "l"
76#define PF_REZ_TYPE (long)
77#define STRTOL(s, e, b) strtol(s, e, b)
78#endif
79
80/* TODO: use bb_strtol[l]? It's easier to check for errors... */
81
82/* The kinds of value we can have.  */
83enum {
84    INTEGER,
85    STRING
86};
87
88/* A value is.... */
89struct valinfo {
90    smallint type;                  /* Which kind. */
91    union {                         /* The value itself. */
92        arith_t i;
93        char *s;
94    } u;
95};
96typedef struct valinfo VALUE;
97
98/* The arguments given to the program, minus the program name.  */
99struct globals {
100    char **args;
101} FIX_ALIASING;
102#define G (*(struct globals*)&bb_common_bufsiz1)
103#define INIT_G() do { } while (0)
104
105/* forward declarations */
106static VALUE *eval(void);
107
108
109/* Return a VALUE for I.  */
110
111static VALUE *int_value(arith_t i)
112{
113    VALUE *v;
114
115    v = xzalloc(sizeof(VALUE));
116    if (INTEGER) /* otherwise xzaaloc did it already */
117        v->type = INTEGER;
118    v->u.i = i;
119    return v;
120}
121
122/* Return a VALUE for S.  */
123
124static VALUE *str_value(const char *s)
125{
126    VALUE *v;
127
128    v = xzalloc(sizeof(VALUE));
129    if (STRING) /* otherwise xzaaloc did it already */
130        v->type = STRING;
131    v->u.s = xstrdup(s);
132    return v;
133}
134
135/* Free VALUE V, including structure components.  */
136
137static void freev(VALUE *v)
138{
139    if (v->type == STRING)
140        free(v->u.s);
141    free(v);
142}
143
144/* Return nonzero if V is a null-string or zero-number.  */
145
146static int null(VALUE *v)
147{
148    if (v->type == INTEGER)
149        return v->u.i == 0;
150    /* STRING: */
151    return v->u.s[0] == '\0' || LONE_CHAR(v->u.s, '0');
152}
153
154/* Coerce V to a STRING value (can't fail).  */
155
156static void tostring(VALUE *v)
157{
158    if (v->type == INTEGER) {
159        v->u.s = xasprintf("%" PF_REZ "d", PF_REZ_TYPE v->u.i);
160        v->type = STRING;
161    }
162}
163
164/* Coerce V to an INTEGER value.  Return 1 on success, 0 on failure.  */
165
166static bool toarith(VALUE *v)
167{
168    if (v->type == STRING) {
169        arith_t i;
170        char *e;
171
172        /* Don't interpret the empty string as an integer.  */
173        /* Currently does not worry about overflow or int/long differences. */
174        i = STRTOL(v->u.s, &e, 10);
175        if ((v->u.s == e) || *e)
176            return 0;
177        free(v->u.s);
178        v->u.i = i;
179        v->type = INTEGER;
180    }
181    return 1;
182}
183
184/* Return str[0]+str[1] if the next token matches STR exactly.
185   STR must not be NULL.  */
186
187static int nextarg(const char *str)
188{
189    if (*G.args == NULL || strcmp(*G.args, str) != 0)
190        return 0;
191    return (unsigned char)str[0] + (unsigned char)str[1];
192}
193
194/* The comparison operator handling functions.  */
195
196static int cmp_common(VALUE *l, VALUE *r, int op)
197{
198    arith_t ll, rr;
199
200    ll = l->u.i;
201    rr = r->u.i;
202    if (l->type == STRING || r->type == STRING) {
203        tostring(l);
204        tostring(r);
205        ll = strcmp(l->u.s, r->u.s);
206        rr = 0;
207    }
208    /* calculating ll - rr and checking the result is prone to overflows.
209     * We'll do it differently: */
210    if (op == '<')
211        return ll < rr;
212    if (op == ('<' + '='))
213        return ll <= rr;
214    if (op == '=' || (op == '=' + '='))
215        return ll == rr;
216    if (op == '!' + '=')
217        return ll != rr;
218    if (op == '>')
219        return ll > rr;
220    /* >= */
221    return ll >= rr;
222}
223
224/* The arithmetic operator handling functions.  */
225
226static arith_t arithmetic_common(VALUE *l, VALUE *r, int op)
227{
228    arith_t li, ri;
229
230    if (!toarith(l) || !toarith(r))
231        bb_error_msg_and_die("non-numeric argument");
232    li = l->u.i;
233    ri = r->u.i;
234    if (op == '+')
235        return li + ri;
236    if (op == '-')
237        return li - ri;
238    if (op == '*')
239        return li * ri;
240    if (ri == 0)
241        bb_error_msg_and_die("division by zero");
242    if (op == '/')
243        return li / ri;
244    return li % ri;
245}
246
247/* Do the : operator.
248   SV is the VALUE for the lhs (the string),
249   PV is the VALUE for the rhs (the pattern).  */
250
251static VALUE *docolon(VALUE *sv, VALUE *pv)
252{
253    enum { NMATCH = 2 };
254    VALUE *v;
255    regex_t re_buffer;
256    regmatch_t re_regs[NMATCH];
257
258    tostring(sv);
259    tostring(pv);
260
261    if (pv->u.s[0] == '^') {
262        bb_error_msg(
263"warning: '%s': using '^' as the first character\n"
264"of a basic regular expression is not portable; it is ignored", pv->u.s);
265    }
266
267    memset(&re_buffer, 0, sizeof(re_buffer));
268    memset(re_regs, 0, sizeof(re_regs));
269    xregcomp(&re_buffer, pv->u.s, 0);
270
271    /* expr uses an anchored pattern match, so check that there was a
272     * match and that the match starts at offset 0. */
273    if (regexec(&re_buffer, sv->u.s, NMATCH, re_regs, 0) != REG_NOMATCH
274     && re_regs[0].rm_so == 0
275    ) {
276        /* Were \(...\) used? */
277        if (re_buffer.re_nsub > 0 && re_regs[1].rm_so >= 0) {
278            sv->u.s[re_regs[1].rm_eo] = '\0';
279            v = str_value(sv->u.s + re_regs[1].rm_so);
280        } else {
281            v = int_value(re_regs[0].rm_eo);
282        }
283    } else {
284        /* Match failed -- return the right kind of null.  */
285        if (re_buffer.re_nsub > 0)
286            v = str_value("");
287        else
288            v = int_value(0);
289    }
290    regfree(&re_buffer);
291    return v;
292}
293
294/* Handle bare operands and ( expr ) syntax.  */
295
296static VALUE *eval7(void)
297{
298    VALUE *v;
299
300    if (!*G.args)
301        bb_error_msg_and_die("syntax error");
302
303    if (nextarg("(")) {
304        G.args++;
305        v = eval();
306        if (!nextarg(")"))
307            bb_error_msg_and_die("syntax error");
308        G.args++;
309        return v;
310    }
311
312    if (nextarg(")"))
313        bb_error_msg_and_die("syntax error");
314
315    return str_value(*G.args++);
316}
317
318/* Handle match, substr, index, length, and quote keywords.  */
319
320static VALUE *eval6(void)
321{
322    static const char keywords[] ALIGN1 =
323        "quote\0""length\0""match\0""index\0""substr\0";
324
325    VALUE *r, *i1, *i2;
326    VALUE *l = l; /* silence gcc */
327    VALUE *v = v; /* silence gcc */
328    int key = *G.args ? index_in_strings(keywords, *G.args) + 1 : 0;
329
330    if (key == 0) /* not a keyword */
331        return eval7();
332    G.args++; /* We have a valid token, so get the next argument.  */
333    if (key == 1) { /* quote */
334        if (!*G.args)
335            bb_error_msg_and_die("syntax error");
336        return str_value(*G.args++);
337    }
338    if (key == 2) { /* length */
339        r = eval6();
340        tostring(r);
341        v = int_value(strlen(r->u.s));
342        freev(r);
343    } else
344        l = eval6();
345
346    if (key == 3) { /* match */
347        r = eval6();
348        v = docolon(l, r);
349        freev(l);
350        freev(r);
351    }
352    if (key == 4) { /* index */
353        r = eval6();
354        tostring(l);
355        tostring(r);
356        v = int_value(strcspn(l->u.s, r->u.s) + 1);
357        if (v->u.i == (arith_t) strlen(l->u.s) + 1)
358            v->u.i = 0;
359        freev(l);
360        freev(r);
361    }
362    if (key == 5) { /* substr */
363        i1 = eval6();
364        i2 = eval6();
365        tostring(l);
366        if (!toarith(i1) || !toarith(i2)
367         || i1->u.i > (arith_t) strlen(l->u.s)
368         || i1->u.i <= 0 || i2->u.i <= 0)
369            v = str_value("");
370        else {
371            v = xmalloc(sizeof(VALUE));
372            v->type = STRING;
373            v->u.s = xstrndup(l->u.s + i1->u.i - 1, i2->u.i);
374        }
375        freev(l);
376        freev(i1);
377        freev(i2);
378    }
379    return v;
380}
381
382/* Handle : operator (pattern matching).
383   Calls docolon to do the real work.  */
384
385static VALUE *eval5(void)
386{
387    VALUE *l, *r, *v;
388
389    l = eval6();
390    while (nextarg(":")) {
391        G.args++;
392        r = eval6();
393        v = docolon(l, r);
394        freev(l);
395        freev(r);
396        l = v;
397    }
398    return l;
399}
400
401/* Handle *, /, % operators.  */
402
403static VALUE *eval4(void)
404{
405    VALUE *l, *r;
406    int op;
407    arith_t val;
408
409    l = eval5();
410    while (1) {
411        op = nextarg("*");
412        if (!op) { op = nextarg("/");
413         if (!op) { op = nextarg("%");
414          if (!op) return l;
415        }}
416        G.args++;
417        r = eval5();
418        val = arithmetic_common(l, r, op);
419        freev(l);
420        freev(r);
421        l = int_value(val);
422    }
423}
424
425/* Handle +, - operators.  */
426
427static VALUE *eval3(void)
428{
429    VALUE *l, *r;
430    int op;
431    arith_t val;
432
433    l = eval4();
434    while (1) {
435        op = nextarg("+");
436        if (!op) {
437            op = nextarg("-");
438            if (!op) return l;
439        }
440        G.args++;
441        r = eval4();
442        val = arithmetic_common(l, r, op);
443        freev(l);
444        freev(r);
445        l = int_value(val);
446    }
447}
448
449/* Handle comparisons.  */
450
451static VALUE *eval2(void)
452{
453    VALUE *l, *r;
454    int op;
455    arith_t val;
456
457    l = eval3();
458    while (1) {
459        op = nextarg("<");
460        if (!op) { op = nextarg("<=");
461         if (!op) { op = nextarg("=");
462          if (!op) { op = nextarg("==");
463           if (!op) { op = nextarg("!=");
464            if (!op) { op = nextarg(">=");
465             if (!op) { op = nextarg(">");
466              if (!op) return l;
467        }}}}}}
468        G.args++;
469        r = eval3();
470        toarith(l);
471        toarith(r);
472        val = cmp_common(l, r, op);
473        freev(l);
474        freev(r);
475        l = int_value(val);
476    }
477}
478
479/* Handle &.  */
480
481static VALUE *eval1(void)
482{
483    VALUE *l, *r;
484
485    l = eval2();
486    while (nextarg("&")) {
487        G.args++;
488        r = eval2();
489        if (null(l) || null(r)) {
490            freev(l);
491            freev(r);
492            l = int_value(0);
493        } else
494            freev(r);
495    }
496    return l;
497}
498
499/* Handle |.  */
500
501static VALUE *eval(void)
502{
503    VALUE *l, *r;
504
505    l = eval1();
506    while (nextarg("|")) {
507        G.args++;
508        r = eval1();
509        if (null(l)) {
510            freev(l);
511            l = r;
512        } else
513            freev(r);
514    }
515    return l;
516}
517
518int expr_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
519int expr_main(int argc UNUSED_PARAM, char **argv)
520{
521    VALUE *v;
522
523    INIT_G();
524
525    xfunc_error_retval = 2; /* coreutils compat */
526    G.args = argv + 1;
527    if (*G.args == NULL) {
528        bb_error_msg_and_die("too few arguments");
529    }
530    v = eval();
531    if (*G.args)
532        bb_error_msg_and_die("syntax error");
533    if (v->type == INTEGER)
534        printf("%" PF_REZ "d\n", PF_REZ_TYPE v->u.i);
535    else
536        puts(v->u.s);
537    fflush_stdout_and_exit(null(v));
538}
Note: See TracBrowser for help on using the repository browser.