bc: convert arithmetic calc functions to "z" logic

In order for magic macros to work, a bit of reordering was necessary.

function                                             old     new   delta
zbc_program_modexp                                     -     558    +558
zbc_program_assign                                     -     448    +448
zbc_program_pushArray                                  -     111    +111
zbc_num_s                                            239     237      -2
zbc_num_d                                            543     541      -2
zbc_num_binary                                       145     143      -2
zbc_num_a                                            443     441      -2
zbc_num_rem                                           95      91      -4
zbc_num_divmod                                       150     146      -4
zbc_num_m                                            269     257     -12
zbc_num_r                                            230     208     -22
zbc_num_printNum                                     447     417     -30
bc_program_exec                                     3960    3928     -32
zbc_num_p                                            434     399     -35
zbc_program_num                                      880     840     -40
zbc_num_k                                            913     852     -61
zbc_program_printStream                              141       -    -141
bc_program_assign                                    455       -    -455
bc_program_modexp                                    668       -    -668
------------------------------------------------------------------------------
(add/remove: 3/3 grow/shrink: 0/13 up/down: 1117/-1512)      Total: -395 bytes
   text	   data	    bss	    dec	    hex	filename
 982632	    485	   7296	 990413	  f1ccd	busybox_old
 982237	    485	   7296	 990018	  f1b42	busybox_unstripped

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

1 files changed, 424 insertions, 355 deletions

diff --git a/miscutils/bc.c b/miscutils/bc.c
index 3ab0bf3b7..5ede8598d 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -929,35 +929,94 @@ dc_parse_insts[] = {
 // ("always returning zero") prefix, i.e. zbc_foo or zdc_foo.
 //
 #if ENABLE_FEATURE_BC_SIGNALS || ENABLE_FEATURE_CLEAN_UP
+# define ERRORS_ARE_FATAL 0
 # define ERRORFUNC        /*nothing*/
 # define ERROR_RETURN(a)  a
-# define ERRORS_ARE_FATAL 0
 # define BC_STATUS        BcStatus
 # define RETURN_STATUS(v) return (v)
 #else
+# define ERRORS_ARE_FATAL 1
 # define ERRORFUNC        NORETURN
 # define ERROR_RETURN(a)  /*nothing*/
-# define ERRORS_ARE_FATAL 1
 # define BC_STATUS        void
 # define RETURN_STATUS(v) do { ((void)(v)); return; } while (0)
 #endif
 
+#define BC_NUM_NEG(n, neg)      ((((ssize_t)(n)) ^ -((ssize_t)(neg))) + (neg))
+#define BC_NUM_ONE(n)           ((n)->len == 1 && (n)->rdx == 0 && (n)->num[0] == 1)
+#define BC_NUM_INT(n)           ((n)->len - (n)->rdx)
+//#define BC_NUM_AREQ(a, b)       (BC_MAX((a)->rdx, (b)->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1)
+static /*ALWAYS_INLINE*/ size_t BC_NUM_AREQ(BcNum *a, BcNum *b)
+{
+        return BC_MAX(a->rdx, b->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1;
+}
+//#define BC_NUM_MREQ(a, b, scale) (BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX((scale), (a)->rdx + (b)->rdx) + 1)
+static /*ALWAYS_INLINE*/ size_t BC_NUM_MREQ(BcNum *a, BcNum *b, size_t scale)
+{
+        return BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX(scale, a->rdx + b->rdx) + 1;
+}
+
 typedef void (*BcNumDigitOp)(size_t, size_t, bool) FAST_FUNC;
 
-typedef BcStatus (*BcNumBinaryOp)(BcNum *, BcNum *, BcNum *, size_t) FAST_FUNC;
+typedef BC_STATUS (*BcNumBinaryOp)(BcNum *, BcNum *, BcNum *, size_t) FAST_FUNC;
 
-static BcStatus zbc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale) FAST_FUNC;
-static BcStatus zbc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale) FAST_FUNC;
-static BcStatus zbc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale) FAST_FUNC;
-static BcStatus zbc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale) FAST_FUNC;
-static BcStatus zbc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale) FAST_FUNC;
-static BcStatus zbc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale) FAST_FUNC;
-static BcStatus zbc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d,
-                              size_t scale);
+static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
+                        BcNumBinaryOp op, size_t req);
+static FAST_FUNC BC_STATUS zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
+static FAST_FUNC BC_STATUS zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
+static FAST_FUNC BC_STATUS zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
+static FAST_FUNC BC_STATUS zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
+static FAST_FUNC BC_STATUS zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
+static FAST_FUNC BC_STATUS zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
+
+static FAST_FUNC BC_STATUS zbc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale)
+{
+        BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_a : zbc_num_s;
+        (void) scale;
+        RETURN_STATUS(zbc_num_binary(a, b, c, false, op, BC_NUM_AREQ(a, b)));
+}
+
+static FAST_FUNC BC_STATUS zbc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale)
+{
+        BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_s : zbc_num_a;
+        (void) scale;
+        RETURN_STATUS(zbc_num_binary(a, b, c, true, op, BC_NUM_AREQ(a, b)));
+}
+
+static FAST_FUNC BC_STATUS zbc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale)
+{
+        size_t req = BC_NUM_MREQ(a, b, scale);
+        RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_m, req));
+}
+
+static FAST_FUNC BC_STATUS zbc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale)
+{
+        size_t req = BC_NUM_MREQ(a, b, scale);
+        RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_d, req));
+}
+
+static FAST_FUNC BC_STATUS zbc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale)
+{
+        size_t req = BC_NUM_MREQ(a, b, scale);
+        RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_rem, req));
+}
+
+static FAST_FUNC BC_STATUS zbc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale)
+{
+        RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_p, a->len * b->len + 1));
+}
 
 static const BcNumBinaryOp zbc_program_ops[] = {
         zbc_num_pow, zbc_num_mul, zbc_num_div, zbc_num_mod, zbc_num_add, zbc_num_sub,
 };
