bc: convert more of lexer functions to "z" convention

function                                             old     new   delta
dc_parse_expr                                        748       -    -748
zdc_parse_expr                                         -     688    +688
bc_parse_endBody                                     338       -    -338
zbc_parse_endBody                                      -     343    +343
bc_parse_auto                                        201       -    -201
zbc_parse_auto                                         -     198    +198
dc_parse_mem                                         115       -    -115
zdc_parse_mem                                          -     108    +108
bc_parse_body                                        116       -    -116
zbc_parse_body                                         -     108    +108
bc_parse_string                                      102       -    -102
zbc_parse_string                                       -     100    +100
dc_parse_register                                     43       -     -43
zdc_parse_register                                     -      40     +40
common_parse_expr                                     40      43      +3
bc_parse_parse                                       321     476    +155
bc_parse_stmt                                       1598    1594      -4
dc_parse_parse                                        44      26     -18
bc_parse_reset                                       153       -    -153
------------------------------------------------------------------------------
(add/remove: 7/8 grow/shrink: 2/2 up/down: 1743/-1838)        Total: -95 bytes
   text	   data	    bss	    dec	    hex	filename
 981450	    485	   7296	 989231	  f182f	busybox_old
 981355	    485	   7296	 989136	  f17d0	busybox_unstripped

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

1 files changed, 137 insertions, 137 deletions

diff --git a/miscutils/bc.c b/miscutils/bc.c
index eae5063a8..3815b7f09 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -3771,22 +3771,25 @@ err:
         return s;
 }
 
