/* expr.c -- arithmetic expression evaluation. */
-/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+/* Copyright (C) 1990-2004 Free Software Foundation, Inc.
This file is part of GNU Bash, the Bourne Again SHell.
Bash 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 1, or (at your option)
+ the Free Software Foundation; either version 2, or (at your option)
any later version.
Bash is distributed in the hope that it will be useful, but WITHOUT
You should have received a copy of the GNU General Public License
along with Bash; see the file COPYING. If not, write to the Free
- Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+ Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
/*
- All arithmetic is done as long integers with no checking for overflow
+ All arithmetic is done as intmax_t integers with no checking for overflow
(though division by 0 is caught and flagged as an error).
The following operators are handled, grouped into a set of levels in
order of decreasing precedence.
+ "id++", "id--" [post-increment and post-decrement]
+ "++id", "--id" [pre-increment and pre-decrement]
"-", "+" [(unary operators)]
"!", "~"
+ "**" [(exponentiation)]
"*", "/", "%"
"+", "-"
"<<", ">>"
"&&"
"||"
"expr ? expr : expr"
- "=", "*=", "/=", "%=",
- "+=", "-=", "<<=", ">>=",
- "&=", "^=", "|="
+ "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|="
+ , [comma]
(Note that most of these operators have special meaning to bash, and an
entire expression should be quoted, e.g. "a=$a+1" or "a=a+1" to ensure
#include <stdio.h>
#include "bashansi.h"
+
#if defined (HAVE_UNISTD_H)
+# ifdef _MINIX
+# include <sys/types.h>
+# endif
# include <unistd.h>
#endif
+#include "chartypes.h"
+#include "bashintl.h"
+
#include "shell.h"
/* Because of the $((...)) construct, expressions may include newlines.
#define LSH 9 /* "<<" Left SHift */
#define RSH 10 /* ">>" Right SHift */
#define OP_ASSIGN 11 /* op= expassign as in Posix.2 */
-#define COND 12
+#define COND 12 /* exp1 ? exp2 : exp3 */
+#define POWER 13 /* exp1**exp2 */
+#define PREINC 14 /* ++var */
+#define PREDEC 15 /* --var */
+#define POSTINC 16 /* var++ */
+#define POSTDEC 17 /* var-- */
#define EQ '='
#define GT '>'
#define LT '<'
#define BNOT '~' /* Bitwise NOT; Two's complement. */
#define QUES '?'
#define COL ':'
+#define COMMA ','
+
+/* This should be the function corresponding to the operator with the
+ highest precedence. */
+#define EXP_HIGHEST expcomma
static char *expression; /* The current expression */
static char *tp; /* token lexical position */
static int lasttok; /* the previous token */
static int assigntok; /* the OP in OP= */
static char *tokstr; /* current token string */
-static int tokval; /* current token value */
+static intmax_t tokval; /* current token value */
static int noeval; /* set to 1 if no assignment to be done */
static procenv_t evalbuf;
-static void readtok (); /* lexical analyzer */
-static long subexpr (), expassign (), exp0 (), exp1 (), exp2 (), exp3 (),
- exp4 (), exp5 (), expshift (), expland (), explor (),
- expband (), expbor (), expbxor (), expcond ();
-static long strlong ();
-static void evalerror ();
+static void readtok __P((void)); /* lexical analyzer */
+
+static intmax_t expr_streval __P((char *, int));
+static intmax_t strlong __P((char *));
+static void evalerror __P((char *));
+
+static void pushexp __P((void));
+static void popexp __P((void));
+static void expr_unwind __P((void));
+static void expr_bind_variable __P((char *, char *));
+
+static intmax_t subexpr __P((char *));
+
+static intmax_t expcomma __P((void));
+static intmax_t expassign __P((void));
+static intmax_t expcond __P((void));
+static intmax_t explor __P((void));
+static intmax_t expland __P((void));
+static intmax_t expbor __P((void));
+static intmax_t expbxor __P((void));
+static intmax_t expband __P((void));
+static intmax_t exp5 __P((void));
+static intmax_t exp4 __P((void));
+static intmax_t expshift __P((void));
+static intmax_t exp3 __P((void));
+static intmax_t exp2 __P((void));
+static intmax_t exppower __P((void));
+static intmax_t exp1 __P((void));
+static intmax_t exp0 __P((void));
/* A structure defining a single expression context. */
typedef struct {
int curtok, lasttok;
- char *expression, *tp;
- int tokval;
+ char *expression, *tp, *lasttp;
+ intmax_t tokval;
char *tokstr;
+ int noeval;
} EXPR_CONTEXT;
+#ifdef INCLUDE_UNUSED
+/* Not used yet. */
+typedef struct {
+ char *tokstr;
+ intmax_t tokval;
+} LVALUE;
+#endif
+
/* Global var which contains the stack of expression contexts. */
static EXPR_CONTEXT **expr_stack;
static int expr_depth; /* Location in the stack. */
static int expr_stack_size; /* Number of slots already allocated. */
extern char *this_command_name;
+extern int unbound_vars_is_error;
+
+#if defined (ARRAY_VARS)
+extern char *bash_badsub_errmsg;
+#endif
+
+#define SAVETOK(X) \
+ do { \
+ (X)->curtok = curtok; \
+ (X)->lasttok = lasttok; \
+ (X)->tp = tp; \
+ (X)->lasttp = lasttp; \
+ (X)->tokval = tokval; \
+ (X)->tokstr = tokstr; \
+ (X)->noeval = noeval; \
+ } while (0)
+
+#define RESTORETOK(X) \
+ do { \
+ curtok = (X)->curtok; \
+ lasttok = (X)->lasttok; \
+ tp = (X)->tp; \
+ lasttp = (X)->lasttp; \
+ tokval = (X)->tokval; \
+ tokstr = (X)->tokstr; \
+ noeval = (X)->noeval; \
+ } while (0)
/* Push and save away the contents of the globals describing the
current expression context. */
EXPR_CONTEXT *context;
if (expr_depth >= MAX_EXPR_RECURSION_LEVEL)
- evalerror ("expression recursion level exceeded");
+ evalerror (_("expression recursion level exceeded"));
if (expr_depth >= expr_stack_size)
{
- expr_stack = (EXPR_CONTEXT **)
- xrealloc (expr_stack, (expr_stack_size += EXPR_STACK_GROW_SIZE)
- * sizeof (EXPR_CONTEXT *));
+ expr_stack_size += EXPR_STACK_GROW_SIZE;
+ expr_stack = (EXPR_CONTEXT **)xrealloc (expr_stack, expr_stack_size * sizeof (EXPR_CONTEXT *));
}
context = (EXPR_CONTEXT *)xmalloc (sizeof (EXPR_CONTEXT));
- context->curtok = curtok;
- context->lasttok = lasttok;
context->expression = expression;
- context->tp = tp;
- context->tokval = tokval;
- context->tokstr = tokstr;
+ SAVETOK(context);
+
expr_stack[expr_depth++] = context;
}
EXPR_CONTEXT *context;
if (expr_depth == 0)
- evalerror ("recursion stack underflow");
+ evalerror (_("recursion stack underflow"));
context = expr_stack[--expr_depth];
- curtok = context->curtok;
- lasttok = context->lasttok;
+
expression = context->expression;
- tp = context->tp;
- tokval = context->tokval;
- tokstr = context->tokstr;
+ RESTORETOK (context);
+
free (context);
}
+static void
+expr_unwind ()
+{
+ while (--expr_depth > 0)
+ {
+ if (expr_stack[expr_depth]->tokstr)
+ free (expr_stack[expr_depth]->tokstr);
+
+ if (expr_stack[expr_depth]->expression)
+ free (expr_stack[expr_depth]->expression);
+
+ free (expr_stack[expr_depth]);
+ }
+ free (expr_stack[expr_depth]); /* free the allocated EXPR_CONTEXT */
+}
+
+static void
+expr_bind_variable (lhs, rhs)
+ char *lhs, *rhs;
+{
+ (void)bind_int_variable (lhs, rhs);
+ stupidly_hack_special_variables (lhs);
+}
+
/* Evaluate EXPR, and return the arithmetic result. If VALIDP is
non-null, a zero is stored into the location to which it points
if the expression is invalid, non-zero otherwise. If a non-zero
were assigned at program startup or by the compiler. Therefore, it is
safe to let the loop terminate when expr_depth == 0, without freeing up
any of the expr_depth[0] stuff. */
-long
+intmax_t
evalexp (expr, validp)
char *expr;
int *validp;
{
- long val;
-#if 0
- procenv_t old_evalbuf;
-#endif
+ intmax_t val;
+ int c;
+ procenv_t oevalbuf;
- val = 0L;
+ val = 0;
-#if 0
- /* Save the value of evalbuf to protect it around possible recursive
- calls to evalexp (). */
- COPY_PROCENV (evalbuf, old_evalbuf);
-#endif
+ FASTCOPY (evalbuf, oevalbuf, sizeof (evalbuf));
+
+ c = setjmp (evalbuf);
- if (setjmp (evalbuf))
+ if (c)
{
FREE (tokstr);
FREE (expression);
tokstr = expression = (char *)NULL;
- while (--expr_depth > 0)
- {
- if (expr_stack[expr_depth]->tokstr)
- free (expr_stack[expr_depth]->tokstr);
-
- if (expr_stack[expr_depth]->expression)
- free (expr_stack[expr_depth]->expression);
-
- free (expr_stack[expr_depth]);
- }
- free (expr_stack[expr_depth]); /* free the allocated EXPR_CONTEXT */
+ expr_unwind ();
if (validp)
*validp = 0;
- return (0L);
+ return (0);
}
val = subexpr (expr);
-#if 0
- /* Restore the value of evalbuf so that any subsequent longjmp calls
- will have a valid location to jump to. */
- COPY_PROCENV (old_evalbuf, evalbuf);
-#endif
-
if (validp)
*validp = 1;
+ FASTCOPY (oevalbuf, evalbuf, sizeof (evalbuf));
+
return (val);
}
-static long
+static intmax_t
subexpr (expr)
char *expr;
{
- long val;
+ intmax_t val;
char *p;
for (p = expr; p && *p && cr_whitespace (*p); p++)
;
if (p == NULL || *p == '\0')
- return (0L);
+ return (0);
pushexp ();
curtok = lasttok = 0;
tp = expression;
tokstr = (char *)NULL;
- tokval = 0L;
+ tokval = 0;
readtok ();
- val = expassign ();
+ val = EXP_HIGHEST ();
if (curtok != 0)
- evalerror ("syntax error in expression");
+ evalerror (_("syntax error in expression"));
FREE (tokstr);
FREE (expression);
return val;
}
-/* Bind/create a shell variable with the name LHS to the RHS.
- This creates or modifies a variable such that it is an integer.
-
- This should really be in variables.c, but it is here so that all of the
- expression evaluation stuff is localized. Since we don't want any
- recursive evaluation from bind_variable() (possible without this code,
- since bind_variable() calls the evaluator for variables with the integer
- attribute set), we temporarily turn off the integer attribute for each
- variable we set here, then turn it back on after binding as necessary. */
-
-void
-bind_int_variable (lhs, rhs)
- char *lhs, *rhs;
+static intmax_t
+expcomma ()
{
- register SHELL_VAR *v;
- int isint = 0;
+ register intmax_t value;
- v = find_variable (lhs);
- if (v)
+ value = expassign ();
+ while (curtok == COMMA)
{
- isint = integer_p (v);
- v->attributes &= ~att_integer;
+ readtok ();
+ value = expassign ();
}
- v = bind_variable (lhs, rhs);
- if (isint)
- v->attributes |= att_integer;
+ return value;
}
-
-static long
+
+static intmax_t
expassign ()
{
- register long value;
+ register intmax_t value;
char *lhs, *rhs;
value = expcond ();
if (curtok == EQ || curtok == OP_ASSIGN)
{
int special, op;
- long lvalue;
+ intmax_t lvalue;
special = curtok == OP_ASSIGN;
if (lasttok != STR)
- evalerror ("attempted assignment to non-variable");
+ evalerror (_("attempted assignment to non-variable"));
if (special)
{
lvalue *= value;
break;
case DIV:
+ if (value == 0)
+ evalerror (_("division by 0"));
lvalue /= value;
break;
case MOD:
+ if (value == 0)
+ evalerror (_("division by 0"));
lvalue %= value;
break;
case PLUS:
case BOR:
lvalue |= value;
break;
+ case BXOR:
+ lvalue ^= value;
+ break;
default:
free (lhs);
- evalerror ("bug: bad expassign token");
+ evalerror (_("bug: bad expassign token"));
break;
}
value = lvalue;
rhs = itos (value);
if (noeval == 0)
- bind_int_variable (lhs, rhs);
+ expr_bind_variable (lhs, rhs);
free (rhs);
free (lhs);
FREE (tokstr);
}
/* Conditional expression (expr?expr:expr) */
-static long
+static intmax_t
expcond ()
{
- long cval, val1, val2, rval;
+ intmax_t cval, val1, val2, rval;
int set_noeval;
set_noeval = 0;
{
readtok ();
if (curtok == 0 || curtok == COL)
- evalerror ("expression expected");
+ evalerror (_("expression expected"));
if (cval == 0)
{
set_noeval = 1;
noeval++;
}
-#if 0
- val1 = explor ();
-#else
- val1 = expassign ();
-#endif
+
+ val1 = EXP_HIGHEST ();
+
if (set_noeval)
- noeval--;
+ noeval--;
if (curtok != COL)
- evalerror ("`:' expected for conditional expression");
+ evalerror (_("`:' expected for conditional expression"));
readtok ();
if (curtok == 0)
- evalerror ("expression expected");
+ evalerror (_("expression expected"));
set_noeval = 0;
if (cval)
{
}
val2 = explor ();
if (set_noeval)
- noeval--;
+ noeval--;
rval = cval ? val1 : val2;
lasttok = COND;
}
}
/* Logical OR. */
-static long
+static intmax_t
explor ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
int set_noeval;
val1 = expland ();
}
/* Logical AND. */
-static long
+static intmax_t
expland ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
int set_noeval;
val1 = expbor ();
}
/* Bitwise OR. */
-static long
+static intmax_t
expbor ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
val1 = expbxor ();
}
/* Bitwise XOR. */
-static long
+static intmax_t
expbxor ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
val1 = expband ();
}
/* Bitwise AND. */
-static long
+static intmax_t
expband ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
val1 = exp5 ();
return (val1);
}
-static long
+static intmax_t
exp5 ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
val1 = exp4 ();
return (val1);
}
-static long
+static intmax_t
exp4 ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
val1 = expshift ();
while ((curtok == LEQ) ||
}
/* Left and right shifts. */
-static long
+static intmax_t
expshift ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
val1 = exp3 ();
return (val1);
}
-static long
+static intmax_t
exp3 ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
val1 = exp2 ();
return (val1);
}
-static long
+static intmax_t
exp2 ()
{
- register long val1, val2;
+ register intmax_t val1, val2;
- val1 = exp1 ();
+ val1 = exppower ();
while ((curtok == MUL) ||
- (curtok == DIV) ||
- (curtok == MOD))
+ (curtok == DIV) ||
+ (curtok == MOD))
{
int op = curtok;
readtok ();
- val2 = exp1 ();
+ val2 = exppower ();
if (((op == DIV) || (op == MOD)) && (val2 == 0))
- evalerror ("division by 0");
+ evalerror (_("division by 0"));
if (op == MUL)
- val1 *= val2;
+ val1 *= val2;
else if (op == DIV)
- val1 /= val2;
+ val1 /= val2;
else if (op == MOD)
- val1 %= val2;
+ val1 %= val2;
}
return (val1);
}
-static long
+static intmax_t
+exppower ()
+{
+ register intmax_t val1, val2, c;
+
+ val1 = exp1 ();
+ while (curtok == POWER)
+ {
+ readtok ();
+ val2 = exppower (); /* exponentiation is right-associative */
+ if (val2 == 0)
+ return (1);
+ if (val2 < 0)
+ evalerror (_("exponent less than 0"));
+ for (c = 1; val2--; c *= val1)
+ ;
+ val1 = c;
+ }
+ return (val1);
+}
+
+static intmax_t
exp1 ()
{
- register long val;
+ register intmax_t val;
if (curtok == NOT)
{
return (val);
}
-static long
+static intmax_t
exp0 ()
{
- register long val = 0L;
+ register intmax_t val = 0, v2;
+ char *vincdec;
+ int stok;
+ EXPR_CONTEXT ec;
+
+ /* XXX - might need additional logic here to decide whether or not
+ pre-increment or pre-decrement is legal at this point. */
+ if (curtok == PREINC || curtok == PREDEC)
+ {
+ stok = lasttok = curtok;
+ readtok ();
+ if (curtok != STR)
+ /* readtok() catches this */
+ evalerror (_("identifier expected after pre-increment or pre-decrement"));
+
+ v2 = tokval + ((stok == PREINC) ? 1 : -1);
+ vincdec = itos (v2);
+ if (noeval == 0)
+ expr_bind_variable (tokstr, vincdec);
+ free (vincdec);
+ val = v2;
- if (curtok == MINUS)
+ curtok = NUM; /* make sure --x=7 is flagged as an error */
+ readtok ();
+ }
+ else if (curtok == MINUS)
{
readtok ();
val = - exp0 ();
else if (curtok == LPAR)
{
readtok ();
- val = expassign ();
+ val = EXP_HIGHEST ();
- if (curtok != RPAR)
- evalerror ("missing `)'");
+ if (curtok != RPAR) /* ( */
+ evalerror (_("missing `)'"));
/* Skip over closing paren. */
readtok ();
else if ((curtok == NUM) || (curtok == STR))
{
val = tokval;
+ if (curtok == STR)
+ {
+ SAVETOK (&ec);
+ tokstr = (char *)NULL; /* keep it from being freed */
+ noeval = 1;
+ readtok ();
+ stok = curtok;
+
+ /* post-increment or post-decrement */
+ if (stok == POSTINC || stok == POSTDEC)
+ {
+ /* restore certain portions of EC */
+ tokstr = ec.tokstr;
+ noeval = ec.noeval;
+ lasttok = STR; /* ec.curtok */
+
+ v2 = val + ((stok == POSTINC) ? 1 : -1);
+ vincdec = itos (v2);
+ if (noeval == 0)
+ expr_bind_variable (tokstr, vincdec);
+ free (vincdec);
+ curtok = NUM; /* make sure x++=7 is flagged as an error */
+ }
+ else
+ {
+ if (stok == STR) /* free new tokstr before old one is restored */
+ FREE (tokstr);
+ RESTORETOK (&ec);
+ }
+
+ }
+
readtok ();
}
else
- evalerror ("syntax error: operand expected");
+ evalerror (_("syntax error: operand expected"));
return (val);
}
+static intmax_t
+expr_streval (tok, e)
+ char *tok;
+ int e;
+{
+ SHELL_VAR *v;
+ char *value;
+ intmax_t tval;
+
+ /* [[[[[ */
+#if defined (ARRAY_VARS)
+ v = (e == ']') ? array_variable_part (tok, (char **)0, (int *)0) : find_variable (tok);
+#else
+ v = find_variable (tok);
+#endif
+
+ if ((v == 0 || invisible_p (v)) && unbound_vars_is_error)
+ {
+#if defined (ARRAY_VARS)
+ value = (e == ']') ? array_variable_name (tok, (char **)0, (int *)0) : tok;
+#else
+ value = tok;
+#endif
+
+ err_unboundvar (value);
+
+#if defined (ARRAY_VARS)
+ if (e == ']')
+ FREE (value); /* array_variable_name returns new memory */
+#endif
+
+ if (interactive_shell)
+ {
+ expr_unwind ();
+ jump_to_top_level (DISCARD);
+ }
+ else
+ jump_to_top_level (FORCE_EOF);
+ }
+
+#if defined (ARRAY_VARS)
+ /* Second argument of 0 to get_array_value means that we don't allow
+ references like array[@]. In this case, get_array_value is just
+ like get_variable_value in that it does not return newly-allocated
+ memory or quote the results. */
+ value = (e == ']') ? get_array_value (tok, 0, (int *)NULL) : get_variable_value (v);
+#else
+ value = get_variable_value (v);
+#endif
+
+ tval = (value && *value) ? subexpr (value) : 0;
+
+ return (tval);
+}
+
/* Lexical analyzer/token reader for the expression evaluator. Reads the
next token and puts its value into curtok, while advancing past it.
Updates value of tp. May also set tokval (for number) or tokstr (for
static void
readtok ()
{
- register char *cp;
- register int c, c1, e;
+ register char *cp, *xp;
+ register unsigned char c, c1;
+ register int e;
/* Skip leading whitespace. */
cp = tp;
if (legal_variable_starter (c))
{
- /* Semi-bogus ksh compatibility feature -- variable names
- not preceded with a dollar sign are shell variables. */
- char *value;
+ /* variable names not preceded with a dollar sign are shell variables. */
+ char *savecp;
+ EXPR_CONTEXT ec;
+ int peektok;
while (legal_variable_char (c))
c = *cp++;
e = ']';
}
else
- evalerror ("bad array subscript");
+ evalerror (bash_badsub_errmsg);
}
#endif /* ARRAY_VARS */
*cp = '\0';
-
FREE (tokstr);
tokstr = savestring (tp);
+ *cp = c;
-#if defined (ARRAY_VARS)
- value = (e == ']') ? get_array_value (tokstr, 0) : get_string_value (tokstr);
-#else
- value = get_string_value (tokstr);
-#endif
-
- tokval = (value && *value) ? subexpr (value) : 0;
-
-#if defined (ARRAY_VARS)
- if (e == ']')
- FREE (value); /* get_array_value returns newly-allocated memory */
-#endif
+ SAVETOK (&ec);
+ tokstr = (char *)NULL; /* keep it from being freed */
+ tp = savecp = cp;
+ noeval = 1;
+ curtok = STR;
+ readtok ();
+ peektok = curtok;
+ if (peektok == STR) /* free new tokstr before old one is restored */
+ FREE (tokstr);
+ RESTORETOK (&ec);
+ cp = savecp;
+
+ /* The tests for PREINC and PREDEC aren't strictly correct, but they
+ preserve old behavior if a construct like --x=9 is given. */
+ if (lasttok == PREINC || lasttok == PREDEC || peektok != EQ)
+ tokval = expr_streval (tokstr, e);
+ else
+ tokval = 0;
- *cp = c;
lasttok = curtok;
curtok = STR;
}
- else if (digit(c))
+ else if (DIGIT(c))
{
- while (digit (c) || isletter (c) || c == '#' || c == '@' || c == '_')
+ while (ISALNUM (c) || c == '#' || c == '@' || c == '_')
c = *cp++;
c = *--cp;
c = LAND;
else if ((c == BOR) && (c1 == BOR))
c = LOR;
- else if (c1 == EQ && member(c, "*/%+-&^|"))
+ else if ((c == '*') && (c1 == '*'))
+ c = POWER;
+ else if ((c == '-' || c == '+') && c1 == c && curtok == STR)
+ c = (c == '-') ? POSTDEC : POSTINC;
+ else if ((c == '-' || c == '+') && c1 == c)
+ {
+ /* Quickly scan forward to see if this is followed by optional
+ whitespace and an identifier. */
+ xp = cp;
+ while (xp && *xp && cr_whitespace (*xp))
+ xp++;
+ if (legal_variable_starter ((unsigned char)*xp))
+ c = (c == '-') ? PREDEC : PREINC;
+ else
+ cp--; /* not preinc or predec, so unget the character */
+ }
+ else if (c1 == EQ && member (c, "*/%+-&^|"))
{
assigntok = c; /* a OP= b */
c = OP_ASSIGN;
longjmp (evalbuf, 1);
}
-/* Convert a string to a long integer, with an arbitrary base.
+/* Convert a string to an intmax_t integer, with an arbitrary base.
0nnn -> base 8
- 0xnn -> base 16
+ 0[Xx]nn -> base 16
Anything else: [base#]number (this is implemented to match ksh93)
Base may be >=2 and <=64. If base is <= 36, the numbers are drawn
from [0-9][a-zA-Z], and lowercase and uppercase letters may be used
interchangably. If base is > 36 and <= 64, the numbers are drawn
- from [0-9][a-z][A-Z]_@ (a = 10, z = 35, A = 36, Z = 61, _ = 62, @ = 63 --
+ from [0-9][a-z][A-Z]_@ (a = 10, z = 35, A = 36, Z = 61, @ = 62, _ = 63 --
you get the picture). */
-static long
+static intmax_t
strlong (num)
char *num;
{
register char *s;
- register int c;
+ register unsigned char c;
int base, foundbase;
- long val = 0L;
+ intmax_t val;
s = num;
- if (s == NULL || *s == '\0')
- return 0L;
base = 10;
foundbase = 0;
{
s++;
- if (s == NULL || *s == '\0')
- return 0L;
+ if (*s == '\0')
+ return 0;
/* Base 16? */
if (*s == 'x' || *s == 'X')
foundbase++;
}
- val = 0L;
+ val = 0;
for (c = *s++; c; c = *s++)
{
if (c == '#')
{
if (foundbase)
- evalerror ("bad number");
-
- base = (int)val;
+ evalerror (_("invalid number"));
/* Illegal base specifications raise an evaluation error. */
- if (base < 2 || base > 64)
- evalerror ("illegal arithmetic base");
+ if (val < 2 || val > 64)
+ evalerror (_("invalid arithmetic base"));
- val = 0L;
+ base = val;
+ val = 0;
foundbase++;
}
- else if (isletter(c) || digit(c) || (c == '_') || (c == '@'))
+ else if (ISALNUM(c) || (c == '_') || (c == '@'))
{
- if (digit(c))
- c = digit_value(c);
+ if (DIGIT(c))
+ c = TODIGIT(c);
else if (c >= 'a' && c <= 'z')
c -= 'a' - 10;
else if (c >= 'A' && c <= 'Z')
c -= 'A' - ((base <= 36) ? 10 : 36);
- else if (c == '_')
- c = 62;
else if (c == '@')
+ c = 62;
+ else if (c == '_')
c = 63;
if (c >= base)
- evalerror ("value too great for base");
+ evalerror (_("value too great for base"));
val = (val * base) + c;
}
else
break;
}
+
return (val);
}
#if defined (EXPR_TEST)
-char *
+void *
xmalloc (n)
int n;
{
return (malloc (n));
}
-char *
+void *
xrealloc (s, n)
char *s;
int n;
char **argv;
{
register int i;
- long v;
+ intmax_t v;
int expok;
if (setjmp (top_level))
{
v = evalexp (argv[i], &expok);
if (expok == 0)
- fprintf (stderr, "%s: expression error\n", argv[i]);
+ fprintf (stderr, "%s: expression error\n", argv[i]);
else
- printf ("'%s' -> %ld\n", argv[i], v);
+ printf ("'%s' -> %ld\n", argv[i], v);
}
exit (0);
}
char *
itos (n)
- int n;
+ intmax_t n;
{
return ("42");
}