X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=coreutils%2Fexpr.c;h=b247f08db10801fdaaad5e8e7f98f638c8e3cedc;hb=eb1395147ae98e56b455d0f3f9406725fe189822;hp=c2f5d4f3e9001f26ae54f3821de4c6a014102e7d;hpb=07f6b95d8f75cd38262b02976ff92a5d6d328950;p=oweals%2Fbusybox.git diff --git a/coreutils/expr.c b/coreutils/expr.c index c2f5d4f3e..b247f08db 100644 --- a/coreutils/expr.c +++ b/coreutils/expr.c @@ -5,396 +5,415 @@ * based on GNU expr Mike Parker. * Copyright (C) 86, 1991-1997, 1999 Free Software Foundation, Inc. * - * Busybox modifications + * Busybox modifications * Copyright (c) 2000 Edward Betts . - * Aug 2003 Vladimir Oleynik - reduced 464 bytes. - * - * this program is free software; you can redistribute it and/or modify - * it under the terms of the gnu general public license as published by - * the free software foundation; either version 2 of the license, or - * (at your option) any later version. - * - * this program is distributed in the hope that it will be useful, - * but without any warranty; without even the implied warranty of - * merchantability or fitness for a particular purpose. see the gnu - * general public license for more details. - * - * you should have received a copy of the gnu general public license - * along with this program; if not, write to the free software - * foundation, inc., 59 temple place, suite 330, boston, ma 02111-1307 usa + * Copyright (C) 2003-2005 Vladimir Oleynik + * - reduced 464 bytes. + * - 64 math support * + * Licensed under GPLv2 or later, see file LICENSE in this source tree. */ - /* This program evaluates expressions. Each token (operator, operand, - * parenthesis) of the expression must be a seperate argument. The + * parenthesis) of the expression must be a separate argument. The * parser used is a reasonably general one, though any incarnation of * it is language-specific. It is especially nice for expressions. * * No parse tree is needed; a new node is evaluated immediately. * One function can handle multiple operators all of equal precedence, - * provided they all associate ((x op x) op x). */ - -/* no getopt needed */ - -#include -#include -#include -#include -#include -#include -#include "busybox.h" - + * provided they all associate ((x op x) op x). + */ +//config:config EXPR +//config: bool "expr (6.6 kb)" +//config: default y +//config: help +//config: expr is used to calculate numbers and print the result +//config: to standard output. +//config: +//config:config EXPR_MATH_SUPPORT_64 +//config: bool "Extend Posix numbers support to 64 bit" +//config: default y +//config: depends on EXPR +//config: help +//config: Enable 64-bit math support in the expr applet. This will make +//config: the applet slightly larger, but will allow computation with very +//config: large numbers. + +//applet:IF_EXPR(APPLET_NOEXEC(expr, expr, BB_DIR_USR_BIN, BB_SUID_DROP, expr)) + +//kbuild:lib-$(CONFIG_EXPR) += expr.o + +//usage:#define expr_trivial_usage +//usage: "EXPRESSION" +//usage:#define expr_full_usage "\n\n" +//usage: "Print the value of EXPRESSION to stdout\n" +//usage: "\n" +//usage: "EXPRESSION may be:\n" +//usage: " ARG1 | ARG2 ARG1 if it is neither null nor 0, otherwise ARG2\n" +//usage: " ARG1 & ARG2 ARG1 if neither argument is null or 0, otherwise 0\n" +//usage: " ARG1 < ARG2 1 if ARG1 is less than ARG2, else 0. Similarly:\n" +//usage: " ARG1 <= ARG2\n" +//usage: " ARG1 = ARG2\n" +//usage: " ARG1 != ARG2\n" +//usage: " ARG1 >= ARG2\n" +//usage: " ARG1 > ARG2\n" +//usage: " ARG1 + ARG2 Sum of ARG1 and ARG2. Similarly:\n" +//usage: " ARG1 - ARG2\n" +//usage: " ARG1 * ARG2\n" +//usage: " ARG1 / ARG2\n" +//usage: " ARG1 % ARG2\n" +//usage: " STRING : REGEXP Anchored pattern match of REGEXP in STRING\n" +//usage: " match STRING REGEXP Same as STRING : REGEXP\n" +//usage: " substr STRING POS LENGTH Substring of STRING, POS counted from 1\n" +//usage: " index STRING CHARS Index in STRING where any CHARS is found, or 0\n" +//usage: " length STRING Length of STRING\n" +//usage: " quote TOKEN Interpret TOKEN as a string, even if\n" +//usage: " it is a keyword like 'match' or an\n" +//usage: " operator like '/'\n" +//usage: " (EXPRESSION) Value of EXPRESSION\n" +//usage: "\n" +//usage: "Beware that many operators need to be escaped or quoted for shells.\n" +//usage: "Comparisons are arithmetic if both ARGs are numbers, else\n" +//usage: "lexicographical. Pattern matches return the string matched between\n" +//usage: "\\( and \\) or null; if \\( and \\) are not used, they return the number\n" +//usage: "of characters matched or 0." + +#include "libbb.h" +#include "common_bufsiz.h" +#include "xregex.h" + +#if ENABLE_EXPR_MATH_SUPPORT_64 +typedef int64_t arith_t; + +#define PF_REZ "ll" +#define PF_REZ_TYPE (long long) +#define STRTOL(s, e, b) strtoll(s, e, b) +#else +typedef long arith_t; + +#define PF_REZ "l" +#define PF_REZ_TYPE (long) +#define STRTOL(s, e, b) strtol(s, e, b) +#endif + +/* TODO: use bb_strtol[l]? It's easier to check for errors... */ /* The kinds of value we can have. */ -enum valtype { - integer, - string +enum { + INTEGER, + STRING }; -typedef enum valtype TYPE; /* A value is.... */ struct valinfo { - TYPE type; /* Which kind. */ - union { /* The value itself. */ - int i; + smallint type; /* Which kind. */ + union { /* The value itself. */ + arith_t i; char *s; } u; }; typedef struct valinfo VALUE; /* The arguments given to the program, minus the program name. */ -static char **args; - -static VALUE *docolon (VALUE *sv, VALUE *pv); -static VALUE *eval (void); -static VALUE *int_value (int i); -static VALUE *str_value (char *s); -static int nextarg (char *str); -static int null (VALUE *v); -static int toarith (VALUE *v); -static void freev (VALUE *v); -static void tostring (VALUE *v); - -int expr_main (int argc, char **argv) -{ - VALUE *v; - - if (argc == 1) { - bb_error_msg_and_die("too few arguments"); - } - - args = argv + 1; +struct globals { + char **args; +} FIX_ALIASING; +#define G (*(struct globals*)bb_common_bufsiz1) +#define INIT_G() do { \ + setup_common_bufsiz(); \ + /* NB: noexec applet - globals not zeroed */ \ +} while (0) - v = eval (); - if (*args) - bb_error_msg_and_die ("syntax error"); +/* forward declarations */ +static VALUE *eval(void); - if (v->type == integer) - printf ("%d\n", v->u.i); - else - puts (v->u.s); - - exit (null (v)); -} /* Return a VALUE for I. */ -static VALUE *int_value (int i) +static VALUE *int_value(arith_t i) { VALUE *v; - v = xmalloc (sizeof(VALUE)); - v->type = integer; + v = xzalloc(sizeof(VALUE)); + if (INTEGER) /* otherwise xzalloc did it already */ + v->type = INTEGER; v->u.i = i; return v; } /* Return a VALUE for S. */ -static VALUE *str_value (char *s) +static VALUE *str_value(const char *s) { VALUE *v; - v = xmalloc (sizeof(VALUE)); - v->type = string; - v->u.s = strdup (s); + v = xzalloc(sizeof(VALUE)); + if (STRING) /* otherwise xzalloc did it already */ + v->type = STRING; + v->u.s = xstrdup(s); return v; } /* Free VALUE V, including structure components. */ -static void freev (VALUE *v) +static void freev(VALUE *v) { - if (v->type == string) - free (v->u.s); - free (v); + if (v->type == STRING) + free(v->u.s); + free(v); } /* Return nonzero if V is a null-string or zero-number. */ -static int null (VALUE *v) +static int null(VALUE *v) { - switch (v->type) { - case integer: - return v->u.i == 0; - default: /* string: */ - return v->u.s[0] == '\0' || strcmp (v->u.s, "0") == 0; - } + if (v->type == INTEGER) + return v->u.i == 0; + /* STRING: */ + return v->u.s[0] == '\0' || LONE_CHAR(v->u.s, '0'); } -/* Coerce V to a string value (can't fail). */ +/* Coerce V to a STRING value (can't fail). */ -static void tostring (VALUE *v) +static void tostring(VALUE *v) { - if (v->type == integer) { - bb_xasprintf (&(v->u.s), "%d", v->u.i); - v->type = string; + if (v->type == INTEGER) { + v->u.s = xasprintf("%" PF_REZ "d", PF_REZ_TYPE v->u.i); + v->type = STRING; } } -/* Coerce V to an integer value. Return 1 on success, 0 on failure. */ +/* Coerce V to an INTEGER value. Return 1 on success, 0 on failure. */ -static int toarith (VALUE *v) +static bool toarith(VALUE *v) { - if(v->type == string) { - int i; - - /* Don't interpret the empty string as an integer. */ - if (v->u.s == 0) - return 0; - i = atoi(v->u.s); - free (v->u.s); - v->u.i = i; - v->type = integer; + if (v->type == STRING) { + arith_t i; + char *e; + + /* Don't interpret the empty string as an integer. */ + /* Currently does not worry about overflow or int/long differences. */ + i = STRTOL(v->u.s, &e, 10); + if ((v->u.s == e) || *e) + return 0; + free(v->u.s); + v->u.i = i; + v->type = INTEGER; } return 1; } -/* Return nonzero if the next token matches STR exactly. +/* Return str[0]+str[1] if the next token matches STR exactly. STR must not be NULL. */ -static int -nextarg (char *str) +static int nextarg(const char *str) { - if (*args == NULL) + if (*G.args == NULL || strcmp(*G.args, str) != 0) return 0; - return strcmp (*args, str) == 0; + return (unsigned char)str[0] + (unsigned char)str[1]; } /* The comparison operator handling functions. */ -static int cmp_common (VALUE *l, VALUE *r, int op) +static int cmp_common(VALUE *l, VALUE *r, int op) { - int cmpval; - - if (l->type == string || r->type == string) { - tostring (l); - tostring (r); - cmpval = strcmp (l->u.s, r->u.s); - } - else - cmpval = l->u.i - r->u.i; - switch(op) { - case '<': - return cmpval < 0; - case ('L'+'E'): - return cmpval <= 0; - case '=': - return cmpval == 0; - case '!': - return cmpval != 0; - case '>': - return cmpval > 0; - default: /* >= */ - return cmpval >= 0; + arith_t ll, rr; + + ll = l->u.i; + rr = r->u.i; + if (l->type == STRING || r->type == STRING) { + tostring(l); + tostring(r); + ll = strcmp(l->u.s, r->u.s); + rr = 0; } + /* calculating ll - rr and checking the result is prone to overflows. + * We'll do it differently: */ + if (op == '<') + return ll < rr; + if (op == ('<' + '=')) + return ll <= rr; + if (op == '=' || (op == '=' + '=')) + return ll == rr; + if (op == '!' + '=') + return ll != rr; + if (op == '>') + return ll > rr; + /* >= */ + return ll >= rr; } /* The arithmetic operator handling functions. */ -static int arithmetic_common (VALUE *l, VALUE *r, int op) +static arith_t arithmetic_common(VALUE *l, VALUE *r, int op) { - int li, ri; - - if (!toarith (l) || !toarith (r)) - bb_error_msg_and_die ("non-numeric argument"); - li = l->u.i; - ri = r->u.i; - if((op == '/' || op == '%') && ri == 0) - bb_error_msg_and_die ( "division by zero"); - switch(op) { - case '+': + arith_t li, ri; + + if (!toarith(l) || !toarith(r)) + bb_simple_error_msg_and_die("non-numeric argument"); + li = l->u.i; + ri = r->u.i; + if (op == '+') return li + ri; - case '-': + if (op == '-') return li - ri; - case '*': + if (op == '*') return li * ri; - case '/': + if (ri == 0) + bb_simple_error_msg_and_die("division by zero"); + if (op == '/') return li / ri; - default: - return li % ri; - } + return li % ri; } /* Do the : operator. SV is the VALUE for the lhs (the string), PV is the VALUE for the rhs (the pattern). */ -static VALUE *docolon (VALUE *sv, VALUE *pv) +static VALUE *docolon(VALUE *sv, VALUE *pv) { + enum { NMATCH = 2 }; VALUE *v; - const char *errmsg; - struct re_pattern_buffer re_buffer; - struct re_registers re_regs; - int len; + regex_t re_buffer; + regmatch_t re_regs[NMATCH]; - tostring (sv); - tostring (pv); + tostring(sv); + tostring(pv); if (pv->u.s[0] == '^') { - fprintf (stderr, "\ -warning: unportable BRE: `%s': using `^' as the first character\n\ -of a basic regular expression is not portable; it is being ignored", - pv->u.s); + bb_error_msg( +"warning: '%s': using '^' as the first character\n" +"of a basic regular expression is not portable; it is ignored", pv->u.s); } - len = strlen (pv->u.s); - memset (&re_buffer, 0, sizeof (re_buffer)); - memset (&re_regs, 0, sizeof (re_regs)); - re_buffer.allocated = 2 * len; - re_buffer.buffer = (unsigned char *) xmalloc (re_buffer.allocated); - re_buffer.translate = 0; - re_syntax_options = RE_SYNTAX_POSIX_BASIC; - errmsg = re_compile_pattern (pv->u.s, len, &re_buffer); - if (errmsg) { - bb_error_msg_and_die("%s", errmsg); - } + memset(&re_buffer, 0, sizeof(re_buffer)); + memset(re_regs, 0, sizeof(re_regs)); + xregcomp(&re_buffer, pv->u.s, 0); - len = re_match (&re_buffer, sv->u.s, strlen (sv->u.s), 0, &re_regs); - if (len >= 0) { + /* expr uses an anchored pattern match, so check that there was a + * match and that the match starts at offset 0. */ + if (regexec(&re_buffer, sv->u.s, NMATCH, re_regs, 0) != REG_NOMATCH + && re_regs[0].rm_so == 0 + ) { /* Were \(...\) used? */ - if (re_buffer.re_nsub > 0) { /* was (re_regs.start[1] >= 0) */ - sv->u.s[re_regs.end[1]] = '\0'; - v = str_value (sv->u.s + re_regs.start[1]); + if (re_buffer.re_nsub > 0 && re_regs[1].rm_so >= 0) { + sv->u.s[re_regs[1].rm_eo] = '\0'; + v = str_value(sv->u.s + re_regs[1].rm_so); + } else { + v = int_value(re_regs[0].rm_eo); } - else - v = int_value (len); - } - else { + } else { /* Match failed -- return the right kind of null. */ if (re_buffer.re_nsub > 0) - v = str_value (""); + v = str_value(""); else - v = int_value (0); + v = int_value(0); } - free (re_buffer.buffer); + regfree(&re_buffer); return v; } /* Handle bare operands and ( expr ) syntax. */ -static VALUE *eval7 (void) +static VALUE *eval7(void) { VALUE *v; - if (!*args) - bb_error_msg_and_die ( "syntax error"); + if (!*G.args) + bb_simple_error_msg_and_die("syntax error"); - if (nextarg ("(")) { - args++; - v = eval (); - if (!nextarg (")")) - bb_error_msg_and_die ( "syntax error"); - args++; - return v; - } + if (nextarg("(")) { + G.args++; + v = eval(); + if (!nextarg(")")) + bb_simple_error_msg_and_die("syntax error"); + G.args++; + return v; + } - if (nextarg (")")) - bb_error_msg_and_die ( "syntax error"); + if (nextarg(")")) + bb_simple_error_msg_and_die("syntax error"); - return str_value (*args++); + return str_value(*G.args++); } /* Handle match, substr, index, length, and quote keywords. */ -static VALUE *eval6 (void) +static VALUE *eval6(void) { - VALUE *l, *r, *v, *i1, *i2; - - if (nextarg ("quote")) { - args++; - if (!*args) - bb_error_msg_and_die ( "syntax error"); - return str_value (*args++); + static const char keywords[] ALIGN1 = + "quote\0""length\0""match\0""index\0""substr\0"; + + VALUE *r, *i1, *i2; + VALUE *l = l; /* silence gcc */ + VALUE *v = v; /* silence gcc */ + int key = *G.args ? index_in_strings(keywords, *G.args) + 1 : 0; + + if (key == 0) /* not a keyword */ + return eval7(); + G.args++; /* We have a valid token, so get the next argument. */ + if (key == 1) { /* quote */ + if (!*G.args) + bb_simple_error_msg_and_die("syntax error"); + return str_value(*G.args++); } - else if (nextarg ("length")) { - args++; - r = eval6 (); - tostring (r); - v = int_value (strlen (r->u.s)); - freev (r); - return v; + if (key == 2) { /* length */ + r = eval6(); + tostring(r); + v = int_value(strlen(r->u.s)); + freev(r); + } else + l = eval6(); + + if (key == 3) { /* match */ + r = eval6(); + v = docolon(l, r); + freev(l); + freev(r); } - else if (nextarg ("match")) { - args++; - l = eval6 (); - r = eval6 (); - v = docolon (l, r); - freev (l); - freev (r); - return v; - } - else if (nextarg ("index")) { - args++; - l = eval6 (); - r = eval6 (); - tostring (l); - tostring (r); - v = int_value (strcspn (l->u.s, r->u.s) + 1); - if (v->u.i == (int) strlen (l->u.s) + 1) + if (key == 4) { /* index */ + r = eval6(); + tostring(l); + tostring(r); + v = int_value(strcspn(l->u.s, r->u.s) + 1); + if (v->u.i == (arith_t) strlen(l->u.s) + 1) v->u.i = 0; - freev (l); - freev (r); - return v; + freev(l); + freev(r); } - else if (nextarg ("substr")) { - args++; - l = eval6 (); - i1 = eval6 (); - i2 = eval6 (); - tostring (l); - if (!toarith (i1) || !toarith (i2) - || i1->u.i > (int) strlen (l->u.s) - || i1->u.i <= 0 || i2->u.i <= 0) - v = str_value (""); + if (key == 5) { /* substr */ + i1 = eval6(); + i2 = eval6(); + tostring(l); + if (!toarith(i1) || !toarith(i2) + || i1->u.i > (arith_t) strlen(l->u.s) + || i1->u.i <= 0 || i2->u.i <= 0) + v = str_value(""); else { - v = xmalloc (sizeof(VALUE)); - v->type = string; - v->u.s = bb_xstrndup(l->u.s + i1->u.i - 1, i2->u.i); + v = xmalloc(sizeof(VALUE)); + v->type = STRING; + v->u.s = xstrndup(l->u.s + i1->u.i - 1, i2->u.i); } - freev (l); - freev (i1); - freev (i2); - return v; + freev(l); + freev(i1); + freev(i2); } - else - return eval7 (); + return v; } /* Handle : operator (pattern matching). Calls docolon to do the real work. */ -static VALUE *eval5 (void) +static VALUE *eval5(void) { VALUE *l, *r, *v; - l = eval6 (); - while (nextarg (":")) { - args++; - r = eval6 (); - v = docolon (l, r); - freev (l); - freev (r); + l = eval6(); + while (nextarg(":")) { + G.args++; + r = eval6(); + v = docolon(l, r); + freev(l); + freev(r); l = v; } return l; @@ -402,125 +421,139 @@ static VALUE *eval5 (void) /* Handle *, /, % operators. */ -static VALUE *eval4 (void) +static VALUE *eval4(void) { VALUE *l, *r; - int op, val; + int op; + arith_t val; - l = eval5 (); + l = eval5(); while (1) { - if (nextarg ("*")) - op = '*'; - else if (nextarg ("/")) - op = '/'; - else if (nextarg ("%")) - op = '%'; - else - return l; - args++; - r = eval5 (); - val = arithmetic_common (l, r, op); - freev (l); - freev (r); - l = int_value (val); + op = nextarg("*"); + if (!op) { op = nextarg("/"); + if (!op) { op = nextarg("%"); + if (!op) return l; + }} + G.args++; + r = eval5(); + val = arithmetic_common(l, r, op); + freev(l); + freev(r); + l = int_value(val); } } /* Handle +, - operators. */ -static VALUE *eval3 (void) +static VALUE *eval3(void) { VALUE *l, *r; - int op, val; + int op; + arith_t val; - l = eval4 (); + l = eval4(); while (1) { - if (nextarg ("+")) - op = '+'; - else if (nextarg ("-")) - op = '-'; - else - return l; - args++; - r = eval4 (); - val = arithmetic_common (l, r, op); - freev (l); - freev (r); - l = int_value (val); + op = nextarg("+"); + if (!op) { + op = nextarg("-"); + if (!op) return l; + } + G.args++; + r = eval4(); + val = arithmetic_common(l, r, op); + freev(l); + freev(r); + l = int_value(val); } } /* Handle comparisons. */ -static VALUE *eval2 (void) +static VALUE *eval2(void) { VALUE *l, *r; - int op, val; + int op; + arith_t val; - l = eval3 (); + l = eval3(); while (1) { - if (nextarg ("<")) - op = '<'; - else if (nextarg ("<=")) - op = 'L'+'E'; - else if (nextarg ("=") || nextarg ("==")) - op = '='; - else if (nextarg ("!=")) - op = '!'; - else if (nextarg (">=")) - op = 'G'+'E'; - else if (nextarg (">")) - op = '>'; - else - return l; - args++; - r = eval3 (); - toarith (l); - toarith (r); - val = cmp_common (l, r, op); - freev (l); - freev (r); - l = int_value (val); + op = nextarg("<"); + if (!op) { op = nextarg("<="); + if (!op) { op = nextarg("="); + if (!op) { op = nextarg("=="); + if (!op) { op = nextarg("!="); + if (!op) { op = nextarg(">="); + if (!op) { op = nextarg(">"); + if (!op) return l; + }}}}}} + G.args++; + r = eval3(); + toarith(l); + toarith(r); + val = cmp_common(l, r, op); + freev(l); + freev(r); + l = int_value(val); } } /* Handle &. */ -static VALUE *eval1 (void) +static VALUE *eval1(void) { VALUE *l, *r; - l = eval2 (); - while (nextarg ("&")) { - args++; - r = eval2 (); - if (null (l) || null (r)) { - freev (l); - freev (r); - l = int_value (0); - } - else - freev (r); + l = eval2(); + while (nextarg("&")) { + G.args++; + r = eval2(); + if (null(l) || null(r)) { + freev(l); + freev(r); + l = int_value(0); + } else + freev(r); } return l; } /* Handle |. */ -static VALUE *eval (void) +static VALUE *eval(void) { VALUE *l, *r; - l = eval1 (); - while (nextarg ("|")) { - args++; - r = eval1 (); - if (null (l)) { - freev (l); + l = eval1(); + while (nextarg("|")) { + G.args++; + r = eval1(); + if (null(l)) { + freev(l); l = r; - } - else - freev (r); + } else + freev(r); } return l; } + +int expr_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int expr_main(int argc UNUSED_PARAM, char **argv) +{ + VALUE *v; + + INIT_G(); + + xfunc_error_retval = 2; /* coreutils compat */ + G.args = argv + 1; + if (*G.args == NULL) { + bb_simple_error_msg_and_die("too few arguments"); + } + v = eval(); + if (*G.args) + bb_simple_error_msg_and_die("syntax error"); + if (v->type == INTEGER) + printf("%" PF_REZ "d\n", PF_REZ_TYPE v->u.i); + else + puts(v->u.s); + fflush_stdout_and_exit(null(v)); +}