-static BcStatus bc_parse_read(BcParse *p)
+static BC_STATUS zbc_parse_read(BcParse *p)
 {
         BcStatus s;
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
-        if (p->l.t.t != BC_LEX_LPAREN) return bc_error_bad_token();
+        if (s) RETURN_STATUS(s);
+        if (p->l.t.t != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
-        if (p->l.t.t != BC_LEX_RPAREN) return bc_error_bad_token();
+        if (s) RETURN_STATUS(s);
+        if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
 
         bc_parse_push(p, BC_INST_READ);
 
-        return zbc_lex_next(&p->l);
+        RETURN_STATUS(zbc_lex_next(&p->l));
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_read(...) (zbc_parse_read(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static BcStatus bc_parse_builtin(BcParse *p, BcLexType type, uint8_t flags,
                                  BcInst *prev)
@@ -3910,7 +3913,7 @@ static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
         return s;
 }
 
-static BcStatus bc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
+static BC_STATUS zbc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
                                bool rparen, size_t *nexprs)
 {
         BcStatus s;
@@ -3918,7 +3921,7 @@ static BcStatus bc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
         BcInst etype = *prev;
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         type = rparen || etype == BC_INST_INC_POST || etype == BC_INST_DEC_POST ||
                        (etype >= BC_INST_NUM && etype <= BC_INST_SQRT) ?
@@ -3933,10 +3936,13 @@ static BcStatus bc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
         else
                 s = zbc_parse_operator(p, type, ops_bgn, nexprs, false);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_minus(...) (zbc_parse_minus(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus bc_parse_string(BcParse *p, char inst)
+static BC_STATUS zbc_parse_string(BcParse *p, char inst)
 {
         char *str = xstrdup(p->l.t.v.v);
 
@@ -3945,8 +3951,11 @@ static BcStatus bc_parse_string(BcParse *p, char inst)
         bc_vec_push(&G.prog.strs, &str);
         bc_parse_push(p, inst);
 
-        return zbc_lex_next(&p->l);
+        RETURN_STATUS(zbc_lex_next(&p->l));
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_string(...) (zbc_parse_string(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static BcStatus bc_parse_print(BcParse *p)
 {
@@ -3966,7 +3975,7 @@ static BcStatus bc_parse_print(BcParse *p)
         while (type != BC_LEX_SCOLON && type != BC_LEX_NLINE) {
 
                 if (type == BC_LEX_STR) {
-                        s = bc_parse_string(p, BC_INST_PRINT_POP);
+                        s = zbc_parse_string(p, BC_INST_PRINT_POP);
                         if (s) return s;
                 } else {
                         s = bc_parse_expr(p, 0, bc_parse_next_print);
@@ -4023,32 +4032,29 @@ static BcStatus bc_parse_return(BcParse *p)
         return s;
 }
 
-static BcStatus bc_parse_endBody(BcParse *p, bool brace)
+static BC_STATUS zbc_parse_endBody(BcParse *p, bool brace)
 {
         BcStatus s = BC_STATUS_SUCCESS;
 
         if (p->flags.len <= 1 || (brace && p->nbraces == 0))
-                return bc_error_bad_token();
+                RETURN_STATUS(bc_error_bad_token());
 
         if (brace) {
-
-                if (p->l.t.t == BC_LEX_RBRACE) {
-                        if (!p->nbraces) return bc_error_bad_token();
-                        --p->nbraces;
-                        s = zbc_lex_next(&p->l);
-                        if (s) return s;
-                }
-                else
-                        return bc_error_bad_token();
+                if (p->l.t.t != BC_LEX_RBRACE)
+                        RETURN_STATUS(bc_error_bad_token());
+                if (!p->nbraces)
+                        RETURN_STATUS(bc_error_bad_token());
+                --p->nbraces;
+                s = zbc_lex_next(&p->l);
+                if (s) RETURN_STATUS(s);
         }
 
         if (BC_PARSE_IF(p)) {
-
                 uint8_t *flag_ptr;
 
                 while (p->l.t.t == BC_LEX_NLINE) {
                         s = zbc_lex_next(&p->l);
-                        if (s) return s;
+                        if (s) RETURN_STATUS(s);
                 }
 
                 bc_vec_pop(&p->flags);
@@ -4060,7 +4066,6 @@ static BcStatus bc_parse_endBody(BcParse *p, bool brace)
                         ERROR_RETURN(s =) zbc_parse_else(p);
         }
         else if (BC_PARSE_ELSE(p)) {
-
                 BcInstPtr *ip;
                 size_t *label;
 
@@ -4078,7 +4083,6 @@ static BcStatus bc_parse_endBody(BcParse *p, bool brace)
                 bc_vec_pop(&p->flags);
         }
         else {
-
                 BcInstPtr *ip = bc_vec_top(&p->exits);
                 size_t *label = bc_vec_top(&p->conds);
 
@@ -4093,8 +4097,11 @@ static BcStatus bc_parse_endBody(BcParse *p, bool brace)
                 bc_vec_pop(&p->conds);
         }
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_endBody(...) (zbc_parse_endBody(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static void bc_parse_startBody(BcParse *p, uint8_t flags)
 {
@@ -4284,23 +4291,24 @@ static BcStatus bc_parse_for(BcParse *p)
         return BC_STATUS_SUCCESS;
 }
 
-static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type)
+static BC_STATUS zbc_parse_loopExit(BcParse *p, BcLexType type)
 {
         BcStatus s;
         size_t i;
         BcInstPtr *ip;
 
-        if (!BC_PARSE_LOOP(p)) return bc_error_bad_token();
+        if (!BC_PARSE_LOOP(p)) RETURN_STATUS(bc_error_bad_token());
 
         if (type == BC_LEX_KEY_BREAK) {
-
-                if (p->exits.len == 0) return bc_error_bad_token();
+                if (p->exits.len == 0) RETURN_STATUS(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_error_bad_token();
+                while (!ip->func && i < p->exits.len)
+                        ip = bc_vec_item(&p->exits, i--);
+                if (i >= p->exits.len && !ip->func)
+                        RETURN_STATUS(bc_error_bad_token());
 
                 i = ip->idx;
         }
@@ -4311,15 +4319,18 @@ static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type)
         bc_parse_pushIndex(p, i);
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         if (p->l.t.t != BC_LEX_SCOLON && p->l.t.t != BC_LEX_NLINE)
-                return bc_error_bad_token();
+                RETURN_STATUS(bc_error_bad_token());
 
-        return zbc_lex_next(&p->l);
+        RETURN_STATUS(zbc_lex_next(&p->l));
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_loopExit(...) (zbc_parse_loopExit(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus bc_parse_func(BcParse *p)
+static BC_STATUS zbc_parse_func(BcParse *p)
 {
         BcStatus s;
         bool var, comma = false;
@@ -4327,24 +4338,23 @@ static BcStatus bc_parse_func(BcParse *p)
         char *name;
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
         if (p->l.t.t != BC_LEX_NAME)
-                return bc_error("bad function definition");
+                RETURN_STATUS(bc_error("bad function definition"));
 
         name = xstrdup(p->l.t.v.v);
         bc_parse_addFunc(p, name, &p->fidx);
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
         if (p->l.t.t != BC_LEX_LPAREN)
-                return bc_error("bad function definition");
+                RETURN_STATUS(bc_error("bad function definition"));
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         while (p->l.t.t != BC_LEX_RPAREN) {
-
                 if (p->l.t.t != BC_LEX_NAME)
-                        return bc_error("bad function definition");
+                        RETURN_STATUS(bc_error("bad function definition"));
 
                 ++p->func->nparams;
 
@@ -4355,7 +4365,6 @@ static BcStatus bc_parse_func(BcParse *p)
                 var = p->l.t.t != BC_LEX_LBRACKET;
 
                 if (!var) {
-
                         s = zbc_lex_next(&p->l);
                         if (s) goto err;
 
@@ -4378,46 +4387,48 @@ static BcStatus bc_parse_func(BcParse *p)
                 if (s) goto err;
         }
 
-        if (comma) return bc_error("bad function definition");
+        if (comma) RETURN_STATUS(bc_error("bad function definition"));
 
         flags = BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_FUNC_INNER | BC_PARSE_FLAG_BODY;
         bc_parse_startBody(p, flags);
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         if (p->l.t.t != BC_LEX_LBRACE)
                 s = bc_POSIX_requires("the left brace be on the same line as the function header");
 
-        return s;
+        RETURN_STATUS(s);
 
 err:
         free(name);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_func(...) (zbc_parse_func(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus bc_parse_auto(BcParse *p)
+static BC_STATUS zbc_parse_auto(BcParse *p)
 {
         BcStatus s;
         bool comma, var, one;
         char *name;
 
-        if (!p->auto_part) return bc_error_bad_token();
+        if (!p->auto_part) RETURN_STATUS(bc_error_bad_token());
+
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         p->auto_part = comma = false;
         one = p->l.t.t == BC_LEX_NAME;
 
         while (p->l.t.t == BC_LEX_NAME) {
-
                 name = xstrdup(p->l.t.v.v);
                 s = zbc_lex_next(&p->l);
                 if (s) goto err;
 
                 var = p->l.t.t != BC_LEX_LBRACKET;
                 if (!var) {
-
                         s = zbc_lex_next(&p->l);
                         if (s) goto err;
 
@@ -4440,20 +4451,23 @@ static BcStatus bc_parse_auto(BcParse *p)
                 if (s) goto err;
         }
 
-        if (comma) return bc_error("bad function definition");
-        if (!one) return bc_error("no auto variable found");
+        if (comma) RETURN_STATUS(bc_error("bad function definition"));
+        if (!one) RETURN_STATUS(bc_error("no auto variable found"));
 
         if (p->l.t.t != BC_LEX_NLINE && p->l.t.t != BC_LEX_SCOLON)
-                return bc_error_bad_token();
+                RETURN_STATUS(bc_error_bad_token());
 
-        return zbc_lex_next(&p->l);
+        RETURN_STATUS(zbc_lex_next(&p->l));
 
 err:
         free(name);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_auto(...) (zbc_parse_auto(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus bc_parse_body(BcParse *p, bool brace)
+static BC_STATUS zbc_parse_body(BcParse *p, bool brace)
 {
         BcStatus s = BC_STATUS_SUCCESS;
         uint8_t *flag_ptr = bc_vec_top(&p->flags);
@@ -4461,24 +4475,27 @@ static BcStatus bc_parse_body(BcParse *p, bool brace)
         *flag_ptr &= ~(BC_PARSE_FLAG_BODY);
 
         if (*flag_ptr & BC_PARSE_FLAG_FUNC_INNER) {
+                if (!brace) RETURN_STATUS(bc_error_bad_token());
 
-                if (!brace) return bc_error_bad_token();
                 p->auto_part = p->l.t.t != BC_LEX_KEY_AUTO;
 
                 if (!p->auto_part) {
-                        s = bc_parse_auto(p);
-                        if (s) return s;
+                        s = zbc_parse_auto(p);
+                        if (s) RETURN_STATUS(s);
                 }
 
                 if (p->l.t.t == BC_LEX_NLINE) s = zbc_lex_next(&p->l);
         }
         else {
                 s = bc_parse_stmt(p);
-                if (!s && !brace) s = bc_parse_endBody(p, false);
+                if (!s && !brace) s = zbc_parse_endBody(p, false);
         }
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_parse_body(...) (zbc_parse_body(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static BcStatus bc_parse_stmt(BcParse *p)
 {
@@ -4505,12 +4522,12 @@ static BcStatus bc_parse_stmt(BcParse *p)
                         s = zbc_lex_next(&p->l);
                         if (s) return s;
 
-                        return bc_parse_body(p, true);
+                        return zbc_parse_body(p, true);
                 }
 
                 case BC_LEX_KEY_AUTO:
                 {
-                        return bc_parse_auto(p);
+                        return zbc_parse_auto(p);
                 }
 
                 default:
@@ -4522,7 +4539,7 @@ static BcStatus bc_parse_stmt(BcParse *p)
                                 return BC_STATUS_SUCCESS;
                         }
                         else if (BC_PARSE_BODY(p))
-                                return bc_parse_body(p, false);
+                                return zbc_parse_body(p, false);
 
                         break;
                 }
@@ -4563,20 +4580,20 @@ static BcStatus bc_parse_stmt(BcParse *p)
 
                 case BC_LEX_RBRACE:
                 {
-                        s = bc_parse_endBody(p, true);
+                        s = zbc_parse_endBody(p, true);
                         break;
                 }
 
                 case BC_LEX_STR:
                 {
-                        s = bc_parse_string(p, BC_INST_PRINT_STR);
+                        s = zbc_parse_string(p, BC_INST_PRINT_STR);
                         break;
                 }
 
                 case BC_LEX_KEY_BREAK:
                 case BC_LEX_KEY_CONTINUE:
                 {
-                        s = bc_parse_loopExit(p, p->l.t.t);
+                        s = zbc_parse_loopExit(p, p->l.t.t);
                         break;
                 }
 
@@ -4662,7 +4679,7 @@ static FAST_FUNC BcStatus bc_parse_parse(BcParse *p)
                 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_error_bad_token();
-                s = bc_parse_func(p);
+                s = zbc_parse_func(p);
         }
         else
                 s = bc_parse_stmt(p);
@@ -4703,7 +4720,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
 
                         case BC_LEX_OP_MINUS:
                         {
-                                s = bc_parse_minus(p, &prev, ops_bgn, rprn, &nexprs);
+                                s = zbc_parse_minus(p, &prev, ops_bgn, rprn, &nexprs);
                                 rprn = get_token = false;
                                 bin_last = prev == BC_INST_MINUS;
                                 break;
@@ -4854,7 +4871,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
                                 else if (flags & BC_PARSE_NOREAD)
                                         s = bc_error_nested_read_call();
                                 else
-                                        s = bc_parse_read(p);
+                                        s = zbc_parse_read(p);
 
                                 paren_expr = true;
                                 rprn = get_token = bin_last = false;
@@ -4961,20 +4978,23 @@ static BcStatus bc_parse_expression(BcParse *p, uint8_t flags)
 
 #define DC_PARSE_BUF_LEN ((int) (sizeof(uint32_t) * CHAR_BIT))
 
-static BcStatus dc_parse_register(BcParse *p)
+static BC_STATUS zdc_parse_register(BcParse *p)
 {
         BcStatus s;
         char *name;
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
-        if (p->l.t.t != BC_LEX_NAME) return bc_error_bad_token();
+        if (s) RETURN_STATUS(s);
+        if (p->l.t.t != BC_LEX_NAME) RETURN_STATUS(bc_error_bad_token());
 
         name = xstrdup(p->l.t.v.v);
         bc_parse_pushName(p, name);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zdc_parse_register(...) (zdc_parse_register(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static BC_STATUS zdc_parse_string(BcParse *p)
 {
@@ -4996,14 +5016,14 @@ static BC_STATUS zdc_parse_string(BcParse *p)
 # define zdc_parse_string(...) (zdc_parse_string(__VA_ARGS__), BC_STATUS_SUCCESS)
 #endif
 
-static BcStatus dc_parse_mem(BcParse *p, uint8_t inst, bool name, bool store)
+static BC_STATUS zdc_parse_mem(BcParse *p, uint8_t inst, bool name, bool store)
 {
         BcStatus s;
 
         bc_parse_push(p, inst);
         if (name) {
-                s = dc_parse_register(p);
-                if (s) return s;
+                s = zdc_parse_register(p);
+                if (s) RETURN_STATUS(s);
         }
 
         if (store) {
@@ -5012,34 +5032,40 @@ static BcStatus dc_parse_mem(BcParse *p, uint8_t inst, bool name, bool store)
                 bc_parse_push(p, BC_INST_POP);
         }
 
-        return zbc_lex_next(&p->l);
+        RETURN_STATUS(zbc_lex_next(&p->l));
 }
+#if ERRORS_ARE_FATAL
+# define zdc_parse_mem(...) (zdc_parse_mem(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus dc_parse_cond(BcParse *p, uint8_t inst)
+static BC_STATUS zdc_parse_cond(BcParse *p, uint8_t inst)
 {
         BcStatus s;
 
         bc_parse_push(p, inst);
         bc_parse_push(p, BC_INST_EXEC_COND);
 
-        s = dc_parse_register(p);
-        if (s) return s;
+        s = zdc_parse_register(p);
+        if (s) RETURN_STATUS(s);
 
         s = zbc_lex_next(&p->l);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         if (p->l.t.t == BC_LEX_ELSE) {
-                s = dc_parse_register(p);
-                if (s) return s;
+                s = zdc_parse_register(p);
+                if (s) RETURN_STATUS(s);
                 s = zbc_lex_next(&p->l);
         }
         else
                 bc_parse_push(p, BC_PARSE_STREND);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zdc_parse_cond(...) (zdc_parse_cond(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus dc_parse_token(BcParse *p, BcLexType t, uint8_t flags)
+static BC_STATUS zdc_parse_token(BcParse *p, BcLexType t, uint8_t flags)
 {
         BcStatus s = BC_STATUS_SUCCESS;
         BcInst prev;
@@ -5047,99 +5073,72 @@ static BcStatus dc_parse_token(BcParse *p, BcLexType t, uint8_t flags)
         bool assign, get_token = false;
 
         switch (t) {
-
                 case BC_LEX_OP_REL_EQ:
                 case BC_LEX_OP_REL_LE:
                 case BC_LEX_OP_REL_GE:
                 case BC_LEX_OP_REL_NE:
                 case BC_LEX_OP_REL_LT:
                 case BC_LEX_OP_REL_GT:
-                {
-                        s = dc_parse_cond(p, t - BC_LEX_OP_REL_EQ + BC_INST_REL_EQ);
+                        s = zdc_parse_cond(p, t - BC_LEX_OP_REL_EQ + BC_INST_REL_EQ);
                         break;
-                }
-
                 case BC_LEX_SCOLON:
                 case BC_LEX_COLON:
-                {
-                        s = dc_parse_mem(p, BC_INST_ARRAY_ELEM, true, t == BC_LEX_COLON);
+                        s = zdc_parse_mem(p, BC_INST_ARRAY_ELEM, true, t == BC_LEX_COLON);
                         break;
-                }
-
                 case BC_LEX_STR:
-                {
                         s = zdc_parse_string(p);
                         break;
-                }
-
                 case BC_LEX_NEG:
                 case BC_LEX_NUMBER:
-                {
                         if (t == BC_LEX_NEG) {
                                 s = zbc_lex_next(&p->l);
-                                if (s) return s;
+                                if (s) RETURN_STATUS(s);
                                 if (p->l.t.t != BC_LEX_NUMBER)
-                                        return bc_error_bad_token();
+                                        RETURN_STATUS(bc_error_bad_token());
                         }
-
                         bc_parse_number(p, &prev, &p->nbraces);
-
                         if (t == BC_LEX_NEG) bc_parse_push(p, BC_INST_NEG);
                         get_token = true;
-
                         break;
-                }
-
                 case BC_LEX_KEY_READ:
-                {
                         if (flags & BC_PARSE_NOREAD)
                                 s = bc_error_nested_read_call();
                         else
                                 bc_parse_push(p, BC_INST_READ);
                         get_token = true;
                         break;
-                }
-
                 case BC_LEX_OP_ASSIGN:
                 case BC_LEX_STORE_PUSH:
-                {
                         assign = t == BC_LEX_OP_ASSIGN;
                         inst = assign ? BC_INST_VAR : BC_INST_PUSH_TO_VAR;
-                        s = dc_parse_mem(p, inst, true, assign);
+                        s = zdc_parse_mem(p, inst, true, assign);
                         break;
-                }
-
                 case BC_LEX_LOAD:
                 case BC_LEX_LOAD_POP:
-                {
                         inst = t == BC_LEX_LOAD_POP ? BC_INST_PUSH_VAR : BC_INST_LOAD;
-                        s = dc_parse_mem(p, inst, true, false);
+                        s = zdc_parse_mem(p, inst, true, false);
                         break;
-                }
-
                 case BC_LEX_STORE_IBASE:
                 case BC_LEX_STORE_SCALE:
                 case BC_LEX_STORE_OBASE:
-                {
                         inst = t - BC_LEX_STORE_IBASE + BC_INST_IBASE;
-                        s = dc_parse_mem(p, inst, false, true);
+                        s = zdc_parse_mem(p, inst, false, true);
                         break;
-                }
-
                 default:
-                {
                         s = bc_error_bad_token();
                         get_token = true;
                         break;
-                }
         }
 
         if (!s && get_token) s = zbc_lex_next(&p->l);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zdc_parse_token(...) (zdc_parse_token(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus dc_parse_expr(BcParse *p, uint8_t flags)
+static BC_STATUS zdc_parse_expr(BcParse *p, uint8_t flags)
 {
         BcStatus s = BC_STATUS_SUCCESS;
         BcInst inst;
@@ -5148,22 +5147,23 @@ static BcStatus dc_parse_expr(BcParse *p, uint8_t flags)
         if (flags & BC_PARSE_NOCALL) p->nbraces = G.prog.results.len;
 
         for (t = p->l.t.t; !s && t != BC_LEX_EOF; t = p->l.t.t) {
-
                 inst = dc_parse_insts[t];
 
                 if (inst != BC_INST_INVALID) {
                         bc_parse_push(p, inst);
                         s = zbc_lex_next(&p->l);
-                }
-                else
-                        s = dc_parse_token(p, t, flags);
+                } else
+                        s = zdc_parse_token(p, t, flags);
         }
 
         if (!s && p->l.t.t == BC_LEX_EOF && (flags & BC_PARSE_NOCALL))
                 bc_parse_push(p, BC_INST_POP_EXEC);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static FAST_FUNC BcStatus dc_parse_parse(BcParse *p)
 {
@@ -5172,7 +5172,7 @@ static FAST_FUNC BcStatus dc_parse_parse(BcParse *p)
         if (p->l.t.t == BC_LEX_EOF)
                 s = bc_error("end of file");
         else
-                s = dc_parse_expr(p, 0);
+                s = zdc_parse_expr(p, 0);
 
         if (s || G_interrupt) {
                 bc_parse_reset(p);
@@ -5203,7 +5203,7 @@ static BcStatus common_parse_expr(BcParse *p, uint8_t flags)
         if (IS_BC) {
                 IF_BC(return bc_parse_expression(p, flags);)
         } else {
-                IF_DC(return dc_parse_expr(p, flags);)
+                IF_DC(return zdc_parse_expr(p, flags);)
         }
 }