bc: convert all non-POSIX BC_STATUS_foo codes

function                                             old     new   delta
bc_program_asciify                                     -     469    +469
bc_parse_parse                                       432     495     +63
dc_parse_expr                                        727     775     +48
bc_vm_run                                           1955    1995     +40
bc_program_num                                      1115    1147     +32
bc_program_binOpPrep                                 296     324     +28
static.msg                                             -      24     +24
bc_parse_name                                        570     593     +23
bc_lex_token                                        1344    1367     +23
dc_lex_token                                         695     714     +19
bc_num_ulong                                          85     103     +18
bc_program_read                                      336     353     +17
dc_parse_parse                                        47      60     +13
bc_parse_stmt                                       2301    2313     +12
bc_parse_auto                                        291     302     +11
bc_program_prep                                       89      99     +10
bc_lex_next                                           71      81     +10
dc_parse_register                                     52      61      +9
bc_program_print                                     775     784      +9
bc_func_insert                                        89      98      +9
bc_program_assignStr                                 159     167      +8
bc_program_assign                                    476     484      +8
bc_parse_body                                        116     124      +8
bc_lex_name                                           83      91      +8
bc_program_pushVar                                   215     221      +6
bc_parse_text                                        141     147      +6
bc_num_shift                                          68      74      +6
bc_num_p                                             472     478      +6
bc_program_execStr                                   559     564      +5
bc_parse_else                                        139     143      +4
bc_lex_number                                        301     305      +4
bc_num_d                                             558     561      +3
bc_parse_endBody                                     422     424      +2
bc_num_r                                             231     230      -1
bc_program_copyToVar                                 343     340      -3
bc_program_call                                      372     367      -5
bc_parse_expr                                       2215    2210      -5
bc_program_modexp                                    763     756      -7
bc_err_msgs                                          164      60    -104
bc_program_pushArray                                 136       -    -136
bc_program_exec                                     4453    4153    -300
------------------------------------------------------------------------------
(add/remove: 2/1 grow/shrink: 31/7 up/down: 961/-561)         Total: 400 bytes
   text	   data	    bss	    dec	    hex	filename
 987766	    485	   7296	 995547	  f30db	busybox_old
 988258	    485	   7296	 996039	  f32c7	busybox_unstripped

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 271 insertions, 204 deletions

diff --git a/miscutils/bc.c b/miscutils/bc.c
index bd70670d5..7b20a94cc 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -168,8 +168,9 @@
 #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,
@@ -177,48 +178,47 @@ typedef enum BcStatus {
 //      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,
@@ -242,51 +242,52 @@ typedef enum BcStatus {
 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",
@@ -1577,7 +1578,8 @@ static void bc_num_split(BcNum *restrict n, size_t idx, BcNum *restrict a,
 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;
@@ -1885,7 +1887,7 @@ static BcStatus bc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
         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;
@@ -1948,7 +1950,8 @@ static BcStatus bc_num_r(BcNum *a, BcNum *b, BcNum *restrict c,
         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);
@@ -1997,7 +2000,7 @@ static BcStatus bc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
         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);
@@ -2435,7 +2438,8 @@ static void bc_num_copy(BcNum *d, BcNum *s)
 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);
@@ -2474,7 +2478,7 @@ static BcStatus bc_num_ulong(BcNum *n, unsigned long *result)
         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) {
 
@@ -2483,7 +2487,8 @@ static BcStatus bc_num_ulong(BcNum *n, unsigned long *result)
                 *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;
@@ -2555,7 +2560,7 @@ static BcStatus bc_num_sqrt(BcNum *a, BcNum *restrict b, size_t scale)
                 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);
@@ -2674,9 +2679,12 @@ static BcStatus bc_num_modexp(BcNum *a, BcNum *b, BcNum *c, BcNum *restrict d)
         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);
@@ -2735,8 +2743,8 @@ static BcStatus bc_func_insert(BcFunc *f, char *name, bool var)
         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;