+#if ERRORS_ARE_FATAL
+# define zbc_num_add(...) (zbc_num_add(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_num_sub(...) (zbc_num_sub(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_num_mul(...) (zbc_num_mul(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_num_div(...) (zbc_num_div(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_num_mod(...) (zbc_num_mod(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_num_pow(...) (zbc_num_pow(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static void fflush_and_check(void)
 {
@@ -1527,20 +1586,6 @@ static void bc_num_subArrays(BcDig *restrict a, BcDig *restrict b,
         }
 }
 
-#define BC_NUM_NEG(n, neg)      ((((ssize_t)(n)) ^ -((ssize_t)(neg))) + (neg))
-#define BC_NUM_ONE(n)           ((n)->len == 1 && (n)->rdx == 0 && (n)->num[0] == 1)
-#define BC_NUM_INT(n)           ((n)->len - (n)->rdx)
-//#define BC_NUM_AREQ(a, b)       (BC_MAX((a)->rdx, (b)->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1)
-static /*ALWAYS_INLINE*/ size_t BC_NUM_AREQ(BcNum *a, BcNum *b)
-{
-        return BC_MAX(a->rdx, b->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1;
-}
-//#define BC_NUM_MREQ(a, b, scale) (BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX((scale), (a)->rdx + (b)->rdx) + 1)
-static /*ALWAYS_INLINE*/ size_t BC_NUM_MREQ(BcNum *a, BcNum *b, size_t scale)
-{
-        return BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX(scale, a->rdx + b->rdx) + 1;
-}
-
 static ssize_t bc_num_compare(BcDig *restrict a, BcDig *restrict b, size_t len)
 {
         size_t i;
@@ -1692,7 +1737,7 @@ static BC_STATUS zbc_num_shift(BcNum *n, size_t places)
 # define zbc_num_shift(...) (zbc_num_shift(__VA_ARGS__), BC_STATUS_SUCCESS)
 #endif
 
-static BcStatus zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
+static BC_STATUS zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
 {
         BcNum one;
         BcDig num[2];
@@ -1701,10 +1746,13 @@ static BcStatus zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
         one.num = num;
         bc_num_one(&one);
 
-        return zbc_num_div(&one, a, b, scale);
+        RETURN_STATUS(zbc_num_div(&one, a, b, scale));
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_inv(...) (zbc_num_inv(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static FAST_FUNC BcStatus zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
+static FAST_FUNC BC_STATUS zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
 {
         BcDig *ptr, *ptr_a, *ptr_b, *ptr_c;
         size_t i, max, min_rdx, min_int, diff, a_int, b_int;
@@ -1716,11 +1764,11 @@ static FAST_FUNC BcStatus zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_
         if (a->len == 0) {
                 bc_num_copy(c, b);
                 if (sub && c->len) c->neg = !c->neg;
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
-        else if (b->len == 0) {
+        if (b->len == 0) {
                 bc_num_copy(c, a);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         c->neg = a->neg;
@@ -1772,10 +1820,10 @@ static FAST_FUNC BcStatus zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_
 
         if (carry != 0) c->num[c->len++] = (BcDig) carry;
 
-        return BC_STATUS_SUCCESS; // can't make void, see zbc_num_binary()
+        RETURN_STATUS(BC_STATUS_SUCCESS); // can't make void, see zbc_num_binary()
 }
 
-static FAST_FUNC BcStatus zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
+static FAST_FUNC BC_STATUS zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
 {
         ssize_t cmp;
         BcNum *minuend, *subtrahend;
@@ -1788,11 +1836,11 @@ static FAST_FUNC BcStatus zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_
         if (a->len == 0) {
                 bc_num_copy(c, b);
                 if (sub && c->len) c->neg = !c->neg;
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
-        else if (b->len == 0) {
+        if (b->len == 0) {
                 bc_num_copy(c, a);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         aneg = a->neg;
@@ -1806,9 +1854,9 @@ static FAST_FUNC BcStatus zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_
 
         if (cmp == 0) {
                 bc_num_setToZero(c, BC_MAX(a->rdx, b->rdx));
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
-        else if (cmp > 0) {
+        if (cmp > 0) {
                 neg = a->neg;
                 minuend = a;
                 subtrahend = b;
@@ -1834,11 +1882,14 @@ static FAST_FUNC BcStatus zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_
 
         bc_num_clean(c);
 
-        return BC_STATUS_SUCCESS; // can't make void, see zbc_num_binary()
+        RETURN_STATUS(BC_STATUS_SUCCESS); // can't make void, see zbc_num_binary()
 }
 
-static FAST_FUNC BcStatus zbc_num_k(BcNum *restrict a, BcNum *restrict b,
+static FAST_FUNC BC_STATUS zbc_num_k(BcNum *restrict a, BcNum *restrict b,
                          BcNum *restrict c)
+#if ERRORS_ARE_FATAL
+# define zbc_num_k(...) (zbc_num_k(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 {
         BcStatus s;
         size_t max = BC_MAX(a->len, b->len), max2 = (max + 1) / 2;
@@ -1847,12 +1898,12 @@ static FAST_FUNC BcStatus zbc_num_k(BcNum *restrict a, BcNum *restrict b,
 
         if (a->len == 0 || b->len == 0) {
                 bc_num_zero(c);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
         aone = BC_NUM_ONE(a);
         if (aone || BC_NUM_ONE(b)) {
                 bc_num_copy(c, aone ? b : a);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         if (a->len + b->len < BC_NUM_KARATSUBA_LEN ||
@@ -1880,14 +1931,16 @@ static FAST_FUNC BcStatus zbc_num_k(BcNum *restrict a, BcNum *restrict b,
                         c->num[i + j] += (BcDig) carry;
                         len = BC_MAX(len, i + j + !!carry);
 
+#if ENABLE_FEATURE_BC_SIGNALS
                         // a=2^1000000
                         // a*a <- without check below, this will not be interruptible
                         if (G_interrupt) return BC_STATUS_FAILURE;
+#endif
                 }
 
                 c->len = len;
 
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         bc_num_init(&l1, max);
@@ -1940,10 +1993,10 @@ err:
         bc_num_free(&l2);
         bc_num_free(&h1);
         bc_num_free(&l1);
-        return s;
+        RETURN_STATUS(s);
 }
 
-static FAST_FUNC BcStatus zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
+static FAST_FUNC BC_STATUS zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
 {
         BcStatus s;
         BcNum cpa, cpb;
@@ -1982,10 +2035,13 @@ static FAST_FUNC BcStatus zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_
 err:
         bc_num_free(&cpb);
         bc_num_free(&cpa);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_m(...) (zbc_num_m(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static FAST_FUNC BcStatus zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
+static FAST_FUNC BC_STATUS zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
 {
         BcStatus s = BC_STATUS_SUCCESS;
         BcDig *n, *p, q;
@@ -1994,15 +2050,15 @@ static FAST_FUNC BcStatus zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_
         bool zero = true;
 
         if (b->len == 0)
-                return bc_error("divide by zero");
-        else if (a->len == 0) {
+                RETURN_STATUS(bc_error("divide by zero"));
+        if (a->len == 0) {
                 bc_num_setToZero(c, scale);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
-        else if (BC_NUM_ONE(b)) {
+        if (BC_NUM_ONE(b)) {
                 bc_num_copy(c, a);
                 bc_num_retireMul(c, scale, a->neg, b->neg);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         bc_num_init(&cp, BC_NUM_MREQ(a, b, scale));
@@ -2042,6 +2098,7 @@ static FAST_FUNC BcStatus zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_
                 for (q = 0; (!s && n[len] != 0) || bc_num_compare(n, p, len) >= 0; ++q)
                         bc_num_subArrays(n, p, len);
                 c->num[i] = q;
+#if ENABLE_FEATURE_BC_SIGNALS
                 // a=2^100000
                 // scale=40000
                 // 1/a <- without check below, this will not be interruptible
@@ -2049,15 +2106,19 @@ static FAST_FUNC BcStatus zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_
                         s = BC_STATUS_FAILURE;
                         break;
                 }
+#endif
         }
 
         bc_num_retireMul(c, scale, a->neg, b->neg);
         bc_num_free(&cp);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_d(...) (zbc_num_d(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static FAST_FUNC BcStatus zbc_num_r(BcNum *a, BcNum *b, BcNum *restrict c,
+static FAST_FUNC BC_STATUS zbc_num_r(BcNum *a, BcNum *b, BcNum *restrict c,
                          BcNum *restrict d, size_t scale, size_t ts)
 {
         BcStatus s;
@@ -2065,11 +2126,11 @@ static FAST_FUNC BcStatus zbc_num_r(BcNum *a, BcNum *b, BcNum *restrict c,
         bool neg;
 
         if (b->len == 0)
-                return bc_error("divide by zero");
+                RETURN_STATUS(bc_error("divide by zero"));
 
         if (a->len == 0) {
                 bc_num_setToZero(d, ts);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         bc_num_init(&temp, d->cap);
@@ -2091,10 +2152,13 @@ static FAST_FUNC BcStatus zbc_num_r(BcNum *a, BcNum *b, BcNum *restrict c,
 
 err:
         bc_num_free(&temp);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_r(...) (zbc_num_r(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static FAST_FUNC BcStatus zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
+static FAST_FUNC BC_STATUS zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
 {
         BcStatus s;
         BcNum c1;
@@ -2104,10 +2168,13 @@ static FAST_FUNC BcStatus zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, siz
         s = zbc_num_r(a, b, &c1, c, scale, ts);
         bc_num_free(&c1);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_rem(...) (zbc_num_rem(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static FAST_FUNC BcStatus zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
+static FAST_FUNC BC_STATUS zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
 {
         BcStatus s = BC_STATUS_SUCCESS;
         BcNum copy;
@@ -2115,29 +2182,29 @@ static FAST_FUNC BcStatus zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_
         size_t i, powrdx, resrdx;
         bool neg, zero;
 
-        if (b->rdx) return bc_error("non integer number");
+        if (b->rdx) RETURN_STATUS(bc_error("non integer number"));
 
         if (b->len == 0) {
                 bc_num_one(c);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
-        else if (a->len == 0) {
+        if (a->len == 0) {
                 bc_num_setToZero(c, scale);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
-        else if (BC_NUM_ONE(b)) {
+        if (BC_NUM_ONE(b)) {
                 if (!b->neg)
                         bc_num_copy(c, a);
                 else
                         s = zbc_num_inv(a, c, scale);
-                return s;
+                RETURN_STATUS(s);
         }
 
         neg = b->neg;
         b->neg = false;
 
         s = zbc_num_ulong(b, &pow);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         bc_num_init(&copy, a->len);
         bc_num_copy(&copy, a);
@@ -2195,10 +2262,13 @@ static FAST_FUNC BcStatus zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_
 
 err:
         bc_num_free(&copy);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_p(...) (zbc_num_p(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
+static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
                               BcNumBinaryOp op, size_t req)
 {
         BcStatus s;
@@ -2228,183 +2298,19 @@ static BcStatus zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
         else
                 bc_num_expand(c, req);
 
+#if !ERRORS_ARE_FATAL
         s = op(ptr_a, ptr_b, c, scale);
-
-        if (init) bc_num_free(&num2);
-
-        return s;
-}
-
-static void bc_num_printNewline(void)
-{
-        if (G.prog.nchars == G.prog.len - 1) {
-                bb_putchar('\\');
-                bb_putchar('\n');
-                G.prog.nchars = 0;
-        }
-}
-
-#if ENABLE_DC
-static FAST_FUNC void bc_num_printChar(size_t num, size_t width, bool radix)
-{
-        (void) radix;
-        bb_putchar((char) num);
-        G.prog.nchars += width;
-}
-#endif
-
-static FAST_FUNC void bc_num_printDigits(size_t num, size_t width, bool radix)
-{
-        size_t exp, pow;
-
-        bc_num_printNewline();
-        bb_putchar(radix ? '.' : ' ');
-        ++G.prog.nchars;
-
-        bc_num_printNewline();
-        for (exp = 0, pow = 1; exp < width - 1; ++exp, pow *= 10)
-                continue;
-
-        for (exp = 0; exp < width; pow /= 10, ++G.prog.nchars, ++exp) {
-                size_t dig;
-                bc_num_printNewline();
-                dig = num / pow;
-                num -= dig * pow;
-                bb_putchar(((char) dig) + '0');
-        }
-}
-
-static FAST_FUNC void bc_num_printHex(size_t num, size_t width, bool radix)
-{
-        if (radix) {
-                bc_num_printNewline();
-                bb_putchar('.');
-                G.prog.nchars += 1;
-        }
-
-        bc_num_printNewline();
-        bb_putchar(bb_hexdigits_upcase[num]);
-        G.prog.nchars += width;
-}
-
-static void bc_num_printDecimal(BcNum *n)
-{
-        size_t i, rdx = n->rdx - 1;
-
-        if (n->neg) bb_putchar('-');
-        G.prog.nchars += n->neg;
-
-        for (i = n->len - 1; i < n->len; --i)
-                bc_num_printHex((size_t) n->num[i], 1, i == rdx);
-}
-
-static BC_STATUS zbc_num_printNum(BcNum *n, BcNum *base, size_t width, BcNumDigitOp print)
-{
-        BcStatus s;
-        BcVec stack;
-        BcNum intp, fracp, digit, frac_len;
-        unsigned long dig, *ptr;
-        size_t i;
-        bool radix;
-
-        if (n->len == 0) {
-                print(0, width, false);
-                RETURN_STATUS(BC_STATUS_SUCCESS);
-        }
-
-        bc_vec_init(&stack, sizeof(long), NULL);
-        bc_num_init(&intp, n->len);
-        bc_num_init(&fracp, n->rdx);
-        bc_num_init(&digit, width);
-        bc_num_init(&frac_len, BC_NUM_INT(n));
-        bc_num_copy(&intp, n);
-        bc_num_one(&frac_len);
-
-        bc_num_truncate(&intp, intp.rdx);
-        s = zbc_num_sub(n, &intp, &fracp, 0);
-        if (s) goto err;
-
-        while (intp.len != 0) {
-                s = zbc_num_divmod(&intp, base, &intp, &digit, 0);
-                if (s) goto err;
-                s = zbc_num_ulong(&digit, &dig);
-                if (s) goto err;
-                bc_vec_push(&stack, &dig);
-        }
-
-        for (i = 0; i < stack.len; ++i) {
-                ptr = bc_vec_item_rev(&stack, i);
-                print(*ptr, width, false);
-        }
-
-        if (!n->rdx) goto err;
-
-        for (radix = true; frac_len.len <= n->rdx; radix = false) {
-                s = zbc_num_mul(&fracp, base, &fracp, n->rdx);
-                if (s) goto err;
-                s = zbc_num_ulong(&fracp, &dig);
-                if (s) goto err;
-                bc_num_ulong2num(&intp, dig);
-                s = zbc_num_sub(&fracp, &intp, &fracp, 0);
-                if (s) goto err;
-                print(dig, width, radix);
-                s = zbc_num_mul(&frac_len, base, &frac_len, 0);
-                if (s) goto err;
-        }
-
-err:
-        bc_num_free(&frac_len);
-        bc_num_free(&digit);
-        bc_num_free(&fracp);
-        bc_num_free(&intp);
-        bc_vec_free(&stack);
-        RETURN_STATUS(s);
-}
-#if ERRORS_ARE_FATAL
-# define zbc_num_printNum(...) (zbc_num_printNum(__VA_ARGS__), BC_STATUS_SUCCESS)
+#else
+        op(ptr_a, ptr_b, c, scale);
+        s = BC_STATUS_SUCCESS;
 #endif
 
-static BC_STATUS zbc_num_printBase(BcNum *n)
-{
-        BcStatus s;
-        size_t width, i;
-        BcNumDigitOp print;
-        bool neg = n->neg;
-
-        if (neg) {
-                bb_putchar('-');
-                G.prog.nchars++;
-        }
-
-        n->neg = false;
-
-        if (G.prog.ob_t <= BC_NUM_MAX_IBASE) {
-                width = 1;
-                print = bc_num_printHex;
-        }
-        else {
-                for (i = G.prog.ob_t - 1, width = 0; i != 0; i /= 10, ++width)
-                        continue;
-                print = bc_num_printDigits;
-        }
-
-        s = zbc_num_printNum(n, &G.prog.ob, width, print);
-        n->neg = neg;
+        if (init) bc_num_free(&num2);
 
         RETURN_STATUS(s);
 }
 #if ERRORS_ARE_FATAL
-# define zbc_num_printBase(...) (zbc_num_printBase(__VA_ARGS__), BC_STATUS_SUCCESS)
-#endif
-
-#if ENABLE_DC
-static BC_STATUS zbc_num_stream(BcNum *n, BcNum *base)
-{
-        RETURN_STATUS(zbc_num_printNum(n, base, 1, bc_num_printChar));
-}
-#if ERRORS_ARE_FATAL
-# define zbc_num_stream(...) (zbc_num_stream(__VA_ARGS__), BC_STATUS_SUCCESS)
-#endif
+# define zbc_num_binary(...) (zbc_num_binary(__VA_ARGS__), BC_STATUS_SUCCESS)
 #endif
 
 static bool bc_num_strValid(const char *val, size_t base)
@@ -2557,70 +2463,7 @@ static BC_STATUS zbc_num_parse(BcNum *n, const char *val, BcNum *base,
 # define zbc_num_parse(...) (zbc_num_parse(__VA_ARGS__), BC_STATUS_SUCCESS)
 #endif
 
-static BC_STATUS zbc_num_print(BcNum *n, bool newline)
-{
-        BcStatus s = BC_STATUS_SUCCESS;
-
-        bc_num_printNewline();
-
-        if (n->len == 0) {
-                bb_putchar('0');
-                ++G.prog.nchars;
-        }
-        else if (G.prog.ob_t == 10)
-                bc_num_printDecimal(n);
-        else
-                s = zbc_num_printBase(n);
-
-        if (newline) {
-                bb_putchar('\n');
-                G.prog.nchars = 0;
-        }
-
-        RETURN_STATUS(s);
-}
-#if ERRORS_ARE_FATAL
-# define zbc_num_print(...) (zbc_num_print(__VA_ARGS__), BC_STATUS_SUCCESS)
-#endif
-
-static FAST_FUNC BcStatus zbc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale)
-{
-        BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_a : zbc_num_s;
-        (void) scale;
-        return zbc_num_binary(a, b, c, false, op, BC_NUM_AREQ(a, b));
-}
-
-static FAST_FUNC BcStatus zbc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale)
-{
-        BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_s : zbc_num_a;
-        (void) scale;
-        return zbc_num_binary(a, b, c, true, op, BC_NUM_AREQ(a, b));
-}
-
-static FAST_FUNC BcStatus zbc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale)
-{
-        size_t req = BC_NUM_MREQ(a, b, scale);
-        return zbc_num_binary(a, b, c, scale, zbc_num_m, req);
-}
-
-static FAST_FUNC BcStatus zbc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale)
-{
-        size_t req = BC_NUM_MREQ(a, b, scale);
-        return zbc_num_binary(a, b, c, scale, zbc_num_d, req);
-}
-
-static FAST_FUNC BcStatus zbc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale)
-{
-        size_t req = BC_NUM_MREQ(a, b, scale);
-        return zbc_num_binary(a, b, c, scale, zbc_num_rem, req);
-}
-
-static FAST_FUNC BcStatus zbc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale)
-{
-        return zbc_num_binary(a, b, c, scale, zbc_num_p, a->len * b->len + 1);
-}
-
-static BcStatus zbc_num_sqrt(BcNum *a, BcNum *restrict b, size_t scale)
+static BC_STATUS zbc_num_sqrt(BcNum *a, BcNum *restrict b, size_t scale)
 {
         BcStatus s;
         BcNum num1, num2, half, f, fprime, *x0, *x1, *temp;
@@ -2632,14 +2475,14 @@ static BcStatus zbc_num_sqrt(BcNum *a, BcNum *restrict b, size_t scale)
 
         if (a->len == 0) {
                 bc_num_setToZero(b, scale);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
         else if (a->neg)
-                return bc_error("negative number");
+                RETURN_STATUS(bc_error("negative number"));
         else if (BC_NUM_ONE(a)) {
                 bc_num_one(b);
                 bc_num_extend(b, scale);
-                return BC_STATUS_SUCCESS;
+                RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         scale = BC_MAX(scale, a->rdx) + 1;
@@ -2719,10 +2562,13 @@ err:
         bc_num_free(&half);
         bc_num_free(&num2);
         bc_num_free(&num1);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_sqrt(...) (zbc_num_sqrt(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus zbc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d,
+static BC_STATUS zbc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d,
                               size_t scale)
 {
         BcStatus s;
@@ -2745,21 +2591,24 @@ static BcStatus zbc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d,
 
         if (init) bc_num_free(&num2);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_divmod(...) (zbc_num_divmod(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 #if ENABLE_DC
-static BcStatus zbc_num_modexp(BcNum *a, BcNum *b, BcNum *c, BcNum *restrict d)
+static BC_STATUS zbc_num_modexp(BcNum *a, BcNum *b, BcNum *c, BcNum *restrict d)
 {
         BcStatus s;
         BcNum base, exp, two, temp;
 
         if (c->len == 0)
-                return bc_error("divide by zero");
+                RETURN_STATUS(bc_error("divide by zero"));
         if (a->rdx || b->rdx || c->rdx)
-                return bc_error("non integer number");
+                RETURN_STATUS(bc_error("non integer number"));
         if (b->neg)
-                return bc_error("negative number");
+                RETURN_STATUS(bc_error("negative number"));
 
         bc_num_expand(d, c->len);
         bc_num_init(&base, c->len);
@@ -2798,8 +2647,11 @@ err:
         bc_num_free(&two);
         bc_num_free(&exp);
         bc_num_free(&base);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_num_modexp(...) (zbc_num_modexp(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 #endif // ENABLE_DC
 
 #if ENABLE_BC
@@ -5630,7 +5482,11 @@ static BcStatus bc_program_op(char inst)
         if (s) return s;
         bc_num_init_DEF_SIZE(&res.d.n);
 
-        s = zbc_program_ops[inst - BC_INST_POWER](n1, n2, &res.d.n, G.prog.scale);
+        s = BC_STATUS_SUCCESS;
+#if !ERRORS_ARE_FATAL
+        s =
+#endif
+        zbc_program_ops[inst - BC_INST_POWER](n1, n2, &res.d.n, G.prog.scale);
         if (s) goto err;
         bc_program_binOpRetire(&res);
 
@@ -5810,6 +5666,204 @@ static void bc_program_printString(const char *str)
         }
 }
 
+static void bc_num_printNewline(void)
+{
+        if (G.prog.nchars == G.prog.len - 1) {
+                bb_putchar('\\');
+                bb_putchar('\n');
+                G.prog.nchars = 0;
+        }
+}
+
+#if ENABLE_DC
+static FAST_FUNC void bc_num_printChar(size_t num, size_t width, bool radix)
+{
+        (void) radix;
+        bb_putchar((char) num);
+        G.prog.nchars += width;
+}
+#endif
+
+static FAST_FUNC void bc_num_printDigits(size_t num, size_t width, bool radix)
+{
+        size_t exp, pow;
+
+        bc_num_printNewline();
+        bb_putchar(radix ? '.' : ' ');
+        ++G.prog.nchars;
+
+        bc_num_printNewline();
+        for (exp = 0, pow = 1; exp < width - 1; ++exp, pow *= 10)
+                continue;
+
+        for (exp = 0; exp < width; pow /= 10, ++G.prog.nchars, ++exp) {
+                size_t dig;
+                bc_num_printNewline();
+                dig = num / pow;
+                num -= dig * pow;
+                bb_putchar(((char) dig) + '0');
+        }
+}
+
+static FAST_FUNC void bc_num_printHex(size_t num, size_t width, bool radix)
+{
+        if (radix) {
+                bc_num_printNewline();
+                bb_putchar('.');
+                G.prog.nchars += 1;
+        }
+
+        bc_num_printNewline();
+        bb_putchar(bb_hexdigits_upcase[num]);
+        G.prog.nchars += width;
+}
+
+static void bc_num_printDecimal(BcNum *n)
+{
+        size_t i, rdx = n->rdx - 1;
+
+        if (n->neg) bb_putchar('-');
+        G.prog.nchars += n->neg;
+
+        for (i = n->len - 1; i < n->len; --i)
+                bc_num_printHex((size_t) n->num[i], 1, i == rdx);
+}
+
+static BC_STATUS zbc_num_printNum(BcNum *n, BcNum *base, size_t width, BcNumDigitOp print)
+{
+        BcStatus s;
+        BcVec stack;
+        BcNum intp, fracp, digit, frac_len;
+        unsigned long dig, *ptr;
+        size_t i;
+        bool radix;
+
+        if (n->len == 0) {
+                print(0, width, false);
+                RETURN_STATUS(BC_STATUS_SUCCESS);
+        }
+
+        bc_vec_init(&stack, sizeof(long), NULL);
+        bc_num_init(&intp, n->len);
+        bc_num_init(&fracp, n->rdx);
+        bc_num_init(&digit, width);
+        bc_num_init(&frac_len, BC_NUM_INT(n));
+        bc_num_copy(&intp, n);
+        bc_num_one(&frac_len);
+
+        bc_num_truncate(&intp, intp.rdx);
+        s = zbc_num_sub(n, &intp, &fracp, 0);
+        if (s) goto err;
+
+        while (intp.len != 0) {
+                s = zbc_num_divmod(&intp, base, &intp, &digit, 0);
+                if (s) goto err;
+                s = zbc_num_ulong(&digit, &dig);
+                if (s) goto err;
+                bc_vec_push(&stack, &dig);
+        }
+
+        for (i = 0; i < stack.len; ++i) {
+                ptr = bc_vec_item_rev(&stack, i);
+                print(*ptr, width, false);
+        }
+
+        if (!n->rdx) goto err;
+
+        for (radix = true; frac_len.len <= n->rdx; radix = false) {
+                s = zbc_num_mul(&fracp, base, &fracp, n->rdx);
+                if (s) goto err;
+                s = zbc_num_ulong(&fracp, &dig);
+                if (s) goto err;
+                bc_num_ulong2num(&intp, dig);
+                s = zbc_num_sub(&fracp, &intp, &fracp, 0);
+                if (s) goto err;
+                print(dig, width, radix);
+                s = zbc_num_mul(&frac_len, base, &frac_len, 0);
+                if (s) goto err;
+        }
+
+err:
+        bc_num_free(&frac_len);
+        bc_num_free(&digit);
+        bc_num_free(&fracp);
+        bc_num_free(&intp);
+        bc_vec_free(&stack);
+        RETURN_STATUS(s);
+}
+#if ERRORS_ARE_FATAL
+# define zbc_num_printNum(...) (zbc_num_printNum(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
+
+static BC_STATUS zbc_num_printBase(BcNum *n)
+{
+        BcStatus s;
+        size_t width, i;
+        BcNumDigitOp print;
+        bool neg = n->neg;
+
+        if (neg) {
+                bb_putchar('-');
+                G.prog.nchars++;
+        }
+
+        n->neg = false;
+
+        if (G.prog.ob_t <= BC_NUM_MAX_IBASE) {
+                width = 1;
+                print = bc_num_printHex;
+        }
+        else {
+                for (i = G.prog.ob_t - 1, width = 0; i != 0; i /= 10, ++width)
+                        continue;
+                print = bc_num_printDigits;
+        }
+
+        s = zbc_num_printNum(n, &G.prog.ob, width, print);
+        n->neg = neg;
+
+        RETURN_STATUS(s);
+}
+#if ERRORS_ARE_FATAL
+# define zbc_num_printBase(...) (zbc_num_printBase(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
+
+#if ENABLE_DC
+static BC_STATUS zbc_num_stream(BcNum *n, BcNum *base)
+{
+        RETURN_STATUS(zbc_num_printNum(n, base, 1, bc_num_printChar));
+}
+#if ERRORS_ARE_FATAL
+# define zbc_num_stream(...) (zbc_num_stream(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
+#endif
+
+static BC_STATUS zbc_num_print(BcNum *n, bool newline)
+{
+        BcStatus s = BC_STATUS_SUCCESS;
+
+        bc_num_printNewline();
+
+        if (n->len == 0) {
+                bb_putchar('0');
+                ++G.prog.nchars;
+        }
+        else if (G.prog.ob_t == 10)
+                bc_num_printDecimal(n);
+        else
+                s = zbc_num_printBase(n);
+
+        if (newline) {
+                bb_putchar('\n');
+                G.prog.nchars = 0;
+        }
+
+        RETURN_STATUS(s);
+}
+#if ERRORS_ARE_FATAL
+# define zbc_num_print(...) (zbc_num_print(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
+
 static BC_STATUS zbc_program_print(char inst, size_t idx)
 {
         BcStatus s;
@@ -6022,7 +6076,7 @@ static BC_STATUS zbc_program_copyToVar(char *name, bool var)
 # define zbc_program_copyToVar(...) (zbc_program_copyToVar(__VA_ARGS__), BC_STATUS_SUCCESS)
 #endif
 
-static BcStatus bc_program_assign(char inst)
+static BC_STATUS zbc_program_assign(char inst)
 {
         BcStatus s;
         BcResult *left, *right, res;
@@ -6030,7 +6084,7 @@ static BcStatus bc_program_assign(char inst)
         bool assign = inst == BC_INST_ASSIGN, ib, sc;
 
         s = zbc_program_binOpPrep(&left, &l, &right, &r, assign);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         ib = left->t == BC_RESULT_IBASE;
         sc = left->t == BC_RESULT_SCALE;
@@ -6042,30 +6096,34 @@ static BcStatus bc_program_assign(char inst)
                 BcVec *v;
 
                 if (left->t != BC_RESULT_VAR)
-                        return bc_error_variable_is_wrong_type();
+                        RETURN_STATUS(bc_error_variable_is_wrong_type());
                 v = bc_program_search(left->d.id.name, true);
 
-                return zbc_program_assignStr(right, v, false);
+                RETURN_STATUS(zbc_program_assignStr(right, v, false));
         }
 #endif
 
         if (left->t == BC_RESULT_CONSTANT || left->t == BC_RESULT_TEMP)
-                return bc_error("bad assignment:"
+                RETURN_STATUS(("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_error("divide by zero");
+                RETURN_STATUS(bc_error("divide by zero"));
 
         if (assign)
                 bc_num_copy(l, r);
-        else
-                s = zbc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, G.prog.scale);
-
-        if (s) return s;
+        else {
+                s = BC_STATUS_SUCCESS;
+#if !ERRORS_ARE_FATAL
+                s =
+#endif
+                zbc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, G.prog.scale);
+        }
+        if (s) RETURN_STATUS(s);
 #else
         bc_num_copy(l, r);
 #endif
@@ -6083,8 +6141,7 @@ static BcStatus bc_program_assign(char inst)
                 unsigned long val, max;
 
                 s = zbc_num_ulong(l, &val);
-                if (s)
-                        return s;
+                if (s) RETURN_STATUS(s);
                 s = left->t - BC_RESULT_IBASE;
                 if (sc) {
                         max = BC_MAX_SCALE;
@@ -6092,13 +6149,13 @@ static BcStatus bc_program_assign(char inst)
                 }
                 else {
                         if (val < BC_NUM_MIN_BASE)
-                                return bc_error(msg[s]);
+                                RETURN_STATUS(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 bc_error(msg[s]);
+                        RETURN_STATUS(bc_error(msg[s]));
                 if (!sc)
                         bc_num_copy(ib ? &G.prog.ib : &G.prog.ob, l);
 
@@ -6110,8 +6167,11 @@ static BcStatus bc_program_assign(char inst)
         bc_num_copy(&res.d.n, l);
         bc_program_binOpRetire(&res);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_program_assign(...) (zbc_program_assign(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 #if !ENABLE_DC
 #define bc_program_pushVar(code, bgn, pop, copy) \
@@ -6232,7 +6292,8 @@ static BC_STATUS zbc_program_incdec(char inst)
                    BC_INST_ASSIGN_MINUS;
 
         bc_vec_push(&G.prog.results, &res);
-        bc_program_assign(inst);
+        s = zbc_program_assign(inst);
+        if (s) RETURN_STATUS(s);
 
         if (inst2 == BC_INST_INC_POST || inst2 == BC_INST_DEC_POST) {
                 bc_vec_pop(&G.prog.results);
@@ -6369,7 +6430,7 @@ static unsigned long bc_program_len(BcNum *n)
         return len;
 }
 
-static BcStatus bc_program_builtin(char inst)
+static BC_STATUS zbc_program_builtin(char inst)
 {
         BcStatus s;
         BcResult *opnd;
@@ -6378,15 +6439,15 @@ static BcStatus bc_program_builtin(char inst)
         bool len = inst == BC_INST_LENGTH;
 
         if (!BC_PROG_STACK(&G.prog.results, 1))
-                return bc_error_stack_has_too_few_elements();
+                RETURN_STATUS(bc_error_stack_has_too_few_elements());
         opnd = bc_vec_top(&G.prog.results);
 
         s = zbc_program_num(opnd, &num, false);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
 #if ENABLE_DC
         if (!BC_PROG_NUM(opnd, num) && !len)
-                return bc_error_variable_is_wrong_type();
+                RETURN_STATUS(bc_error_variable_is_wrong_type());
 #endif
 
         bc_num_init_DEF_SIZE(&res.d.n);
@@ -6399,7 +6460,6 @@ static BcStatus bc_program_builtin(char inst)
 #endif
 #if ENABLE_DC
         else if (len != 0 && !BC_PROG_NUM(opnd, num)) {
-
                 char **str;
                 size_t idx = opnd->t == BC_RESULT_STR ? opnd->d.id.idx : num->rdx;
 
@@ -6413,18 +6473,21 @@ static BcStatus bc_program_builtin(char inst)
 
         bc_program_retire(&res, BC_RESULT_TEMP);
 
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_program_builtin(...) (zbc_program_builtin(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 #if ENABLE_DC
-static BcStatus bc_program_divmod(void)
+static BC_STATUS zbc_program_divmod(void)
 {
         BcStatus s;
         BcResult *opd1, *opd2, res, res2;
         BcNum *n1, *n2 = NULL;
 
         s = zbc_program_binOpPrep(&opd1, &n1, &opd2, &n2, false);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         bc_num_init_DEF_SIZE(&res.d.n);
         bc_num_init(&res2.d.n, n2->len);
@@ -6436,42 +6499,45 @@ static BcStatus bc_program_divmod(void)
         res.t = BC_RESULT_TEMP;
         bc_vec_push(&G.prog.results, &res);
 
-        return s;
+        RETURN_STATUS(s);
 
 err:
         bc_num_free(&res2.d.n);
         bc_num_free(&res.d.n);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_program_divmod(...) (zbc_program_divmod(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
-static BcStatus bc_program_modexp(void)
+static BC_STATUS zbc_program_modexp(void)
 {
         BcStatus s;
         BcResult *r1, *r2, *r3, res;
         BcNum *n1, *n2, *n3;
 
         if (!BC_PROG_STACK(&G.prog.results, 3))
-                return bc_error_stack_has_too_few_elements();
+                RETURN_STATUS(bc_error_stack_has_too_few_elements());
         s = zbc_program_binOpPrep(&r2, &n2, &r3, &n3, false);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
 
         r1 = bc_vec_item_rev(&G.prog.results, 2);
         s = zbc_program_num(r1, &n1, false);
-        if (s) return s;
+        if (s) RETURN_STATUS(s);
         if (!BC_PROG_NUM(r1, n1))
-                return bc_error_variable_is_wrong_type();
+                RETURN_STATUS(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) {
 
                 if (r1->t == r2->t) {
                         s = zbc_program_num(r2, &n2, false);
-                        if (s) return s;
+                        if (s) RETURN_STATUS(s);
                 }
 
                 if (r1->t == r3->t) {
                         s = zbc_program_num(r3, &n3, false);
-                        if (s) return s;
+                        if (s) RETURN_STATUS(s);
                 }
         }
 
@@ -6482,12 +6548,15 @@ static BcStatus bc_program_modexp(void)
         bc_vec_pop(&G.prog.results);
         bc_program_binOpRetire(&res);
 
-        return s;
+        RETURN_STATUS(s);
 
 err:
         bc_num_free(&res.d.n);
-        return s;
+        RETURN_STATUS(s);
 }
+#if ERRORS_ARE_FATAL
+# define zbc_program_modexp(...) (zbc_program_modexp(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
 
 static void bc_program_stackLen(void)
 {
@@ -6857,7 +6926,7 @@ static BcStatus bc_program_exec(void)
                         case BC_INST_SCALE_FUNC:
                         case BC_INST_LENGTH:
                         case BC_INST_SQRT:
-                                s = bc_program_builtin(inst);
+                                s = zbc_program_builtin(inst);
                                 break;
                         case BC_INST_NUM:
                                 r.t = BC_RESULT_CONSTANT;
@@ -6912,14 +6981,14 @@ static BcStatus bc_program_exec(void)
                         case BC_INST_ASSIGN_MINUS:
 #endif
                         case BC_INST_ASSIGN:
-                                s = bc_program_assign(inst);
+                                s = zbc_program_assign(inst);
                                 break;
 #if ENABLE_DC
                         case BC_INST_MODEXP:
-                                s = bc_program_modexp();
+                                s = zbc_program_modexp();
                                 break;
                         case BC_INST_DIVMOD:
-                                s = bc_program_divmod();
+                                s = zbc_program_divmod();
                                 break;
                         case BC_INST_EXECUTE:
                         case BC_INST_EXEC_COND: