commands: add let command which supports proper arithmetic
This command works like the corresponding Unix shell command and is used for adding, multiplying and much more. Signed-off-by: Jan Luebbe <jlu@pengutronix.de> Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
This commit is contained in:
parent
b46b57f35a
commit
964893b34b
|
@ -57,6 +57,13 @@ config CMD_READLINE
|
||||||
tristate
|
tristate
|
||||||
prompt "readline"
|
prompt "readline"
|
||||||
|
|
||||||
|
config CMD_LET
|
||||||
|
tristate
|
||||||
|
prompt "let"
|
||||||
|
help
|
||||||
|
the 'let' command is used for arithmetics. It works like the corresponding
|
||||||
|
Unix shell command.
|
||||||
|
|
||||||
config CMD_TRUE
|
config CMD_TRUE
|
||||||
tristate
|
tristate
|
||||||
default y
|
default y
|
||||||
|
|
|
@ -74,6 +74,7 @@ obj-$(CONFIG_CMD_GLOBAL) += global.o
|
||||||
obj-$(CONFIG_CMD_BASENAME) += basename.o
|
obj-$(CONFIG_CMD_BASENAME) += basename.o
|
||||||
obj-$(CONFIG_CMD_DIRNAME) += dirname.o
|
obj-$(CONFIG_CMD_DIRNAME) += dirname.o
|
||||||
obj-$(CONFIG_CMD_READLINK) += readlink.o
|
obj-$(CONFIG_CMD_READLINK) += readlink.o
|
||||||
|
obj-$(CONFIG_CMD_LET) += let.o
|
||||||
obj-$(CONFIG_CMD_LN) += ln.o
|
obj-$(CONFIG_CMD_LN) += ln.o
|
||||||
obj-$(CONFIG_CMD_CLK) += clk.o
|
obj-$(CONFIG_CMD_CLK) += clk.o
|
||||||
obj-$(CONFIG_CMD_TFTP) += tftp.o
|
obj-$(CONFIG_CMD_TFTP) += tftp.o
|
||||||
|
|
|
@ -0,0 +1,93 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2012 Jan Luebbe <j.luebbe@pengutronix.de>
|
||||||
|
*
|
||||||
|
* Partially based on code from BusyBox.
|
||||||
|
*
|
||||||
|
* 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.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <common.h>
|
||||||
|
#include <command.h>
|
||||||
|
#include <environment.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <init.h>
|
||||||
|
#include <malloc.h>
|
||||||
|
#include <xfuncs.h>
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
static void setvar(const char *name, const char *val)
|
||||||
|
{
|
||||||
|
setenv(name, val); /* return value is always 0 */
|
||||||
|
}
|
||||||
|
|
||||||
|
static arith_t run_arith(const char *s)
|
||||||
|
{
|
||||||
|
arith_state_t math_state;
|
||||||
|
arith_t result;
|
||||||
|
|
||||||
|
math_state.lookupvar = getenv;
|
||||||
|
math_state.setvar = setvar;
|
||||||
|
math_state.endofname = arith_endofname;
|
||||||
|
|
||||||
|
result = arith(&math_state, s);
|
||||||
|
if (math_state.errmsg)
|
||||||
|
printf("let: %s\n", math_state.errmsg);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int do_let(int argc, char *argv[])
|
||||||
|
{
|
||||||
|
arith_t i;
|
||||||
|
|
||||||
|
argv++;
|
||||||
|
if (!*argv) {
|
||||||
|
printf("let: expression expected\n");
|
||||||
|
return COMMAND_ERROR_USAGE;
|
||||||
|
}
|
||||||
|
|
||||||
|
do {
|
||||||
|
i = run_arith(*argv);
|
||||||
|
} while (*++argv);
|
||||||
|
|
||||||
|
return !i;
|
||||||
|
}
|
||||||
|
|
||||||
|
BAREBOX_CMD_HELP_START(let)
|
||||||
|
BAREBOX_CMD_HELP_USAGE("let expr [expr ...]\n")
|
||||||
|
BAREBOX_CMD_HELP_SHORT("evaluate arithmetic expressions\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT ("supported operations are in order of decreasing precedence:\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X++, X--\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" ++X, --X\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" +X, -X\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" !X, ~X\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X**Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X*Y, X/Y, X%Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X+Y, X-Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X<<Y, X>>Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X<Y, X<=Y, X>=Y, X>Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X==Y, X!=Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X&Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X^Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X|Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X&&Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X||Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X?Y:Z\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X*=Y, X/=Y, X%=Y\n")
|
||||||
|
BAREBOX_CMD_HELP_TEXT (" X=Y, X&=Y, X|=Y, X^=Y, X+=Y, X-=Y, X<<=Y, X>>=Y\n")
|
||||||
|
BAREBOX_CMD_HELP_END
|
||||||
|
|
||||||
|
BAREBOX_CMD_START(let)
|
||||||
|
.cmd = do_let,
|
||||||
|
.usage = "evaluate arithmetic expressions",
|
||||||
|
BAREBOX_CMD_HELP(cmd_let_help)
|
||||||
|
BAREBOX_CMD_END
|
|
@ -0,0 +1,92 @@
|
||||||
|
/* math.h - interface to shell math "library" -- this allows shells to share
|
||||||
|
* the implementation of arithmetic $((...)) expansions.
|
||||||
|
*
|
||||||
|
* This aims to be a POSIX shell math library as documented here:
|
||||||
|
* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_04
|
||||||
|
*
|
||||||
|
* See math.c for internal documentation.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* The math library has just one function:
|
||||||
|
*
|
||||||
|
* arith_t arith(arith_state_t *state, const char *expr);
|
||||||
|
*
|
||||||
|
* The expr argument is the math string to parse. All normal expansions must
|
||||||
|
* be done already. i.e. no dollar symbols should be present.
|
||||||
|
*
|
||||||
|
* The state argument is a pointer to a struct of hooks for your shell (see below),
|
||||||
|
* and an error message string (NULL if no error).
|
||||||
|
*
|
||||||
|
* The function returns the answer to the expression. So if you called it
|
||||||
|
* with the expression:
|
||||||
|
* "1 + 2 + 3"
|
||||||
|
* you would obviously get back 6.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* To add support to a shell, you need to implement three functions:
|
||||||
|
*
|
||||||
|
* lookupvar() - look up and return the value of a variable
|
||||||
|
*
|
||||||
|
* If the shell does:
|
||||||
|
* foo=123
|
||||||
|
* Then the code:
|
||||||
|
* const char *val = lookupvar("foo");
|
||||||
|
* will result in val pointing to "123"
|
||||||
|
*
|
||||||
|
* setvar() - set a variable to some value
|
||||||
|
*
|
||||||
|
* If the arithmetic expansion does something like:
|
||||||
|
* $(( i = 1))
|
||||||
|
* then the math code will make a call like so:
|
||||||
|
* setvar("i", "1", 0);
|
||||||
|
* The storage for the first two parameters are not allocated, so your
|
||||||
|
* shell implementation will most likely need to strdup() them to save.
|
||||||
|
*
|
||||||
|
* endofname() - return the end of a variable name from input
|
||||||
|
*
|
||||||
|
* The arithmetic code does not know about variable naming conventions.
|
||||||
|
* So when it is given an experession, it knows something is not numeric,
|
||||||
|
* but it is up to the shell to dictate what is a valid identifiers.
|
||||||
|
* So when it encounters something like:
|
||||||
|
* $(( some_var + 123 ))
|
||||||
|
* It will make a call like so:
|
||||||
|
* end = endofname("some_var + 123");
|
||||||
|
* So the shell needs to scan the input string and return a pointer to the
|
||||||
|
* first non-identifier string. In this case, it should return the input
|
||||||
|
* pointer with an offset pointing to the first space. The typical
|
||||||
|
* implementation will return the offset of first char that does not match
|
||||||
|
* the regex (in C locale): ^[a-zA-Z_][a-zA-Z_0-9]*
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef LIB_MATH_H
|
||||||
|
#define LIB_MATH_H 1
|
||||||
|
|
||||||
|
#ifdef ENABLE_SH_MATH_SUPPORT_64
|
||||||
|
typedef long long arith_t;
|
||||||
|
#define ARITH_FMT "%lld"
|
||||||
|
#define strto_arith_t simple_strtoull
|
||||||
|
#else
|
||||||
|
typedef long arith_t;
|
||||||
|
#define ARITH_FMT "%ld"
|
||||||
|
#define strto_arith_t simple_strtoul
|
||||||
|
#endif
|
||||||
|
|
||||||
|
# define is_name(c) (isalpha((unsigned char)(c)))
|
||||||
|
# define is_in_name(c) ((c) == '_' || (c) == '.' || isalnum((unsigned char)(c)))
|
||||||
|
const char* arith_endofname(const char *name);
|
||||||
|
|
||||||
|
typedef const char* (*arith_var_lookup_t)(const char *name);
|
||||||
|
typedef void (*arith_var_set_t)(const char *name, const char *val);
|
||||||
|
typedef const char* (*arith_var_endofname_t)(const char *name);
|
||||||
|
|
||||||
|
typedef struct arith_state_t {
|
||||||
|
const char *errmsg;
|
||||||
|
arith_var_lookup_t lookupvar;
|
||||||
|
arith_var_set_t setvar;
|
||||||
|
arith_var_endofname_t endofname;
|
||||||
|
void *list_of_recursed_names;
|
||||||
|
} arith_state_t;
|
||||||
|
|
||||||
|
arith_t arith(arith_state_t *state, const char *expr);
|
||||||
|
|
||||||
|
#endif
|
|
@ -15,6 +15,7 @@ obj-y += libgen.o
|
||||||
obj-y += stringlist.o
|
obj-y += stringlist.o
|
||||||
obj-y += recursive_action.o
|
obj-y += recursive_action.o
|
||||||
obj-y += make_directory.o
|
obj-y += make_directory.o
|
||||||
|
obj-y += math.o
|
||||||
obj-$(CONFIG_BZLIB) += decompress_bunzip2.o
|
obj-$(CONFIG_BZLIB) += decompress_bunzip2.o
|
||||||
obj-$(CONFIG_ZLIB) += decompress_inflate.o zlib_inflate/
|
obj-$(CONFIG_ZLIB) += decompress_inflate.o zlib_inflate/
|
||||||
obj-$(CONFIG_CMDLINE_EDITING) += readline.o
|
obj-$(CONFIG_CMDLINE_EDITING) += readline.o
|
||||||
|
|
|
@ -0,0 +1,795 @@
|
||||||
|
/*
|
||||||
|
* Arithmetic code ripped out of ash shell for code sharing.
|
||||||
|
*
|
||||||
|
* This code is derived from software contributed to Berkeley by
|
||||||
|
* Kenneth Almquist.
|
||||||
|
*
|
||||||
|
* Original BSD copyright notice is retained at the end of this file.
|
||||||
|
*
|
||||||
|
* Copyright (c) 1989, 1991, 1993, 1994
|
||||||
|
* The Regents of the University of California. All rights reserved.
|
||||||
|
*
|
||||||
|
* Copyright (c) 1997-2005 Herbert Xu <herbert@gondor.apana.org.au>
|
||||||
|
* was re-ported from NetBSD and debianized.
|
||||||
|
*
|
||||||
|
* rewrite arith.y to micro stack based cryptic algorithm by
|
||||||
|
* Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
|
||||||
|
*
|
||||||
|
* Modified by Paul Mundt <lethal@linux-sh.org> (c) 2004 to support
|
||||||
|
* dynamic variables.
|
||||||
|
*
|
||||||
|
* Modified by Vladimir Oleynik <dzo@simtreas.ru> (c) 2001-2005 to be
|
||||||
|
* used in busybox and size optimizations,
|
||||||
|
* rewrote arith (see notes to this), added locale support,
|
||||||
|
* rewrote dynamic variables.
|
||||||
|
*
|
||||||
|
* Licensed under GPLv2 or later, see file LICENSE in this source tree.
|
||||||
|
*/
|
||||||
|
/* 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 written in yacc. The supported operators are
|
||||||
|
* listed in #defines below. Parens, order of operations, and error handling
|
||||||
|
* are supported. This code is thread safe. 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 explanation 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).
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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 desirable 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 Vladimir Oleynik.
|
||||||
|
*
|
||||||
|
* Merge in Aaron's comments previously posted to the busybox list,
|
||||||
|
* modified slightly to take account of my changes to the code.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
* (C) 2003 Vladimir Oleynik <dzo@simtreas.ru>
|
||||||
|
*
|
||||||
|
* - allow access to variable,
|
||||||
|
* use recursive value indirection: c="2*2"; a="c"; echo $((a+=2)) produce 6
|
||||||
|
* - implement assign syntax (VAR=expr, +=, *= etc)
|
||||||
|
* - implement exponentiation (** operator)
|
||||||
|
* - implement comma separated - expr, expr
|
||||||
|
* - implement ++expr --expr expr++ expr--
|
||||||
|
* - implement expr ? expr : expr (but second expr is always calculated)
|
||||||
|
* - allow hexadecimal and octal numbers
|
||||||
|
* - restore lost XOR operator
|
||||||
|
* - protect $((num num)) as true zero expr (Manuel's error)
|
||||||
|
* - always use special isspace(), see comment from bash ;-)
|
||||||
|
*/
|
||||||
|
#include <common.h>
|
||||||
|
#include <malloc.h>
|
||||||
|
#include <linux/ctype.h>
|
||||||
|
#include <linux/string.h>
|
||||||
|
#include <libbb.h>
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
#define lookupvar (math_state->lookupvar)
|
||||||
|
#define setvar (math_state->setvar )
|
||||||
|
#define endofname (math_state->endofname)
|
||||||
|
|
||||||
|
typedef unsigned char operator;
|
||||||
|
|
||||||
|
/* An operator's token id is a bit of a bitfield. The lower 5 bits are the
|
||||||
|
* precedence, and 3 high bits are an ID unique across 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_COMMA tok_decl(1,0)
|
||||||
|
|
||||||
|
/* All assignments are right associative and have the same precedence,
|
||||||
|
* but there are 11 of them, which doesn't fit into 3 bits for unique id.
|
||||||
|
* Abusing another precedence level:
|
||||||
|
*/
|
||||||
|
#define TOK_ASSIGN tok_decl(2,0)
|
||||||
|
#define TOK_AND_ASSIGN tok_decl(2,1)
|
||||||
|
#define TOK_OR_ASSIGN tok_decl(2,2)
|
||||||
|
#define TOK_XOR_ASSIGN tok_decl(2,3)
|
||||||
|
#define TOK_PLUS_ASSIGN tok_decl(2,4)
|
||||||
|
#define TOK_MINUS_ASSIGN tok_decl(2,5)
|
||||||
|
#define TOK_LSHIFT_ASSIGN tok_decl(2,6)
|
||||||
|
#define TOK_RSHIFT_ASSIGN tok_decl(2,7)
|
||||||
|
|
||||||
|
#define TOK_MUL_ASSIGN tok_decl(3,0)
|
||||||
|
#define TOK_DIV_ASSIGN tok_decl(3,1)
|
||||||
|
#define TOK_REM_ASSIGN tok_decl(3,2)
|
||||||
|
|
||||||
|
#define fix_assignment_prec(prec) do { if (prec == 3) prec = 2; } while (0)
|
||||||
|
|
||||||
|
/* Ternary conditional operator is right associative too */
|
||||||
|
#define TOK_CONDITIONAL tok_decl(4,0)
|
||||||
|
#define TOK_CONDITIONAL_SEP tok_decl(4,1)
|
||||||
|
|
||||||
|
#define TOK_OR tok_decl(5,0)
|
||||||
|
|
||||||
|
#define TOK_AND tok_decl(6,0)
|
||||||
|
|
||||||
|
#define TOK_BOR tok_decl(7,0)
|
||||||
|
|
||||||
|
#define TOK_BXOR tok_decl(8,0)
|
||||||
|
|
||||||
|
#define TOK_BAND tok_decl(9,0)
|
||||||
|
|
||||||
|
#define TOK_EQ tok_decl(10,0)
|
||||||
|
#define TOK_NE tok_decl(10,1)
|
||||||
|
|
||||||
|
#define TOK_LT tok_decl(11,0)
|
||||||
|
#define TOK_GT tok_decl(11,1)
|
||||||
|
#define TOK_GE tok_decl(11,2)
|
||||||
|
#define TOK_LE tok_decl(11,3)
|
||||||
|
|
||||||
|
#define TOK_LSHIFT tok_decl(12,0)
|
||||||
|
#define TOK_RSHIFT tok_decl(12,1)
|
||||||
|
|
||||||
|
#define TOK_ADD tok_decl(13,0)
|
||||||
|
#define TOK_SUB tok_decl(13,1)
|
||||||
|
|
||||||
|
#define TOK_MUL tok_decl(14,0)
|
||||||
|
#define TOK_DIV tok_decl(14,1)
|
||||||
|
#define TOK_REM tok_decl(14,2)
|
||||||
|
|
||||||
|
/* Exponent is right associative */
|
||||||
|
#define TOK_EXPONENT tok_decl(15,1)
|
||||||
|
|
||||||
|
/* Unary operators */
|
||||||
|
#define UNARYPREC 16
|
||||||
|
#define TOK_BNOT tok_decl(UNARYPREC,0)
|
||||||
|
#define TOK_NOT tok_decl(UNARYPREC,1)
|
||||||
|
|
||||||
|
#define TOK_UMINUS tok_decl(UNARYPREC+1,0)
|
||||||
|
#define TOK_UPLUS tok_decl(UNARYPREC+1,1)
|
||||||
|
|
||||||
|
#define PREC_PRE (UNARYPREC+2)
|
||||||
|
|
||||||
|
#define TOK_PRE_INC tok_decl(PREC_PRE, 0)
|
||||||
|
#define TOK_PRE_DEC tok_decl(PREC_PRE, 1)
|
||||||
|
|
||||||
|
#define PREC_POST (UNARYPREC+3)
|
||||||
|
|
||||||
|
#define TOK_POST_INC tok_decl(PREC_POST, 0)
|
||||||
|
#define TOK_POST_DEC tok_decl(PREC_POST, 1)
|
||||||
|
|
||||||
|
#define SPEC_PREC (UNARYPREC+4)
|
||||||
|
|
||||||
|
#define TOK_NUM tok_decl(SPEC_PREC, 0)
|
||||||
|
#define TOK_RPAREN tok_decl(SPEC_PREC, 1)
|
||||||
|
|
||||||
|
/* from busybox's libbb/skip_whitespace.c */
|
||||||
|
static char *skip_whitespace(const char *s)
|
||||||
|
{
|
||||||
|
/* In POSIX/C locale (the only locale we care about: do we REALLY want
|
||||||
|
* to allow Unicode whitespace in, say, .conf files? nuts!)
|
||||||
|
* isspace is only these chars: "\t\n\v\f\r" and space.
|
||||||
|
* "\t\n\v\f\r" happen to have ASCII codes 9,10,11,12,13.
|
||||||
|
* Use that.
|
||||||
|
*/
|
||||||
|
while (*s == ' ' || (unsigned char)(*s - 9) <= (13 - 9))
|
||||||
|
s++;
|
||||||
|
|
||||||
|
return (char *) s;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int is_assign_op(operator op)
|
||||||
|
{
|
||||||
|
operator prec = PREC(op);
|
||||||
|
fix_assignment_prec(prec);
|
||||||
|
|
||||||
|
return prec == PREC(TOK_ASSIGN)
|
||||||
|
|| prec == PREC_PRE
|
||||||
|
|| prec == PREC_POST;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int is_right_associative(operator prec)
|
||||||
|
{
|
||||||
|
return prec == PREC(TOK_ASSIGN)
|
||||||
|
|| prec == PREC(TOK_EXPONENT)
|
||||||
|
|| prec == PREC(TOK_CONDITIONAL);
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
arith_t val;
|
||||||
|
/* We acquire second_val only when "expr1 : expr2" part
|
||||||
|
* of ternary ?: op is evaluated.
|
||||||
|
* We treat ?: as two binary ops: (expr ? (expr1 : expr2)).
|
||||||
|
* ':' produces a new value which has two parts, val and second_val;
|
||||||
|
* then '?' selects one of them based on its left side.
|
||||||
|
*/
|
||||||
|
arith_t second_val;
|
||||||
|
char second_val_present;
|
||||||
|
/* If NULL then it's just a number, else it's a named variable */
|
||||||
|
char *var;
|
||||||
|
} var_or_num_t;
|
||||||
|
|
||||||
|
typedef struct remembered_name {
|
||||||
|
struct remembered_name *next;
|
||||||
|
const char *var;
|
||||||
|
} remembered_name;
|
||||||
|
|
||||||
|
|
||||||
|
static arith_t evaluate_string(arith_state_t *math_state, const char *expr);
|
||||||
|
|
||||||
|
static const char *arith_lookup_val(arith_state_t *math_state, var_or_num_t *t)
|
||||||
|
{
|
||||||
|
if (t->var) {
|
||||||
|
const char *p = lookupvar(t->var);
|
||||||
|
if (p) {
|
||||||
|
remembered_name *cur;
|
||||||
|
remembered_name cur_save;
|
||||||
|
|
||||||
|
/* did we already see this name?
|
||||||
|
* testcase: a=b; b=a; echo $((a))
|
||||||
|
*/
|
||||||
|
for (cur = math_state->list_of_recursed_names; cur; cur = cur->next) {
|
||||||
|
if (strcmp(cur->var, t->var) == 0) {
|
||||||
|
/* Yes */
|
||||||
|
return "expression recursion loop detected";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* push current var name */
|
||||||
|
cur = math_state->list_of_recursed_names;
|
||||||
|
cur_save.var = t->var;
|
||||||
|
cur_save.next = cur;
|
||||||
|
math_state->list_of_recursed_names = &cur_save;
|
||||||
|
|
||||||
|
/* recursively evaluate p as expression */
|
||||||
|
t->val = evaluate_string(math_state, p);
|
||||||
|
|
||||||
|
/* pop current var name */
|
||||||
|
math_state->list_of_recursed_names = cur;
|
||||||
|
|
||||||
|
return math_state->errmsg;
|
||||||
|
}
|
||||||
|
/* treat undefined var as 0 */
|
||||||
|
t->val = 0;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* "Applying" a token means performing it on the top elements on the integer
|
||||||
|
* stack. For an unary operator it will only change the top element, but a
|
||||||
|
* binary operator will pop two arguments and push the result */
|
||||||
|
static const char* noinline arith_apply(arith_state_t *math_state, operator op,
|
||||||
|
var_or_num_t *numstack, var_or_num_t **numstackptr)
|
||||||
|
{
|
||||||
|
#define NUMPTR (*numstackptr)
|
||||||
|
|
||||||
|
var_or_num_t *top_of_stack;
|
||||||
|
arith_t rez;
|
||||||
|
const char *err;
|
||||||
|
|
||||||
|
/* There is no operator that can work without arguments */
|
||||||
|
if (NUMPTR == numstack)
|
||||||
|
goto err;
|
||||||
|
|
||||||
|
top_of_stack = NUMPTR - 1;
|
||||||
|
|
||||||
|
/* Resolve name to value, if needed */
|
||||||
|
err = arith_lookup_val(math_state, top_of_stack);
|
||||||
|
if (err)
|
||||||
|
return err;
|
||||||
|
|
||||||
|
rez = top_of_stack->val;
|
||||||
|
if (op == TOK_UMINUS)
|
||||||
|
rez = -rez;
|
||||||
|
else if (op == TOK_NOT)
|
||||||
|
rez = !rez;
|
||||||
|
else if (op == TOK_BNOT)
|
||||||
|
rez = ~rez;
|
||||||
|
else if (op == TOK_POST_INC || op == TOK_PRE_INC)
|
||||||
|
rez++;
|
||||||
|
else if (op == TOK_POST_DEC || op == TOK_PRE_DEC)
|
||||||
|
rez--;
|
||||||
|
else if (op != TOK_UPLUS) {
|
||||||
|
/* Binary operators */
|
||||||
|
arith_t right_side_val;
|
||||||
|
char bad_second_val;
|
||||||
|
|
||||||
|
/* Binary operators need two arguments */
|
||||||
|
if (top_of_stack == numstack)
|
||||||
|
goto err;
|
||||||
|
/* ...and they pop one */
|
||||||
|
NUMPTR = top_of_stack; /* this decrements NUMPTR */
|
||||||
|
|
||||||
|
bad_second_val = top_of_stack->second_val_present;
|
||||||
|
if (op == TOK_CONDITIONAL) { /* ? operation */
|
||||||
|
/* Make next if (...) protect against
|
||||||
|
* $((expr1 ? expr2)) - that is, missing ": expr" */
|
||||||
|
bad_second_val = !bad_second_val;
|
||||||
|
}
|
||||||
|
if (bad_second_val) {
|
||||||
|
/* Protect against $((expr <not_?_op> expr1 : expr2)) */
|
||||||
|
return "malformed ?: operator";
|
||||||
|
}
|
||||||
|
|
||||||
|
top_of_stack--; /* now points to left side */
|
||||||
|
|
||||||
|
if (op != TOK_ASSIGN) {
|
||||||
|
/* Resolve left side value (unless the op is '=') */
|
||||||
|
err = arith_lookup_val(math_state, top_of_stack);
|
||||||
|
if (err)
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
right_side_val = rez;
|
||||||
|
rez = top_of_stack->val;
|
||||||
|
if (op == TOK_CONDITIONAL) /* ? operation */
|
||||||
|
rez = (rez ? right_side_val : top_of_stack[1].second_val);
|
||||||
|
else if (op == TOK_CONDITIONAL_SEP) { /* : operation */
|
||||||
|
if (top_of_stack == numstack) {
|
||||||
|
/* Protect against $((expr : expr)) */
|
||||||
|
return "malformed ?: operator";
|
||||||
|
}
|
||||||
|
top_of_stack->second_val_present = op;
|
||||||
|
top_of_stack->second_val = right_side_val;
|
||||||
|
}
|
||||||
|
else if (op == TOK_BOR || op == TOK_OR_ASSIGN)
|
||||||
|
rez |= right_side_val;
|
||||||
|
else if (op == TOK_OR)
|
||||||
|
rez = right_side_val || rez;
|
||||||
|
else if (op == TOK_BAND || op == TOK_AND_ASSIGN)
|
||||||
|
rez &= right_side_val;
|
||||||
|
else if (op == TOK_BXOR || op == TOK_XOR_ASSIGN)
|
||||||
|
rez ^= right_side_val;
|
||||||
|
else if (op == TOK_AND)
|
||||||
|
rez = rez && right_side_val;
|
||||||
|
else if (op == TOK_EQ)
|
||||||
|
rez = (rez == right_side_val);
|
||||||
|
else if (op == TOK_NE)
|
||||||
|
rez = (rez != right_side_val);
|
||||||
|
else if (op == TOK_GE)
|
||||||
|
rez = (rez >= right_side_val);
|
||||||
|
else if (op == TOK_RSHIFT || op == TOK_RSHIFT_ASSIGN)
|
||||||
|
rez >>= right_side_val;
|
||||||
|
else if (op == TOK_LSHIFT || op == TOK_LSHIFT_ASSIGN)
|
||||||
|
rez <<= right_side_val;
|
||||||
|
else if (op == TOK_GT)
|
||||||
|
rez = (rez > right_side_val);
|
||||||
|
else if (op == TOK_LT)
|
||||||
|
rez = (rez < right_side_val);
|
||||||
|
else if (op == TOK_LE)
|
||||||
|
rez = (rez <= right_side_val);
|
||||||
|
else if (op == TOK_MUL || op == TOK_MUL_ASSIGN)
|
||||||
|
rez *= right_side_val;
|
||||||
|
else if (op == TOK_ADD || op == TOK_PLUS_ASSIGN)
|
||||||
|
rez += right_side_val;
|
||||||
|
else if (op == TOK_SUB || op == TOK_MINUS_ASSIGN)
|
||||||
|
rez -= right_side_val;
|
||||||
|
else if (op == TOK_ASSIGN || op == TOK_COMMA)
|
||||||
|
rez = right_side_val;
|
||||||
|
else if (op == TOK_EXPONENT) {
|
||||||
|
arith_t c;
|
||||||
|
if (right_side_val < 0)
|
||||||
|
return "exponent less than 0";
|
||||||
|
c = 1;
|
||||||
|
while (--right_side_val >= 0)
|
||||||
|
c *= rez;
|
||||||
|
rez = c;
|
||||||
|
}
|
||||||
|
else if (right_side_val == 0)
|
||||||
|
return "divide by zero";
|
||||||
|
else if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
|
||||||
|
rez /= right_side_val;
|
||||||
|
else if (op == TOK_REM || op == TOK_REM_ASSIGN)
|
||||||
|
rez %= right_side_val;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (is_assign_op(op)) {
|
||||||
|
char buf[sizeof(arith_t)*3 + 2];
|
||||||
|
|
||||||
|
if (top_of_stack->var == NULL) {
|
||||||
|
/* Hmm, 1=2 ? */
|
||||||
|
|
||||||
|
/*
|
||||||
|
* TODO: actually, bash allows ++7 but for some
|
||||||
|
* reason it evals to 7, not 8
|
||||||
|
*/
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
/* Save to shell variable */
|
||||||
|
sprintf(buf, ARITH_FMT, rez);
|
||||||
|
setvar(top_of_stack->var, buf);
|
||||||
|
/* After saving, make previous value for v++ or v-- */
|
||||||
|
if (op == TOK_POST_INC)
|
||||||
|
rez--;
|
||||||
|
else if (op == TOK_POST_DEC)
|
||||||
|
rez++;
|
||||||
|
}
|
||||||
|
|
||||||
|
top_of_stack->val = rez;
|
||||||
|
/* Erase var name, it is just a number now */
|
||||||
|
free(top_of_stack->var);
|
||||||
|
top_of_stack->var = NULL;
|
||||||
|
return NULL;
|
||||||
|
err:
|
||||||
|
return "arithmetic syntax error";
|
||||||
|
#undef NUMPTR
|
||||||
|
}
|
||||||
|
|
||||||
|
/* longest must be first */
|
||||||
|
static const char op_tokens[] __attribute__((aligned(1))) = {
|
||||||
|
'<','<','=',0, TOK_LSHIFT_ASSIGN,
|
||||||
|
'>','>','=',0, TOK_RSHIFT_ASSIGN,
|
||||||
|
'<','<', 0, TOK_LSHIFT,
|
||||||
|
'>','>', 0, TOK_RSHIFT,
|
||||||
|
'|','|', 0, TOK_OR,
|
||||||
|
'&','&', 0, TOK_AND,
|
||||||
|
'!','=', 0, TOK_NE,
|
||||||
|
'<','=', 0, TOK_LE,
|
||||||
|
'>','=', 0, TOK_GE,
|
||||||
|
'=','=', 0, TOK_EQ,
|
||||||
|
'|','=', 0, TOK_OR_ASSIGN,
|
||||||
|
'&','=', 0, TOK_AND_ASSIGN,
|
||||||
|
'*','=', 0, TOK_MUL_ASSIGN,
|
||||||
|
'/','=', 0, TOK_DIV_ASSIGN,
|
||||||
|
'%','=', 0, TOK_REM_ASSIGN,
|
||||||
|
'+','=', 0, TOK_PLUS_ASSIGN,
|
||||||
|
'-','=', 0, TOK_MINUS_ASSIGN,
|
||||||
|
'-','-', 0, TOK_POST_DEC,
|
||||||
|
'^','=', 0, TOK_XOR_ASSIGN,
|
||||||
|
'+','+', 0, TOK_POST_INC,
|
||||||
|
'*','*', 0, TOK_EXPONENT,
|
||||||
|
'!', 0, TOK_NOT,
|
||||||
|
'<', 0, TOK_LT,
|
||||||
|
'>', 0, TOK_GT,
|
||||||
|
'=', 0, TOK_ASSIGN,
|
||||||
|
'|', 0, TOK_BOR,
|
||||||
|
'&', 0, TOK_BAND,
|
||||||
|
'*', 0, TOK_MUL,
|
||||||
|
'/', 0, TOK_DIV,
|
||||||
|
'%', 0, TOK_REM,
|
||||||
|
'+', 0, TOK_ADD,
|
||||||
|
'-', 0, TOK_SUB,
|
||||||
|
'^', 0, TOK_BXOR,
|
||||||
|
/* uniq */
|
||||||
|
'~', 0, TOK_BNOT,
|
||||||
|
',', 0, TOK_COMMA,
|
||||||
|
'?', 0, TOK_CONDITIONAL,
|
||||||
|
':', 0, TOK_CONDITIONAL_SEP,
|
||||||
|
')', 0, TOK_RPAREN,
|
||||||
|
'(', 0, TOK_LPAREN,
|
||||||
|
0
|
||||||
|
};
|
||||||
|
#define ptr_to_rparen (&op_tokens[sizeof(op_tokens)-7])
|
||||||
|
|
||||||
|
const char *arith_endofname(const char *name)
|
||||||
|
{
|
||||||
|
if (!is_name(*name))
|
||||||
|
return name;
|
||||||
|
while (*++name) {
|
||||||
|
if (!is_in_name(*name))
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return name;
|
||||||
|
}
|
||||||
|
|
||||||
|
static arith_t evaluate_string(arith_state_t *math_state, const char *expr)
|
||||||
|
{
|
||||||
|
operator lasttok;
|
||||||
|
const char *errmsg;
|
||||||
|
const char *start_expr = expr = skip_whitespace(expr);
|
||||||
|
unsigned expr_len = strlen(expr) + 2;
|
||||||
|
/* 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 exercise to the reader.
|
||||||
|
*/
|
||||||
|
var_or_num_t *const numstack = xzalloc((expr_len / 2) * sizeof(numstack[0]));
|
||||||
|
var_or_num_t *numstackptr = numstack;
|
||||||
|
/* Stack of operator tokens */
|
||||||
|
operator *const stack = xzalloc(expr_len * sizeof(stack[0]));
|
||||||
|
operator *stackptr = stack;
|
||||||
|
arith_t result;
|
||||||
|
|
||||||
|
if (numstack == NULL || stack == NULL) {
|
||||||
|
errmsg = "out of memory";
|
||||||
|
goto err_with_custom_msg;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Start with a left paren */
|
||||||
|
*stackptr++ = lasttok = TOK_LPAREN;
|
||||||
|
errmsg = NULL;
|
||||||
|
|
||||||
|
while (1) {
|
||||||
|
const char *p;
|
||||||
|
operator op;
|
||||||
|
operator prec;
|
||||||
|
char arithval;
|
||||||
|
|
||||||
|
expr = skip_whitespace(expr);
|
||||||
|
arithval = *expr;
|
||||||
|
if (arithval == '\0') {
|
||||||
|
if (expr == start_expr) {
|
||||||
|
/* Null expression */
|
||||||
|
numstack->val = 0;
|
||||||
|
goto ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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 != ptr_to_rparen + 1) {
|
||||||
|
/*
|
||||||
|
* If we haven't done so already,
|
||||||
|
* append a closing right paren
|
||||||
|
* and let the loop process it
|
||||||
|
*/
|
||||||
|
expr = ptr_to_rparen;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
/* At this point, we're done with the expression */
|
||||||
|
if (numstackptr != numstack + 1) {
|
||||||
|
/* ...but if there isn't, it's bad */
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
if (numstack->var) {
|
||||||
|
/* expression is $((var)) only, lookup now */
|
||||||
|
errmsg = arith_lookup_val(math_state, numstack);
|
||||||
|
free(numstack->var);
|
||||||
|
numstack->var = NULL;
|
||||||
|
}
|
||||||
|
goto ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
p = endofname(expr);
|
||||||
|
if (p != expr) {
|
||||||
|
/* Name */
|
||||||
|
size_t var_name_size = (p-expr) + 1; /* +1 for NUL */
|
||||||
|
free(numstackptr->var);
|
||||||
|
numstackptr->var = xzalloc(var_name_size);
|
||||||
|
safe_strncpy(numstackptr->var, expr, var_name_size);
|
||||||
|
expr = p;
|
||||||
|
num:
|
||||||
|
numstackptr->second_val_present = 0;
|
||||||
|
numstackptr++;
|
||||||
|
lasttok = TOK_NUM;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isdigit(arithval)) {
|
||||||
|
/* Number */
|
||||||
|
free(numstackptr->var);
|
||||||
|
numstackptr->var = NULL;
|
||||||
|
errno = 0;
|
||||||
|
numstackptr->val = strto_arith_t(expr, (char**) &expr, 0);
|
||||||
|
if (errno)
|
||||||
|
numstackptr->val = 0; /* bash compat */
|
||||||
|
goto num;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Should be an operator */
|
||||||
|
p = op_tokens;
|
||||||
|
while (1) {
|
||||||
|
/*
|
||||||
|
* TODO: bash allows 7+++v, treats it as 7 + ++v
|
||||||
|
* we treat it as 7++ + v and reject
|
||||||
|
*/
|
||||||
|
/* Compare expr to current op_tokens[] element */
|
||||||
|
const char *e = expr;
|
||||||
|
while (1) {
|
||||||
|
if (*p == '\0') {
|
||||||
|
/* Match: operator is found */
|
||||||
|
expr = e;
|
||||||
|
goto tok_found;
|
||||||
|
}
|
||||||
|
if (*p != *e)
|
||||||
|
break;
|
||||||
|
p++;
|
||||||
|
e++;
|
||||||
|
}
|
||||||
|
/* No match, go to next element of op_tokens[] */
|
||||||
|
while (*p)
|
||||||
|
p++;
|
||||||
|
p += 2; /* skip NUL and TOK_foo bytes */
|
||||||
|
if (*p == '\0') {
|
||||||
|
/* No next element, operator not found */
|
||||||
|
//math_state->syntax_error_at = expr;
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
tok_found:
|
||||||
|
op = p[1]; /* fetch TOK_foo value */
|
||||||
|
/* NB: expr now points past the operator */
|
||||||
|
|
||||||
|
/* post grammar: a++ reduce to num */
|
||||||
|
if (lasttok == TOK_POST_INC || lasttok == TOK_POST_DEC)
|
||||||
|
lasttok = TOK_NUM;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Plus and minus are binary (not unary) _only_ if the last
|
||||||
|
* token was a 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) {
|
||||||
|
switch (op) {
|
||||||
|
case TOK_ADD:
|
||||||
|
op = TOK_UPLUS;
|
||||||
|
break;
|
||||||
|
case TOK_SUB:
|
||||||
|
op = TOK_UMINUS;
|
||||||
|
break;
|
||||||
|
case TOK_POST_INC:
|
||||||
|
op = TOK_PRE_INC;
|
||||||
|
break;
|
||||||
|
case TOK_POST_DEC:
|
||||||
|
op = TOK_PRE_DEC;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
* We don't want an 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. If op is right-associative,
|
||||||
|
* then stop "applying" on the equal priority too.
|
||||||
|
* Left paren is given the lowest priority so it will never be
|
||||||
|
* "applied" in this way.
|
||||||
|
*/
|
||||||
|
prec = PREC(op);
|
||||||
|
if ((prec > 0 && prec < UNARYPREC) || prec == SPEC_PREC) {
|
||||||
|
/* not left paren or unary */
|
||||||
|
if (lasttok != TOK_NUM) {
|
||||||
|
/* binary op must be preceded by a num */
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
while (stackptr != stack) {
|
||||||
|
operator prev_op = *--stackptr;
|
||||||
|
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 (prev_op == TOK_LPAREN) {
|
||||||
|
/*
|
||||||
|
* Any operator directly after a
|
||||||
|
* close paren should consider itself binary
|
||||||
|
*/
|
||||||
|
lasttok = TOK_NUM;
|
||||||
|
goto next;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
operator prev_prec = PREC(prev_op);
|
||||||
|
fix_assignment_prec(prec);
|
||||||
|
fix_assignment_prec(prev_prec);
|
||||||
|
if (prev_prec < prec
|
||||||
|
|| (prev_prec == prec && is_right_associative(prec))
|
||||||
|
) {
|
||||||
|
stackptr++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
errmsg = arith_apply(math_state, prev_op, numstack, &numstackptr);
|
||||||
|
if (errmsg)
|
||||||
|
goto err_with_custom_msg;
|
||||||
|
}
|
||||||
|
if (op == TOK_RPAREN)
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Push this operator to the stack and remember it */
|
||||||
|
*stackptr++ = lasttok = op;
|
||||||
|
next: ;
|
||||||
|
} /* while (1) */
|
||||||
|
|
||||||
|
err:
|
||||||
|
errmsg = "arithmetic syntax error";
|
||||||
|
err_with_custom_msg:
|
||||||
|
result = -1;
|
||||||
|
ret:
|
||||||
|
result = numstack->val;
|
||||||
|
free(stack);
|
||||||
|
free(numstack);
|
||||||
|
math_state->errmsg = errmsg;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
arith_t arith(arith_state_t *math_state, const char *expr)
|
||||||
|
{
|
||||||
|
math_state->errmsg = NULL;
|
||||||
|
math_state->list_of_recursed_names = NULL;
|
||||||
|
return evaluate_string(math_state, expr);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Copyright (c) 1989, 1991, 1993, 1994
|
||||||
|
* The Regents of the University of California. All rights reserved.
|
||||||
|
*
|
||||||
|
* This code is derived from software contributed to Berkeley by
|
||||||
|
* Kenneth Almquist.
|
||||||
|
*
|
||||||
|
* Redistribution and use in source and binary forms, with or without
|
||||||
|
* modification, are permitted provided that the following conditions
|
||||||
|
* are met:
|
||||||
|
* 1. Redistributions of source code must retain the above copyright
|
||||||
|
* notice, this list of conditions and the following disclaimer.
|
||||||
|
* 2. Redistributions in binary form must reproduce the above copyright
|
||||||
|
* notice, this list of conditions and the following disclaimer in the
|
||||||
|
* documentation and/or other materials provided with the distribution.
|
||||||
|
* 3. Neither the name of the University nor the names of its contributors
|
||||||
|
* may be used to endorse or promote products derived from this software
|
||||||
|
* without specific prior written permission.
|
||||||
|
*
|
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||||
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||||
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||||
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||||
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||||
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||||
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||||
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||||
|
* SUCH DAMAGE.
|
||||||
|
*/
|
Loading…
Reference in New Issue