@@ -2918,7 +2926,8 @@ static BcStatus bc_lex_number(BcLex *l, char start)
         }
 
         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);
@@ -2955,7 +2964,8 @@ static BcStatus bc_lex_name(BcLex *l)
 
         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.
@@ -2987,7 +2997,7 @@ static BcStatus bc_lex_next(BcLex *l)
         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;
@@ -3060,11 +3070,12 @@ static BcStatus bc_lex_string(BcLex *l)
 
         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;
@@ -3101,7 +3112,7 @@ static BcStatus bc_lex_comment(BcLex *l)
                 }
                 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++;
@@ -3404,7 +3415,7 @@ static BcStatus dc_lex_register(BcLex *l)
                 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);
         }
@@ -3437,11 +3448,12 @@ static BcStatus dc_lex_string(BcLex *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;
@@ -3606,11 +3618,12 @@ static BcStatus bc_parse_text(BcParse *p, const char *text)
 
         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);
@@ -3703,7 +3716,8 @@ static BcStatus bc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs)
 {
         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) {
@@ -3713,7 +3727,8 @@ static BcStatus bc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs)
                 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);
         }
 
@@ -3744,7 +3759,7 @@ static BcStatus bc_parse_params(BcParse *p, uint8_t flags)
                 }
         }
 
-        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);
 
@@ -3763,7 +3778,7 @@ static BcStatus bc_parse_call(BcParse *p, char *name, uint8_t flags)
         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;
         }
 
@@ -3805,7 +3820,7 @@ static BcStatus bc_parse_name(BcParse *p, BcInst *type, uint8_t flags)
                 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;
                         }
 
@@ -3828,7 +3843,7 @@ static BcStatus bc_parse_name(BcParse *p, BcInst *type, uint8_t flags)
         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;
                 }
 
@@ -3854,11 +3869,11 @@ static BcStatus bc_parse_read(BcParse *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;
-        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);
 
@@ -3872,7 +3887,7 @@ static BcStatus bc_parse_builtin(BcParse *p, BcLexType type, uint8_t flags,
 
         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;
 
@@ -3882,7 +3897,7 @@ static BcStatus bc_parse_builtin(BcParse *p, BcLexType type, uint8_t flags,
         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);
@@ -3911,7 +3926,7 @@ static BcStatus bc_parse_scale(BcParse *p, BcInst *type, uint8_t flags)
 
         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);
@@ -3968,7 +3983,7 @@ static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
                                 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;
@@ -3976,7 +3991,7 @@ static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
 
                         default:
                         {
-                                s = BC_STATUS_PARSE_BAD_TOKEN;
+                                s = bc_error("bad token");
                                 break;
                         }
                 }
@@ -4037,7 +4052,7 @@ static BcStatus bc_parse_print(BcParse *p)
         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) {
 
@@ -4057,7 +4072,7 @@ static BcStatus bc_parse_print(BcParse *p)
         }
 
         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);
 }
@@ -4068,7 +4083,7 @@ static BcStatus bc_parse_return(BcParse *p)
         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;
@@ -4083,7 +4098,8 @@ static BcStatus bc_parse_return(BcParse *p)
                 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;
@@ -4105,18 +4121,18 @@ static BcStatus bc_parse_endBody(BcParse *p, bool brace)
         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)) {
@@ -4202,13 +4218,13 @@ static BcStatus bc_parse_if(BcParse *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;
@@ -4229,7 +4245,7 @@ static BcStatus bc_parse_else(BcParse *p)
 {
         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;
@@ -4253,7 +4269,7 @@ static BcStatus bc_parse_while(BcParse *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;
 
@@ -4271,7 +4287,7 @@ static BcStatus bc_parse_while(BcParse *p)
 
         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;
 
@@ -4290,7 +4306,7 @@ static BcStatus bc_parse_for(BcParse *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;
 
@@ -4300,7 +4316,7 @@ static BcStatus bc_parse_for(BcParse *p)
                 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;
 
@@ -4317,7 +4333,7 @@ static BcStatus bc_parse_for(BcParse *p)
                 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;
@@ -4339,7 +4355,7 @@ static BcStatus bc_parse_for(BcParse *p)
 
         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);
@@ -4362,17 +4378,17 @@ static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type)
         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;
         }
@@ -4386,7 +4402,7 @@ static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type)
         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);
 }
