#include "libbb.h"
typedef enum BcStatus {
- BC_STATUS_SUCCESS,
- BC_STATUS_FAILURE,
+ BC_STATUS_SUCCESS = 0,
+ BC_STATUS_FAILURE = 1,
+ BC_STATUS_PARSE_EMPTY_EXP = 2, // bc_parse_expr() uses this
// BC_STATUS_ALLOC_ERR,
// BC_STATUS_INPUT_EOF,
// BC_STATUS_PATH_IS_DIR,
// BC_STATUS_LEX_BAD_CHAR,
- BC_STATUS_LEX_NO_STRING_END,
- BC_STATUS_LEX_NO_COMMENT_END,
- BC_STATUS_LEX_EOF,
+// BC_STATUS_LEX_NO_STRING_END,
+// BC_STATUS_LEX_NO_COMMENT_END,
+// BC_STATUS_LEX_EOF,
#if ENABLE_DC
- BC_STATUS_LEX_EXTENDED_REG,
+// BC_STATUS_LEX_EXTENDED_REG,
#endif
- BC_STATUS_PARSE_BAD_TOKEN,
- BC_STATUS_PARSE_BAD_EXP,
- BC_STATUS_PARSE_EMPTY_EXP,
- BC_STATUS_PARSE_BAD_PRINT,
- BC_STATUS_PARSE_BAD_FUNC,
- BC_STATUS_PARSE_BAD_ASSIGN,
+// BC_STATUS_PARSE_BAD_TOKEN,
+// BC_STATUS_PARSE_BAD_EXP,
+// BC_STATUS_PARSE_BAD_PRINT,
+// BC_STATUS_PARSE_BAD_FUNC,
+// BC_STATUS_PARSE_BAD_ASSIGN,
// BC_STATUS_PARSE_NO_AUTO,
- BC_STATUS_PARSE_DUPLICATE_LOCAL,
- BC_STATUS_PARSE_NO_BLOCK_END,
+// BC_STATUS_PARSE_DUPLICATE_LOCAL,
+// BC_STATUS_PARSE_NO_BLOCK_END,
- BC_STATUS_MATH_NEGATIVE,
- BC_STATUS_MATH_NON_INTEGER,
- BC_STATUS_MATH_OVERFLOW,
- BC_STATUS_MATH_DIVIDE_BY_ZERO,
- BC_STATUS_MATH_BAD_STRING,
+// BC_STATUS_MATH_NEGATIVE,
+// BC_STATUS_MATH_NON_INTEGER,
+// BC_STATUS_MATH_OVERFLOW,
+// BC_STATUS_MATH_DIVIDE_BY_ZERO,
+// BC_STATUS_MATH_BAD_STRING,
// BC_STATUS_EXEC_FILE_ERR,
// BC_STATUS_EXEC_MISMATCHED_PARAMS,
// BC_STATUS_EXEC_UNDEFINED_FUNC,
- BC_STATUS_EXEC_FILE_NOT_EXECUTABLE,
- BC_STATUS_EXEC_NUM_LEN,
- BC_STATUS_EXEC_NAME_LEN,
- BC_STATUS_EXEC_STRING_LEN,
- BC_STATUS_EXEC_ARRAY_LEN,
- BC_STATUS_EXEC_BAD_IBASE,
+// BC_STATUS_EXEC_FILE_NOT_EXECUTABLE,
+// BC_STATUS_EXEC_NUM_LEN,
+// BC_STATUS_EXEC_NAME_LEN,
+// BC_STATUS_EXEC_STRING_LEN,
+// BC_STATUS_EXEC_ARRAY_LEN,
+// BC_STATUS_EXEC_BAD_IBASE,
// BC_STATUS_EXEC_BAD_SCALE,
- BC_STATUS_EXEC_BAD_READ_EXPR,
- BC_STATUS_EXEC_REC_READ,
- BC_STATUS_EXEC_BAD_TYPE,
+// BC_STATUS_EXEC_BAD_READ_EXPR,
+// BC_STATUS_EXEC_REC_READ,
+// BC_STATUS_EXEC_BAD_TYPE,
// BC_STATUS_EXEC_BAD_OBASE,
// BC_STATUS_EXEC_SIGNAL,
- BC_STATUS_EXEC_STACK,
+// BC_STATUS_EXEC_STACK,
// BC_STATUS_VEC_OUT_OF_BOUNDS,
// BC_STATUS_VEC_ITEM_EXISTS,
- BC_STATUS_BEFORE_POSIX = BC_STATUS_EXEC_STACK,
+ BC_STATUS_BEFORE_POSIX = BC_STATUS_PARSE_EMPTY_EXP,
#if ENABLE_BC
BC_STATUS_POSIX_NAME_LEN,
BC_STATUS_POSIX_COMMENT,
static const char *const bc_err_msgs[] = {
NULL,
NULL,
+ NULL,
+
// "memory allocation error",
// "I/O error",
// "file is not text:",
// "path is a directory:",
// "bad character",
- "string end could not be found",
- "comment end could not be found",
- "end of file",
+// "string end could not be found",
+// "comment end could not be found",
+// "end of file",
#if ENABLE_DC
- "extended register",
+// "extended register",
#endif
- "bad token",
- "bad expression",
- "empty expression",
- "bad print statement",
- "bad function definition",
- "bad assignment: left side must be scale, ibase, "
- "obase, last, var, or array element",
+// "bad token",
+// "bad expression",
+// "bad print statement",
+// "bad function definition",
+// "bad assignment: left side must be scale, ibase, "
+// "obase, last, var, or array element",
// "no auto variable found",
- "function parameter or auto var has the same name as another",
- "block end could not be found",
+// "function parameter or auto var has the same name as another",
+// "block end could not be found",
- "negative number",
- "non integer number",
- "overflow",
- "divide by zero",
- "bad number string",
+// "negative number",
+// "non integer number",
+// "overflow",
+// "divide by zero",
+// "bad number string",
// "could not open file:",
// "mismatched parameters", // wrong number of them, to be exact
// "undefined function",
- "file is not executable:",
- "number too long: must be [1, BC_NUM_MAX]",
- "name too long: must be [1, BC_NAME_MAX]",
- "string too long: must be [1, BC_STRING_MAX]",
- "array too long; must be [1, BC_DIM_MAX]",
- "bad ibase; must be [2, 16]",
+// "file is not executable:",
+// "number too long: must be [1, BC_NUM_MAX]",
+// "name too long: must be [1, BC_NAME_MAX]",
+// "string too long: must be [1, BC_STRING_MAX]",
+// "array too long; must be [1, BC_DIM_MAX]",
+// "bad ibase; must be [2, 16]",
// "bad scale; must be [0, BC_SCALE_MAX]",
- "bad read() expression",
- "read() call inside of a read() call",
- "variable is wrong type",
+// "bad read() expression",
+// "read() call inside of a read() call",
+// "variable is wrong type",
// "bad obase; must be [2, BC_BASE_MAX]",
// "signal caught and not handled",
- "stack has too few elements",
+// "stack has too few elements",
// "index is out of bounds",
// "item already exists",
static BcStatus bc_num_shift(BcNum *n, size_t places)
{
if (places == 0 || n->len == 0) return BC_STATUS_SUCCESS;
- if (places + n->len > BC_MAX_NUM) return BC_STATUS_EXEC_NUM_LEN;
+ if (places + n->len > BC_MAX_NUM)
+ return bc_error("number too long: must be [1, BC_NUM_MAX]");
if (n->rdx >= places)
n->rdx -= places;
bool zero = true;
if (b->len == 0)
- return BC_STATUS_MATH_DIVIDE_BY_ZERO;
+ return bc_error("divide by zero");
else if (a->len == 0) {
bc_num_setToZero(c, scale);
return BC_STATUS_SUCCESS;
BcNum temp;
bool neg;
- if (b->len == 0) return BC_STATUS_MATH_DIVIDE_BY_ZERO;
+ if (b->len == 0)
+ return bc_error("divide by zero");
if (a->len == 0) {
bc_num_setToZero(d, ts);
size_t i, powrdx, resrdx;
bool neg, zero;
- if (b->rdx) return BC_STATUS_MATH_NON_INTEGER;
+ if (b->rdx) return bc_error("non integer number");
if (b->len == 0) {
bc_num_one(c);
static BcStatus bc_num_parse(BcNum *n, const char *val, BcNum *base,
size_t base_t)
{
- if (!bc_num_strValid(val, base_t)) return BC_STATUS_MATH_BAD_STRING;
+ if (!bc_num_strValid(val, base_t))
+ return bc_error("bad number string");
if (base_t == 10)
bc_num_parseDecimal(n, val);
size_t i;
unsigned long pow;
- if (n->neg) return BC_STATUS_MATH_NEGATIVE;
+ if (n->neg) return bc_error("negative number");
for (*result = 0, pow = 1, i = n->rdx; i < n->len; ++i) {
*result += ((unsigned long) n->num[i]) * pow;
pow *= 10;
- if (*result < prev || pow < powprev) return BC_STATUS_MATH_OVERFLOW;
+ if (*result < prev || pow < powprev)
+ return bc_error("overflow");
}
return BC_STATUS_SUCCESS;
return BC_STATUS_SUCCESS;
}
else if (a->neg)
- return BC_STATUS_MATH_NEGATIVE;
+ return bc_error("negative number");
else if (BC_NUM_ONE(a)) {
bc_num_one(b);
bc_num_extend(b, scale);
BcStatus s;
BcNum base, exp, two, temp;
- if (c->len == 0) return BC_STATUS_MATH_DIVIDE_BY_ZERO;
- if (a->rdx || b->rdx || c->rdx) return BC_STATUS_MATH_NON_INTEGER;
- if (b->neg) return BC_STATUS_MATH_NEGATIVE;
+ if (c->len == 0)
+ return bc_error("divide by zero");
+ if (a->rdx || b->rdx || c->rdx)
+ return bc_error("non integer number");
+ if (b->neg)
+ return bc_error("negative number");
bc_num_expand(d, c->len);
bc_num_init(&base, c->len);
size_t i;
for (i = 0; i < f->autos.len; ++i) {
- if (!strcmp(name, ((BcId *) bc_vec_item(&f->autos, i))->name))
- return BC_STATUS_PARSE_DUPLICATE_LOCAL;
+ if (strcmp(name, ((BcId *) bc_vec_item(&f->autos, i))->name) == 0)
+ return bc_error("function parameter or auto var has the same name as another");
}
a.idx = var;
}
len = i + 1 * !last_pt - bslashes * 2;
- if (len > BC_MAX_NUM) return BC_STATUS_EXEC_NUM_LEN;
+ if (len > BC_MAX_NUM)
+ return bc_error("number too long: must be [1, BC_NUM_MAX]");
bc_vec_npop(&l->t.v, l->t.v.len);
bc_vec_expand(&l->t.v, len + 1);
while ((c >= 'a' && c <= 'z') || isdigit(c) || c == '_') c = buf[++i];
- if (i > BC_MAX_STRING) return BC_STATUS_EXEC_NAME_LEN;
+ if (i > BC_MAX_STRING)
+ return bc_error("name too long: must be [1, BC_NAME_MAX]");
bc_vec_string(&l->t.v, i, buf);
// Increment the index. We minus 1 because it has already been incremented.
BcStatus s;
l->t.last = l->t.t;
- if (l->t.last == BC_LEX_EOF) return BC_STATUS_LEX_EOF;
+ if (l->t.last == BC_LEX_EOF) return bc_error("end of file");
l->line += l->newline;
l->t.t = BC_LEX_EOF;
if (c == '\0') {
l->i = i;
- return BC_STATUS_LEX_NO_STRING_END;
+ return bc_error("string end could not be found");
}
len = i - l->i;
- if (len > BC_MAX_STRING) return BC_STATUS_EXEC_STRING_LEN;
+ if (len > BC_MAX_STRING)
+ return bc_error("string too long: must be [1, BC_STRING_MAX]");
bc_vec_string(&l->t.v, len, l->buf + l->i);
l->i = i + 1;
}
if (c == '\0') {
l->i = i;
- return BC_STATUS_LEX_NO_COMMENT_END;
+ return bc_error("comment end could not be found");
}
nls += (c == '\n');
i++;
bc_lex_whitespace(l);
++l->i;
if (!G_exreg)
- s = BC_STATUS_LEX_EXTENDED_REG;
+ s = bc_error("extended register");
else
s = bc_lex_name(l);
}
if (c == '\0') {
l->i = i;
- return BC_STATUS_LEX_NO_STRING_END;
+ return bc_error("string end could not be found");
}
bc_vec_pushByte(&l->t.v, '\0');
- if (i - l->i > BC_MAX_STRING) return BC_STATUS_EXEC_STRING_LEN;
+ if (i - l->i > BC_MAX_STRING)
+ return bc_error("string too long: must be [1, BC_STRING_MAX]");
l->i = i;
l->line += nls;
p->func = bc_vec_item(&G.prog.fns, p->fidx);
- if (!strcmp(text, "") && !BC_PARSE_CAN_EXEC(p)) {
+ if (!text[0] && !BC_PARSE_CAN_EXEC(p)) {
p->l.t.t = BC_LEX_INVALID;
s = p->parse(p);
if (s) return s;
- if (!BC_PARSE_CAN_EXEC(p)) return BC_STATUS_EXEC_FILE_NOT_EXECUTABLE;
+ if (!BC_PARSE_CAN_EXEC(p))
+ return bc_error("file is not executable");
}
return bc_lex_text(&p->l, text);
{
BcLexType top;
- if (p->ops.len <= ops_bgn) return BC_STATUS_PARSE_BAD_EXP;
+ if (p->ops.len <= ops_bgn)
+ return bc_error("bad expression");
top = BC_PARSE_TOP_OP(p);
while (top != BC_LEX_LPAREN) {
bc_vec_pop(&p->ops);
*nexs -= top != BC_LEX_OP_BOOL_NOT && top != BC_LEX_NEG;
- if (p->ops.len <= ops_bgn) return BC_STATUS_PARSE_BAD_EXP;
+ if (p->ops.len <= ops_bgn)
+ return bc_error("bad expression");
top = BC_PARSE_TOP_OP(p);
}
}
}
- if (comma) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (comma) return bc_error("bad token");
bc_parse_push(p, BC_INST_CALL);
bc_parse_pushIndex(p, nparams);
if (s) goto err;
if (p->l.t.t != BC_LEX_RPAREN) {
- s = BC_STATUS_PARSE_BAD_TOKEN;
+ s = bc_error("bad token");
goto err;
}
if (p->l.t.t == BC_LEX_RBRACKET) {
if (!(flags & BC_PARSE_ARRAY)) {
- s = BC_STATUS_PARSE_BAD_EXP;
+ s = bc_error("bad expression");
goto err;
}
else if (p->l.t.t == BC_LEX_LPAREN) {
if (flags & BC_PARSE_NOCALL) {
- s = BC_STATUS_PARSE_BAD_TOKEN;
+ s = bc_error("bad token");
goto err;
}
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_LPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_LPAREN) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_RPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_RPAREN) return bc_error("bad token");
bc_parse_push(p, BC_INST_READ);
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_LPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_LPAREN) return bc_error("bad token");
flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
s = bc_parse_expr(p, flags, bc_parse_next_rel);
if (s) return s;
- if (p->l.t.t != BC_LEX_RPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_RPAREN) return bc_error("bad token");
*prev = (type == BC_LEX_KEY_LENGTH) ? BC_INST_LENGTH : BC_INST_SQRT;
bc_parse_push(p, *prev);
s = bc_parse_expr(p, flags, bc_parse_next_rel);
if (s) return s;
- if (p->l.t.t != BC_LEX_RPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_RPAREN) return bc_error("bad token");
bc_parse_push(p, BC_INST_SCALE_FUNC);
return bc_lex_next(&p->l);
s = bc_lex_next(&p->l);
if (s) return s;
if (p->l.t.t == BC_LEX_LPAREN)
- s = BC_STATUS_PARSE_BAD_TOKEN;
+ s = bc_error("bad token");
else
bc_parse_push(p, BC_INST_SCALE);
break;
default:
{
- s = BC_STATUS_PARSE_BAD_TOKEN;
+ s = bc_error("bad token");
break;
}
}
type = p->l.t.t;
if (type == BC_LEX_SCOLON || type == BC_LEX_NLINE)
- return BC_STATUS_PARSE_BAD_PRINT;
+ return bc_error("bad print statement");
while (!s && type != BC_LEX_SCOLON && type != BC_LEX_NLINE) {
}
if (s) return s;
- if (comma) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (comma) return bc_error("bad token");
return bc_lex_next(&p->l);
}
BcLexType t;
bool paren;
- if (!BC_PARSE_FUNC(p)) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!BC_PARSE_FUNC(p)) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
s = bc_parse_expr(p, 0, bc_parse_next_expr);
if (s && s != BC_STATUS_PARSE_EMPTY_EXP)
return s;
- else if (s == BC_STATUS_PARSE_EMPTY_EXP) {
+
+ if (s == BC_STATUS_PARSE_EMPTY_EXP) {
bc_parse_push(p, BC_INST_RET0);
s = bc_lex_next(&p->l);
if (s) return s;
BcStatus s = BC_STATUS_SUCCESS;
if (p->flags.len <= 1 || (brace && p->nbraces == 0))
- return BC_STATUS_PARSE_BAD_TOKEN;
+ return bc_error("bad token");
if (brace) {
if (p->l.t.t == BC_LEX_RBRACE) {
- if (!p->nbraces) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!p->nbraces) return bc_error("bad token");
--p->nbraces;
s = bc_lex_next(&p->l);
if (s) return s;
}
else
- return BC_STATUS_PARSE_BAD_TOKEN;
+ return bc_error("bad token");
}
if (BC_PARSE_IF(p)) {
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_LPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_LPAREN) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
s = bc_parse_expr(p, BC_PARSE_REL, bc_parse_next_rel);
if (s) return s;
- if (p->l.t.t != BC_LEX_RPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_RPAREN) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
{
BcInstPtr ip;
- if (!BC_PARSE_IF_END(p)) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!BC_PARSE_IF_END(p)) return bc_error("bad token");
ip.idx = p->func->labels.len;
ip.func = ip.len = 0;
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_LPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_LPAREN) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
s = bc_parse_expr(p, BC_PARSE_REL, bc_parse_next_rel);
if (s) return s;
- if (p->l.t.t != BC_LEX_RPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_RPAREN) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_LPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_LPAREN) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
s = bc_vm_posixError(BC_STATUS_POSIX_FOR1, p->l.f, p->l.line, NULL);
if (s) return s;
- if (p->l.t.t != BC_LEX_SCOLON) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_SCOLON) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
s = bc_vm_posixError(BC_STATUS_POSIX_FOR2, p->l.f, p->l.line, NULL);
if (s) return s;
- if (p->l.t.t != BC_LEX_SCOLON) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_SCOLON) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
if (s) return s;
- if (p->l.t.t != BC_LEX_RPAREN) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_RPAREN) return bc_error("bad token");
bc_parse_push(p, BC_INST_JUMP);
bc_parse_pushIndex(p, cond_idx);
bc_vec_push(&p->func->labels, &p->func->code.len);
size_t i;
BcInstPtr *ip;
- if (!BC_PARSE_LOOP(p)) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!BC_PARSE_LOOP(p)) return bc_error("bad token");
if (type == BC_LEX_KEY_BREAK) {
- if (p->exits.len == 0) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->exits.len == 0) return bc_error("bad token");
i = p->exits.len - 1;
ip = bc_vec_item(&p->exits, i);
while (!ip->func && i < p->exits.len) ip = bc_vec_item(&p->exits, i--);
- if (i >= p->exits.len && !ip->func) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (i >= p->exits.len && !ip->func) return bc_error("bad token");
i = ip->idx;
}
if (s) return s;
if (p->l.t.t != BC_LEX_SCOLON && p->l.t.t != BC_LEX_NLINE)
- return BC_STATUS_PARSE_BAD_TOKEN;
+ return bc_error("bad token");
return bc_lex_next(&p->l);
}
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_NAME) return BC_STATUS_PARSE_BAD_FUNC;
+ if (p->l.t.t != BC_LEX_NAME)
+ return bc_error("bad function definition");
name = xstrdup(p->l.t.v.v);
bc_parse_addFunc(p, name, &p->fidx);
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_LPAREN) return BC_STATUS_PARSE_BAD_FUNC;
+ if (p->l.t.t != BC_LEX_LPAREN)
+ return bc_error("bad function definition");
s = bc_lex_next(&p->l);
if (s) return s;
while (p->l.t.t != BC_LEX_RPAREN) {
- if (p->l.t.t != BC_LEX_NAME) return BC_STATUS_PARSE_BAD_FUNC;
+ if (p->l.t.t != BC_LEX_NAME)
+ return bc_error("bad function definition");
++p->func->nparams;
if (s) goto err;
if (p->l.t.t != BC_LEX_RBRACKET) {
- s = BC_STATUS_PARSE_BAD_FUNC;
+ s = bc_error("bad function definition");
goto err;
}
if (s) goto err;
}
- if (comma) return BC_STATUS_PARSE_BAD_FUNC;
+ if (comma) return bc_error("bad function definition");
flags = BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_FUNC_INNER | BC_PARSE_FLAG_BODY;
bc_parse_startBody(p, flags);
bool comma, var, one;
char *name;
- if (!p->auto_part) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!p->auto_part) return bc_error("bad token");
s = bc_lex_next(&p->l);
if (s) return s;
if (s) goto err;
if (p->l.t.t != BC_LEX_RBRACKET) {
- s = BC_STATUS_PARSE_BAD_FUNC;
+ s = bc_error("bad function definition");
goto err;
}
if (s) goto err;
}
- if (comma) return BC_STATUS_PARSE_BAD_FUNC;
+ if (comma) return bc_error("bad function definition");
if (!one) return bc_error("no auto variable found");
if (p->l.t.t != BC_LEX_NLINE && p->l.t.t != BC_LEX_SCOLON)
- return BC_STATUS_PARSE_BAD_TOKEN;
+ return bc_error("bad token");
return bc_lex_next(&p->l);
if (*flag_ptr & BC_PARSE_FLAG_FUNC_INNER) {
- if (!brace) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!brace) return bc_error("bad token");
p->auto_part = p->l.t.t != BC_LEX_KEY_AUTO;
if (!p->auto_part) {
case BC_LEX_LBRACE:
{
- if (!BC_PARSE_BODY(p)) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!BC_PARSE_BODY(p)) return bc_error("bad token");
++p->nbraces;
s = bc_lex_next(&p->l);
default:
{
- s = BC_STATUS_PARSE_BAD_TOKEN;
+ s = bc_error("bad token");
break;
}
}
BcStatus s;
if (p->l.t.t == BC_LEX_EOF)
- s = p->flags.len > 0 ? BC_STATUS_PARSE_NO_BLOCK_END : BC_STATUS_LEX_EOF;
+ s = p->flags.len > 0 ? bc_error("block end could not be found") : bc_error("end of file");
else if (p->l.t.t == BC_LEX_KEY_DEFINE) {
- if (!BC_PARSE_CAN_EXEC(p)) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (!BC_PARSE_CAN_EXEC(p)) return bc_error("bad token");
s = bc_parse_func(p);
}
else
prev != BC_INST_SCALE && prev != BC_INST_IBASE &&
prev != BC_INST_OBASE && prev != BC_INST_LAST)
{
- s = BC_STATUS_PARSE_BAD_ASSIGN;
+ s = bc_error("bad assignment:"
+ " left side must be scale,"
+ " ibase, obase, last, var,"
+ " or array element"
+ );
break;
}
}
case BC_LEX_OP_BOOL_OR:
case BC_LEX_OP_BOOL_AND:
{
- if (((t == BC_LEX_OP_BOOL_NOT) != bin_last) ||
- (t != BC_LEX_OP_BOOL_NOT && prev == BC_INST_BOOL_NOT))
- {
- return BC_STATUS_PARSE_BAD_EXP;
+ if (((t == BC_LEX_OP_BOOL_NOT) != bin_last)
+ || (t != BC_LEX_OP_BOOL_NOT && prev == BC_INST_BOOL_NOT)
+ ) {
+ return bc_error("bad expression");
}
nrelops += t >= BC_LEX_OP_REL_EQ && t <= BC_LEX_OP_REL_GT;
case BC_LEX_LPAREN:
{
- if (BC_PARSE_LEAF(prev, rprn)) return BC_STATUS_PARSE_BAD_EXP;
-
+ if (BC_PARSE_LEAF(prev, rprn))
+ return bc_error("bad expression");
++nparens;
paren_expr = rprn = bin_last = false;
get_token = true;
case BC_LEX_RPAREN:
{
if (bin_last || prev == BC_INST_BOOL_NOT)
- return BC_STATUS_PARSE_BAD_EXP;
+ return bc_error("bad expression");
if (nparens == 0) {
s = BC_STATUS_SUCCESS;
case BC_LEX_NAME:
{
- if (BC_PARSE_LEAF(prev, rprn)) return BC_STATUS_PARSE_BAD_EXP;
-
+ if (BC_PARSE_LEAF(prev, rprn))
+ return bc_error("bad expression");
paren_expr = true;
rprn = get_token = bin_last = false;
s = bc_parse_name(p, &prev, flags & ~BC_PARSE_NOCALL);
case BC_LEX_NUMBER:
{
- if (BC_PARSE_LEAF(prev, rprn)) return BC_STATUS_PARSE_BAD_EXP;
-
+ if (BC_PARSE_LEAF(prev, rprn))
+ return bc_error("bad expression");
bc_parse_number(p, &prev, &nexprs);
paren_expr = get_token = true;
rprn = bin_last = false;
case BC_LEX_KEY_LAST:
case BC_LEX_KEY_OBASE:
{
- if (BC_PARSE_LEAF(prev, rprn)) return BC_STATUS_PARSE_BAD_EXP;
-
+ if (BC_PARSE_LEAF(prev, rprn))
+ return bc_error("bad expression");
prev = (char) (t - BC_LEX_KEY_IBASE + BC_INST_IBASE);
bc_parse_push(p, (char) prev);
case BC_LEX_KEY_LENGTH:
case BC_LEX_KEY_SQRT:
{
- if (BC_PARSE_LEAF(prev, rprn)) return BC_STATUS_PARSE_BAD_EXP;
-
+ if (BC_PARSE_LEAF(prev, rprn))
+ return bc_error("bad expression");
s = bc_parse_builtin(p, t, flags, &prev);
paren_expr = true;
rprn = get_token = bin_last = false;
case BC_LEX_KEY_READ:
{
if (BC_PARSE_LEAF(prev, rprn))
- return BC_STATUS_PARSE_BAD_EXP;
+ return bc_error("bad expression");
else if (flags & BC_PARSE_NOREAD)
- s = BC_STATUS_EXEC_REC_READ;
+ s = bc_error("read() call inside of a read() call");
else
s = bc_parse_read(p);
case BC_LEX_KEY_SCALE:
{
- if (BC_PARSE_LEAF(prev, rprn)) return BC_STATUS_PARSE_BAD_EXP;
-
+ if (BC_PARSE_LEAF(prev, rprn))
+ return bc_error("bad expression");
s = bc_parse_scale(p, &prev, flags);
paren_expr = true;
rprn = get_token = bin_last = false;
default:
{
- s = BC_STATUS_PARSE_BAD_TOKEN;
+ s = bc_error("bad token");
break;
}
}
assign = top >= BC_LEX_OP_ASSIGN_POWER && top <= BC_LEX_OP_ASSIGN;
if (top == BC_LEX_LPAREN || top == BC_LEX_RPAREN)
- return BC_STATUS_PARSE_BAD_EXP;
+ return bc_error("bad expression");
bc_parse_push(p, BC_PARSE_TOKEN_INST(top));
bc_vec_pop(&p->ops);
}
- s = BC_STATUS_PARSE_BAD_EXP;
- if (prev == BC_INST_BOOL_NOT || nexprs != 1) return s;
+ if (prev == BC_INST_BOOL_NOT || nexprs != 1)
+ return bc_error("bad expression");
- for (i = 0; s && i < next.len; ++i) s *= t != next.tokens[i];
- if (s) return s;
+ for (i = 0; i < next.len; ++i)
+ if (t == next.tokens[i])
+ goto ok;
+ return bc_error("bad expression");
+ ok:
if (!(flags & BC_PARSE_REL) && nrelops) {
s = bc_vm_posixError(BC_STATUS_POSIX_REL_POS, p->l.f, p->l.line, NULL);
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_NAME) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_NAME) return bc_error("bad token");
name = xstrdup(p->l.t.v.v);
bc_parse_pushName(p, name);
if (t == BC_LEX_NEG) {
s = bc_lex_next(&p->l);
if (s) return s;
- if (p->l.t.t != BC_LEX_NUMBER) return BC_STATUS_PARSE_BAD_TOKEN;
+ if (p->l.t.t != BC_LEX_NUMBER)
+ return bc_error("bad token");
}
bc_parse_number(p, &prev, &p->nbraces);
case BC_LEX_KEY_READ:
{
if (flags & BC_PARSE_NOREAD)
- s = BC_STATUS_EXEC_REC_READ;
+ s = bc_error("read() call inside of a read() call");
else
bc_parse_push(p, BC_INST_READ);
get_token = true;
default:
{
- s = BC_STATUS_PARSE_BAD_TOKEN;
+ s = bc_error("bad token");
get_token = true;
break;
}
BcStatus s;
if (p->l.t.t == BC_LEX_EOF)
- s = BC_STATUS_LEX_EOF;
+ s = bc_error("end of file");
else
s = dc_parse_expr(p, 0);
bool hex;
BcResultType lt, rt;
- if (!BC_PROG_STACK(&G.prog.results, 2)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 2))
+ return bc_error("stack has too few elements");
*r = bc_vec_item_rev(&G.prog.results, 0);
*l = bc_vec_item_rev(&G.prog.results, 1);
}
if (!BC_PROG_NUM((*l), (*ln)) && (!assign || (*l)->t != BC_RESULT_VAR))
- return BC_STATUS_EXEC_BAD_TYPE;
- if (!assign && !BC_PROG_NUM((*r), (*ln))) return BC_STATUS_EXEC_BAD_TYPE;
+ return bc_error("variable is wrong type");
+ if (!assign && !BC_PROG_NUM((*r), (*ln)))
+ return bc_error("variable is wrong type");
return s;
}
{
BcStatus s;
- if (!BC_PROG_STACK(&G.prog.results, 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 1))
+ return bc_error("stack has too few elements");
*r = bc_vec_top(&G.prog.results);
s = bc_program_num(*r, n, false);
if (s) return s;
- if (!BC_PROG_NUM((*r), (*n))) return BC_STATUS_EXEC_BAD_TYPE;
+ if (!BC_PROG_NUM((*r), (*n)))
+ return bc_error("variable is wrong type");
return s;
}
for (i = 0; i < G.prog.stack.len; ++i) {
BcInstPtr *ip_ptr = bc_vec_item(&G.prog.stack, i);
- if (ip_ptr->func == BC_PROG_READ) return BC_STATUS_EXEC_REC_READ;
+ if (ip_ptr->func == BC_PROG_READ)
+ return bc_error("read() call inside of a read() call");
}
bc_vec_npop(&f->code, f->code.len);
if (s) goto exec_err;
if (parse.l.t.t != BC_LEX_NLINE && parse.l.t.t != BC_LEX_EOF) {
- s = BC_STATUS_EXEC_BAD_READ_EXPR;
+ s = bc_error("bad read() expression");
goto exec_err;
}
BcNum *num = NULL;
bool pop = inst != BC_INST_PRINT;
- if (!BC_PROG_STACK(&G.prog.results, idx + 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, idx + 1))
+ return bc_error("stack has too few elements");
r = bc_vec_item_rev(&G.prog.results, idx);
s = bc_program_num(r, &num, false);
res.t = BC_RESULT_STR;
if (!push) {
- if (!BC_PROG_STACK(&G.prog.results, 2)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 2))
+ return bc_error("stack has too few elements");
bc_vec_pop(v);
bc_vec_pop(&G.prog.results);
}
BcVec *v;
BcNum *n;
- if (!BC_PROG_STACK(&G.prog.results, 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 1))
+ return bc_error("stack has too few elements");
ptr = bc_vec_top(&G.prog.results);
- if ((ptr->t == BC_RESULT_ARRAY) != !var) return BC_STATUS_EXEC_BAD_TYPE;
+ if ((ptr->t == BC_RESULT_ARRAY) != !var)
+ return bc_error("variable is wrong type");
v = bc_program_search(name, var);
#if ENABLE_DC
- if (ptr->t == BC_RESULT_STR && !var) return BC_STATUS_EXEC_BAD_TYPE;
+ if (ptr->t == BC_RESULT_STR && !var)
+ return bc_error("variable is wrong type");
if (ptr->t == BC_RESULT_STR) return bc_program_assignStr(ptr, v, true);
#endif
BcVec *v;
- if (left->t != BC_RESULT_VAR) return BC_STATUS_EXEC_BAD_TYPE;
+ if (left->t != BC_RESULT_VAR)
+ return bc_error("variable is wrong type");
v = bc_program_search(left->d.id.name, true);
return bc_program_assignStr(right, v, false);
#endif
if (left->t == BC_RESULT_CONSTANT || left->t == BC_RESULT_TEMP)
- return BC_STATUS_PARSE_BAD_ASSIGN;
+ return bc_error("bad assignment:"
+ " left side must be scale,"
+ " ibase, obase, last, var,"
+ " or array element"
+ );
#if ENABLE_BC
if (inst == BC_INST_ASSIGN_DIVIDE && !bc_num_cmp(r, &G.prog.zero))
- return BC_STATUS_MATH_DIVIDE_BY_ZERO;
+ return bc_error("divide by zero");
if (assign)
bc_num_copy(l, r);
#endif
if (ib || sc || left->t == BC_RESULT_OBASE) {
-
+ static const char *const msg[] = {
+ "bad ibase; must be [2, 16]", //BC_RESULT_IBASE
+ "bad scale; must be [0, BC_SCALE_MAX]", //BC_RESULT_SCALE
+ "?1", //BC_RESULT_LAST
+ "?2", //BC_RESULT_CONSTANT
+ "?3", //BC_RESULT_ONE
+ "bad obase; must be [2, BC_BASE_MAX]", //BC_RESULT_OBASE
+ };
size_t *ptr;
s = bc_num_ulong(l, &val);
- if (s) return s;
- s = left->t - BC_RESULT_IBASE + BC_STATUS_EXEC_BAD_IBASE;
-
+ if (s)
+ return s;
+ s = left->t - BC_RESULT_IBASE;
if (sc) {
max = BC_MAX_SCALE;
ptr = &G.prog.scale;
}
else {
- if (val < BC_NUM_MIN_BASE) return s;
+ if (val < BC_NUM_MIN_BASE)
+ return bc_error(msg[s]);
max = ib ? BC_NUM_MAX_IBASE : BC_MAX_OBASE;
ptr = ib ? &G.prog.ib_t : &G.prog.ob_t;
}
- if (val > max) return s;
- if (!sc) bc_num_copy(ib ? &G.prog.ib : &G.prog.ob, l);
+ if (val > max)
+ return bc_error(msg[s]);
+ if (!sc)
+ bc_num_copy(ib ? &G.prog.ib : &G.prog.ob, l);
*ptr = (size_t) val;
s = BC_STATUS_SUCCESS;
if (!BC_PROG_STACK(v, 2 - copy)) {
free(name);
- return BC_STATUS_EXEC_STACK;
+ return bc_error("stack has too few elements");
}
free(name);
if (s) goto err;
if (temp > BC_MAX_DIM) {
- s = BC_STATUS_EXEC_ARRAY_LEN;
+ s = bc_error("array too long; must be [1, BC_DIM_MAX]");
goto err;
}
arg = bc_vec_top(&G.prog.results);
if ((!a->idx) != (arg->t == BC_RESULT_ARRAY) || arg->t == BC_RESULT_STR)
- return BC_STATUS_EXEC_BAD_TYPE;
+ return bc_error("variable is wrong type");
s = bc_program_copyToVar(a->name, a->idx);
if (s) return s;
BcInstPtr *ip = bc_vec_top(&G.prog.stack);
if (!BC_PROG_STACK(&G.prog.results, ip->len + inst == BC_INST_RET))
- return BC_STATUS_EXEC_STACK;
+ return bc_error("stack has too few elements");
f = bc_vec_item(&G.prog.fns, ip->func);
res.t = BC_RESULT_TEMP;
BcResult res;
bool len = inst == BC_INST_LENGTH;
- if (!BC_PROG_STACK(&G.prog.results, 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 1))
+ return bc_error("stack has too few elements");
opnd = bc_vec_top(&G.prog.results);
s = bc_program_num(opnd, &num, false);
if (s) return s;
#if ENABLE_DC
- if (!BC_PROG_NUM(opnd, num) && !len) return BC_STATUS_EXEC_BAD_TYPE;
+ if (!BC_PROG_NUM(opnd, num) && !len)
+ return bc_error("variable is wrong type");
#endif
bc_num_init(&res.d.n, BC_NUM_DEF_SIZE);
BcResult *r1, *r2, *r3, res;
BcNum *n1, *n2, *n3;
- if (!BC_PROG_STACK(&G.prog.results, 3)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 3))
+ return bc_error("stack has too few elements");
s = bc_program_binOpPrep(&r2, &n2, &r3, &n3, false);
if (s) return s;
r1 = bc_vec_item_rev(&G.prog.results, 2);
s = bc_program_num(r1, &n1, false);
if (s) return s;
- if (!BC_PROG_NUM(r1, n1)) return BC_STATUS_EXEC_BAD_TYPE;
+ if (!BC_PROG_NUM(r1, n1))
+ return bc_error("variable is wrong type");
// Make sure that the values have their pointers updated, if necessary.
if (r1->t == BC_RESULT_VAR || r1->t == BC_RESULT_ARRAY_ELEM) {
size_t len = G.prog.strs.len, idx;
unsigned long val;
- if (!BC_PROG_STACK(&G.prog.results, 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 1))
+ return bc_error("stack has too few elements");
r = bc_vec_top(&G.prog.results);
s = bc_program_num(r, &num, false);
size_t idx;
char *str;
- if (!BC_PROG_STACK(&G.prog.results, 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 1))
+ return bc_error("stack has too few elements");
r = bc_vec_top(&G.prog.results);
s = bc_program_num(r, &n, false);
bc_vec_pop(&G.prog.results);
if (G.prog.stack.len < val)
- return BC_STATUS_EXEC_STACK;
+ return bc_error("stack has too few elements");
if (G.prog.stack.len == val)
quit();
BcNum *n;
bool exec;
- if (!BC_PROG_STACK(&G.prog.results, 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 1))
+ return bc_error("stack has too few elements");
r = bc_vec_top(&G.prog.results);
if (!exec) goto exit;
if (!BC_PROG_STR(n)) {
- s = BC_STATUS_EXEC_BAD_TYPE;
+ s = bc_error("variable is wrong type");
goto exit;
}
if (s) goto err;
if (prs.l.t.t != BC_LEX_EOF) {
- s = BC_STATUS_PARSE_BAD_EXP;
+ s = bc_error("bad expression");
goto err;
}
case BC_INST_POP:
{
if (!BC_PROG_STACK(&G.prog.results, 1))
- s = BC_STATUS_EXEC_STACK;
+ s = bc_error("stack has too few elements");
else
bc_vec_pop(&G.prog.results);
break;
case BC_INST_DUPLICATE:
{
- if (!BC_PROG_STACK(&G.prog.results, 1)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 1))
+ return bc_error("stack has too few elements");
ptr = bc_vec_top(&G.prog.results);
bc_result_copy(&r, ptr);
bc_vec_push(&G.prog.results, &r);
{
BcResult *ptr2;
- if (!BC_PROG_STACK(&G.prog.results, 2)) return BC_STATUS_EXEC_STACK;
+ if (!BC_PROG_STACK(&G.prog.results, 2))
+ return bc_error("stack has too few elements");
ptr = bc_vec_item_rev(&G.prog.results, 0);
ptr2 = bc_vec_item_rev(&G.prog.results, 1);
fprintf(stderr, bc_err_line + 4 * !line, line);
}
+///
return s * (!G.ttyin || !!strcmp(file, bc_program_stdin_name));
}
main_func = bc_vec_item(&G.prog.fns, BC_PROG_MAIN);
ip = bc_vec_item(&G.prog.stack, 0);
- if (main_func->code.len < ip->idx) s = BC_STATUS_EXEC_FILE_NOT_EXECUTABLE;
+ if (main_func->code.len < ip->idx)
+ s = bc_error("file '%s' is not executable", file);
err:
free(data);
bc_vec_npop(&buffer, buffer.len);
}
- if (str)
- s = bc_vm_error(BC_STATUS_LEX_NO_STRING_END, G.prs.l.f,
+ if (str) {
+ bc_error("string end could not be found");
+ s = bc_vm_error(BC_STATUS_FAILURE, G.prs.l.f,
G.prs.l.line);
- else if (comment)
- s = bc_vm_error(BC_STATUS_LEX_NO_COMMENT_END, G.prs.l.f,
+ }
+ else if (comment) {
+ bc_error("comment end could not be found");
+ s = bc_vm_error(BC_STATUS_FAILURE, G.prs.l.f,
G.prs.l.line);
+ }
err:
bc_vec_free(&buf);
projects / oweals / busybox.git / commitdiff