@@ -4400,20 +4416,23 @@ static BcStatus bc_parse_func(BcParse *p)
 
         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;
 
@@ -4429,7 +4448,7 @@ static BcStatus bc_parse_func(BcParse *p)
                         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;
                         }
 
@@ -4447,7 +4466,7 @@ static BcStatus bc_parse_func(BcParse *p)
                 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);
@@ -4471,7 +4490,7 @@ static BcStatus bc_parse_auto(BcParse *p)
         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;
 
@@ -4491,7 +4510,7 @@ static BcStatus bc_parse_auto(BcParse *p)
                         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;
                         }
 
@@ -4509,11 +4528,11 @@ static BcStatus bc_parse_auto(BcParse *p)
                 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);
 
@@ -4531,7 +4550,7 @@ static BcStatus bc_parse_body(BcParse *p, bool brace)
 
         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) {
@@ -4568,7 +4587,7 @@ static BcStatus bc_parse_stmt(BcParse *p)
 
                 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);
@@ -4713,7 +4732,7 @@ static BcStatus bc_parse_stmt(BcParse *p)
 
                 default:
                 {
-                        s = BC_STATUS_PARSE_BAD_TOKEN;
+                        s = bc_error("bad token");
                         break;
                 }
         }
@@ -4726,9 +4745,9 @@ static BcStatus bc_parse_parse(BcParse *p)
         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
@@ -4787,7 +4806,11 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                                     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;
                                 }
                         }
@@ -4807,10 +4830,10 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                         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;
@@ -4824,8 +4847,8 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
 
                         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;
@@ -4837,7 +4860,7 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                         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;
@@ -4859,8 +4882,8 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
 
                         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);
@@ -4871,8 +4894,8 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
 
                         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;
@@ -4884,8 +4907,8 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                         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);
 
@@ -4899,8 +4922,8 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                         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;
@@ -4912,9 +4935,9 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                         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);
 
@@ -4928,8 +4951,8 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
 
                         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;
@@ -4941,7 +4964,7 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
 
                         default:
                         {
-                                s = BC_STATUS_PARSE_BAD_TOKEN;
+                                s = bc_error("bad token");
                                 break;
                         }
                 }
@@ -4958,7 +4981,7 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                 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));
 
@@ -4966,11 +4989,14 @@ static BcStatus bc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
                 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);
@@ -5008,7 +5034,7 @@ static BcStatus dc_parse_register(BcParse *p)
 
         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);
@@ -5115,7 +5141,8 @@ static BcStatus dc_parse_token(BcParse *p, BcLexType t, uint8_t flags)
                         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);
@@ -5129,7 +5156,7 @@ static BcStatus dc_parse_token(BcParse *p, BcLexType t, uint8_t flags)
                 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;
@@ -5164,7 +5191,7 @@ static BcStatus dc_parse_token(BcParse *p, BcLexType t, uint8_t flags)
 
                 default:
                 {
-                        s = BC_STATUS_PARSE_BAD_TOKEN;
+                        s = bc_error("bad token");
                         get_token = true;
                         break;
                 }
@@ -5206,7 +5233,7 @@ static BcStatus dc_parse_parse(BcParse *p)
         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);
 
@@ -5349,7 +5376,8 @@ static BcStatus bc_program_binOpPrep(BcResult **l, BcNum **ln,
         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);
@@ -5371,8 +5399,9 @@ static BcStatus bc_program_binOpPrep(BcResult **l, BcNum **ln,
         }
 
         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;
 }
@@ -5389,13 +5418,15 @@ static BcStatus bc_program_prep(BcResult **r, BcNum **n)
 {
         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;
 }
@@ -5439,7 +5470,8 @@ static BcStatus bc_program_read(void)
 
         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);
@@ -5457,7 +5489,7 @@ static BcStatus bc_program_read(void)
         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;
         }
 
@@ -5600,7 +5632,8 @@ static BcStatus bc_program_print(char inst, size_t idx)
         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);
@@ -5731,7 +5764,8 @@ static BcStatus bc_program_assignStr(BcResult *r, BcVec *v,
         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);
         }
@@ -5752,14 +5786,17 @@ static BcStatus bc_program_copyToVar(char *name, bool var)
         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
 
@@ -5804,7 +5841,8 @@ static BcStatus bc_program_assign(char inst)
 
                 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);
@@ -5812,11 +5850,15 @@ static BcStatus bc_program_assign(char inst)
 #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);
@@ -5829,25 +5871,35 @@ static BcStatus bc_program_assign(char inst)
 #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;
@@ -5884,7 +5936,7 @@ static BcStatus bc_program_pushVar(char *code, size_t *bgn,
 
                         if (!BC_PROG_STACK(v, 2 - copy)) {
                                 free(name);
-                                return BC_STATUS_EXEC_STACK;
+                                return bc_error("stack has too few elements");
                         }
 
                         free(name);
@@ -5936,7 +5988,7 @@ static BcStatus bc_program_pushArray(char *code, size_t *bgn,
                 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;
                 }
 
@@ -6010,7 +6062,7 @@ static BcStatus bc_program_call(char *code, size_t *idx)
                 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;
@@ -6046,7 +6098,7 @@ static BcStatus bc_program_return(char inst)
         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;
@@ -6108,14 +6160,16 @@ static BcStatus bc_program_builtin(char inst)
         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);
@@ -6180,14 +6234,16 @@ static BcStatus bc_program_modexp(void)
         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) {
@@ -6238,7 +6294,8 @@ static BcStatus bc_program_asciify(void)
         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);
@@ -6306,7 +6363,8 @@ static BcStatus bc_program_printStream(void)
         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);
@@ -6338,7 +6396,7 @@ static BcStatus bc_program_nquit(void)
         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();
 
@@ -6360,7 +6418,8 @@ static BcStatus bc_program_execStr(char *code, size_t *bgn,
         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);
 
@@ -6393,7 +6452,7 @@ static BcStatus bc_program_execStr(char *code, size_t *bgn,
 
                 if (!exec) goto exit;
                 if (!BC_PROG_STR(n)) {
-                        s = BC_STATUS_EXEC_BAD_TYPE;
+                        s = bc_error("variable is wrong type");
                         goto exit;
                 }
 
@@ -6425,7 +6484,7 @@ static BcStatus bc_program_execStr(char *code, size_t *bgn,
                 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;
                 }
 
@@ -6652,7 +6711,7 @@ static BcStatus bc_program_exec(void)
                         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;
@@ -6764,7 +6823,8 @@ static BcStatus bc_program_exec(void)
 
                         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);
@@ -6775,7 +6835,8 @@ static BcStatus bc_program_exec(void)
                         {
                                 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);
@@ -6863,6 +6924,7 @@ static BcStatus bc_vm_error(BcStatus s, const char *file, size_t line)
                 fprintf(stderr, bc_err_line + 4 * !line, line);
         }
 
+///
         return s * (!G.ttyin || !!strcmp(file, bc_program_stdin_name));
 }
 
@@ -6983,7 +7045,8 @@ static BcStatus bc_vm_file(const char *file)
         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);
@@ -7057,12 +7120,16 @@ static BcStatus bc_vm_stdin(void)
                 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);