bc: move functions/macros around, no code changes

Order now is:
enums/structures/defines,
utility/common functions,
parsing,
execution,
main loop,
main()

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

1 files changed, 392 insertions, 384 deletions

diff --git a/miscutils/bc.c b/miscutils/bc.c
index 7d3b6b7ed..7a69a0816 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -877,82 +877,9 @@ struct globals {
 # define COMMA_SUCCESS    ,BC_STATUS_SUCCESS
 #endif
 
-#define STACK_HAS_MORE_THAN(s, n)          ((s)->len > ((size_t)(n)))
-#define STACK_HAS_EQUAL_OR_MORE_THAN(s, n) ((s)->len >= ((size_t)(n)))
-
-#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 BC_STATUS (*BcNumBinaryOp)(BcNum *, BcNum *, BcNum *, size_t) FAST_FUNC;
-
-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,
-};
-#define zbc_num_add(...) (zbc_num_add(__VA_ARGS__) COMMA_SUCCESS)
-#define zbc_num_sub(...) (zbc_num_sub(__VA_ARGS__) COMMA_SUCCESS)
-#define zbc_num_mul(...) (zbc_num_mul(__VA_ARGS__) COMMA_SUCCESS)
-#define zbc_num_div(...) (zbc_num_div(__VA_ARGS__) COMMA_SUCCESS)
-#define zbc_num_mod(...) (zbc_num_mod(__VA_ARGS__) COMMA_SUCCESS)
-#define zbc_num_pow(...) (zbc_num_pow(__VA_ARGS__) COMMA_SUCCESS)
+//
+// Utility routines
+//
 
 static void fflush_and_check(void)
 {
@@ -1324,102 +1251,6 @@ static size_t bc_map_find_exact(const BcVec *v, const void *ptr)
 }
 #endif
 
-static int bad_input_byte(char c)
-{
-        if ((c < ' ' && c != '\t' && c != '\r' && c != '\n') // also allow '\v' '\f'?
-         || c > 0x7e
-        ) {
-                bc_error_fmt("illegal character 0x%02x", c);
-                return 1;
-        }
-        return 0;
-}
-
-// Note: it _appends_ data from fp to vec.
-static void bc_read_line(BcVec *vec, FILE *fp)
-{
- again:
-        fflush_and_check();
-
-#if ENABLE_FEATURE_BC_SIGNALS
-        if (G_interrupt) { // ^C was pressed
- intr:
-                if (fp != stdin) {
-                        // ^C while running a script (bc SCRIPT): die.
-                        // We do not return to interactive prompt:
-                        // user might be running us from a shell,
-                        // and SCRIPT might be intended to terminate
-                        // (e.g. contain a "halt" stmt).
-                        // ^C dropping user into a bc prompt instead of
-                        // the shell would be unexpected.
-                        xfunc_die();
-                }
-                // ^C while interactive input
-                G_interrupt = 0;
-                // GNU bc says "interrupted execution."
-                // GNU dc says "Interrupt!"
-                fputs("\ninterrupted execution\n", stderr);
-        }
-
-# if ENABLE_FEATURE_EDITING
-        if (G_ttyin && fp == stdin) {
-                int n, i;
-#  define line_buf bb_common_bufsiz1
-                n = read_line_input(G.line_input_state, "", line_buf, COMMON_BUFSIZE);
-                if (n <= 0) { // read errors or EOF, or ^D, or ^C
-                        if (n == 0) // ^C
-                                goto intr;
-                        bc_vec_pushZeroByte(vec); // ^D or EOF (or error)
-                        return;
-                }
-                i = 0;
-                for (;;) {
-                        char c = line_buf[i++];
-                        if (!c) break;
-                        if (bad_input_byte(c)) goto again;
-                }
-                bc_vec_concat(vec, line_buf);
-#  undef line_buf
-        } else
-# endif
-#endif
-        {
-                int c;
-                bool bad_chars = 0;
-                size_t len = vec->len;
-
-                do {
-#if ENABLE_FEATURE_BC_SIGNALS
-                        if (G_interrupt) {
-                                // ^C was pressed: ignore entire line, get another one
-                                vec->len = len;
-                                goto intr;
-                        }
-#endif
-                        do c = fgetc(fp); while (c == '\0');
-                        if (c == EOF) {
-                                if (ferror(fp))
-                                        bb_perror_msg_and_die("input error");
-                                // Note: EOF does not append '\n'
-                                break;
-                        }
-                        bad_chars |= bad_input_byte(c);
-                        bc_vec_pushByte(vec, (char)c);
-                } while (c != '\n');
-
-                if (bad_chars) {
-                        // Bad chars on this line
-                        if (!G.prog.file) { // stdin
-                                // ignore entire line, get another one
-                                vec->len = len;
-                                goto again;
-                        }
-                        bb_perror_msg_and_die("file '%s' is not text", G.prog.file);
-                }
-                bc_vec_pushZeroByte(vec);
-        }
-}
-
 static void bc_num_setToZero(BcNum *n, size_t scale)
 {
         n->len = 0;
@@ -1569,6 +1400,20 @@ static ssize_t bc_num_compare(BcDig *restrict a, BcDig *restrict b, size_t len)
         }
 }
 
+#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_cmp(BcNum *a, BcNum *b)
 {
         size_t i, min, a_int, b_int, diff;
@@ -1705,6 +1550,99 @@ static BC_STATUS zbc_num_shift(BcNum *n, size_t places)
 }
 #define zbc_num_shift(...) (zbc_num_shift(__VA_ARGS__) COMMA_SUCCESS)
 
+typedef BC_STATUS (*BcNumBinaryOp)(BcNum *, BcNum *, BcNum *, size_t) FAST_FUNC;
+
+static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
+                              BcNumBinaryOp op, size_t req)
+{
+        BcStatus s;
+        BcNum num2, *ptr_a, *ptr_b;
+        bool init = false;
+
+        if (c == a) {
+                ptr_a = &num2;
+                memcpy(ptr_a, c, sizeof(BcNum));
+                init = true;
+        } else
+                ptr_a = a;
+
+        if (c == b) {
+                ptr_b = &num2;
+                if (c != a) {
+                        memcpy(ptr_b, c, sizeof(BcNum));
+                        init = true;
+                }
+        } else
+                ptr_b = b;
+
+        if (init)
+                bc_num_init(c, req);
+        else
+                bc_num_expand(c, req);
+
+        s = BC_STATUS_SUCCESS;
+        IF_ERROR_RETURN_POSSIBLE(s =) op(ptr_a, ptr_b, c, scale);
+
+        if (init) bc_num_free(&num2);
+
+        RETURN_STATUS(s);
+}
+#define zbc_num_binary(...) (zbc_num_binary(__VA_ARGS__) COMMA_SUCCESS)
+
+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,
+};
+#define zbc_num_add(...) (zbc_num_add(__VA_ARGS__) COMMA_SUCCESS)
+#define zbc_num_sub(...) (zbc_num_sub(__VA_ARGS__) COMMA_SUCCESS)
+#define zbc_num_mul(...) (zbc_num_mul(__VA_ARGS__) COMMA_SUCCESS)
+#define zbc_num_div(...) (zbc_num_div(__VA_ARGS__) COMMA_SUCCESS)
+#define zbc_num_mod(...) (zbc_num_mod(__VA_ARGS__) COMMA_SUCCESS)
+#define zbc_num_pow(...) (zbc_num_pow(__VA_ARGS__) COMMA_SUCCESS)
+
 static BC_STATUS zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
 {
         BcNum one;
@@ -2224,195 +2162,6 @@ static FAST_FUNC BC_STATUS zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size
 }
 #define zbc_num_p(...) (zbc_num_p(__VA_ARGS__) COMMA_SUCCESS)
 
-static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
-                              BcNumBinaryOp op, size_t req)
-{
-        BcStatus s;
-        BcNum num2, *ptr_a, *ptr_b;
-        bool init = false;
-
-        if (c == a) {
-                ptr_a = &num2;
-                memcpy(ptr_a, c, sizeof(BcNum));
-                init = true;
-        } else
-                ptr_a = a;
-
-        if (c == b) {
-                ptr_b = &num2;
-                if (c != a) {
-                        memcpy(ptr_b, c, sizeof(BcNum));
-                        init = true;
-                }
-        } else
-                ptr_b = b;
-
-        if (init)
-                bc_num_init(c, req);
-        else
-                bc_num_expand(c, req);
-
-        s = BC_STATUS_SUCCESS;
-        IF_ERROR_RETURN_POSSIBLE(s =) op(ptr_a, ptr_b, c, scale);
-
-        if (init) bc_num_free(&num2);
-
-        RETURN_STATUS(s);
-}
-#define zbc_num_binary(...) (zbc_num_binary(__VA_ARGS__) COMMA_SUCCESS)
-
-static bool bc_num_strValid(const char *val, size_t base)
-{
-        BcDig b;
-        bool radix;
-
-        b = (BcDig)(base <= 10 ? base + '0' : base - 10 + 'A');
-        radix = false;
-        for (;;) {
-                BcDig c = *val++;
-                if (c == '\0')
-                        break;
-                if (c == '.') {
-                        if (radix) return false;
-                        radix = true;
-                        continue;
-                }
-                if (c < '0' || c >= b || (c > '9' && c < 'A'))
-                        return false;
-        }
-        return true;
-}
-
-// Note: n is already "bc_num_zero()"ed,
-// leading zeroes in "val" are removed
-static void bc_num_parseDecimal(BcNum *n, const char *val)
-{
-        size_t len, i;
-        const char *ptr;
-
-        len = strlen(val);
-        if (len == 0)
-                return;
-
-        bc_num_expand(n, len);
-
-        ptr = strchr(val, '.');
-
-        n->rdx = 0;
-        if (ptr != NULL)
-                n->rdx = (size_t)((val + len) - (ptr + 1));
-
-        for (i = 0; val[i]; ++i) {
-                if (val[i] != '0' && val[i] != '.') {
-                        // Not entirely zero value - convert it, and exit
-                        i = len - 1;
-                        for (;;) {
-                                n->num[n->len] = val[i] - '0';
-                                ++n->len;
- skip_dot:
-                                if (i == 0) break;
-                                if (val[--i] == '.') goto skip_dot;
-                        }
-                        break;
-                }
-        }
-        // if for() exits without hitting if(), the value is entirely zero
-}
-
-// Note: n is already "bc_num_zero()"ed,
-// leading zeroes in "val" are removed
-static void bc_num_parseBase(BcNum *n, const char *val, unsigned base_t)
-{
-        BcStatus s;
-        BcNum temp, mult, result;
-        BcNum base;
-        BcDig base_digs[ULONG_NUM_BUFSIZE];
-        BcDig c = '\0';
-        unsigned long v;
-        size_t i, digits;
-
-        for (i = 0; ; ++i) {
-                if (val[i] == '\0')
-                        return;
-                if (val[i] != '.' && val[i] != '0')
-                        break;
-        }
-
-        bc_num_init_DEF_SIZE(&temp);
-        bc_num_init_DEF_SIZE(&mult);
-        base.cap = ARRAY_SIZE(base_digs);
-        base.num = base_digs;
-        bc_num_ulong2num(&base, base_t);
-
-        for (;;) {
-                c = *val++;
-                if (c == '\0') goto int_err;
-                if (c == '.') break;
-
-                v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
-
-                s = zbc_num_mul(n, &base, &mult, 0);
-                if (s) goto int_err;
-                bc_num_ulong2num(&temp, v);
-                s = zbc_num_add(&mult, &temp, n, 0);
-                if (s) goto int_err;
-        }
-
-        bc_num_init(&result, base.len);
-        //bc_num_zero(&result); - already is
-        bc_num_one(&mult);
-
-        digits = 0;
-        for (;;) {
-                c = *val++;
-                if (c == '\0') break;
-                digits++;
-
-                v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
-
-                s = zbc_num_mul(&result, &base, &result, 0);
-                if (s) goto err;
-                bc_num_ulong2num(&temp, v);
-                s = zbc_num_add(&result, &temp, &result, 0);
-                if (s) goto err;
-                s = zbc_num_mul(&mult, &base, &mult, 0);
-                if (s) goto err;
-        }
-
-        s = zbc_num_div(&result, &mult, &result, digits);
-        if (s) goto err;
-        s = zbc_num_add(n, &result, n, digits);
-        if (s) goto err;
-
-        if (n->len != 0) {
-                if (n->rdx < digits)
-                        bc_num_extend(n, digits - n->rdx);
-        } else
-                bc_num_zero(n);
- err:
-        bc_num_free(&result);
- int_err:
-        bc_num_free(&mult);
-        bc_num_free(&temp);
-}
-
-static BC_STATUS zbc_num_parse(BcNum *n, const char *val, unsigned base_t)
-{
-        if (!bc_num_strValid(val, base_t))
-                RETURN_STATUS(bc_error("bad number string"));
-
-        bc_num_zero(n);
-        while (*val == '0') val++;
-
-        if (base_t == 10)
-                bc_num_parseDecimal(n, val);
-        else
-                bc_num_parseBase(n, val, base_t);
-
-        RETURN_STATUS(BC_STATUS_SUCCESS);
-}
-#define zbc_num_parse(...) (zbc_num_parse(__VA_ARGS__) COMMA_SUCCESS)
-
 static BC_STATUS zbc_num_sqrt(BcNum *a, BcNum *restrict b, size_t scale)
 {
         BcStatus s;
@@ -2595,29 +2344,6 @@ static BC_STATUS zdc_num_modexp(BcNum *a, BcNum *b, BcNum *c, BcNum *restrict d)
 #define zdc_num_modexp(...) (zdc_num_modexp(__VA_ARGS__) COMMA_SUCCESS)
 #endif // ENABLE_DC
 
-#if ENABLE_BC
-static BC_STATUS zbc_func_insert(BcFunc *f, char *name, bool var)
-{
-        BcId *autoid;
-        BcId a;
-        size_t i;
-
-        autoid = (void*)f->autos.v;
-        for (i = 0; i < f->autos.len; i++, autoid++) {
-                if (strcmp(name, autoid->name) == 0)
-                        RETURN_STATUS(bc_error("function parameter or auto var has the same name as another"));
-        }
-
-        a.idx = var;
-        a.name = name;
-
-        bc_vec_push(&f->autos, &a);
-
-        RETURN_STATUS(BC_STATUS_SUCCESS);
-}
-#define zbc_func_insert(...) (zbc_func_insert(__VA_ARGS__) COMMA_SUCCESS)
-#endif
-
 static FAST_FUNC void bc_string_free(void *string)
 {
         free(*(char**)string);
@@ -2740,6 +2466,258 @@ static FAST_FUNC void bc_result_free(void *result)
         }
 }
 
+static int bad_input_byte(char c)
+{
+        if ((c < ' ' && c != '\t' && c != '\r' && c != '\n') // also allow '\v' '\f'?
+         || c > 0x7e
+        ) {
+                bc_error_fmt("illegal character 0x%02x", c);
+                return 1;
+        }
+        return 0;
+}
+
+// Note: it _appends_ data from fp to vec.
+static void bc_read_line(BcVec *vec, FILE *fp)
+{
+ again:
+        fflush_and_check();
+
+#if ENABLE_FEATURE_BC_SIGNALS
+        if (G_interrupt) { // ^C was pressed
+ intr:
+                if (fp != stdin) {
+                        // ^C while running a script (bc SCRIPT): die.
+                        // We do not return to interactive prompt:
+                        // user might be running us from a shell,
+                        // and SCRIPT might be intended to terminate
+                        // (e.g. contain a "halt" stmt).
+                        // ^C dropping user into a bc prompt instead of
+                        // the shell would be unexpected.
+                        xfunc_die();
+                }
+                // ^C while interactive input
+                G_interrupt = 0;
+                // GNU bc says "interrupted execution."
+                // GNU dc says "Interrupt!"
+                fputs("\ninterrupted execution\n", stderr);
+        }
+
+# if ENABLE_FEATURE_EDITING
+        if (G_ttyin && fp == stdin) {
+                int n, i;
+#  define line_buf bb_common_bufsiz1
+                n = read_line_input(G.line_input_state, "", line_buf, COMMON_BUFSIZE);
+                if (n <= 0) { // read errors or EOF, or ^D, or ^C
+                        if (n == 0) // ^C
+                                goto intr;
+                        bc_vec_pushZeroByte(vec); // ^D or EOF (or error)
+                        return;
+                }
+                i = 0;
+                for (;;) {
+                        char c = line_buf[i++];
+                        if (!c) break;
+                        if (bad_input_byte(c)) goto again;
+                }
+                bc_vec_concat(vec, line_buf);
+#  undef line_buf
+        } else
+# endif
+#endif
+        {
+                int c;
+                bool bad_chars = 0;
+                size_t len = vec->len;
+
+                do {
+#if ENABLE_FEATURE_BC_SIGNALS
+                        if (G_interrupt) {
+                                // ^C was pressed: ignore entire line, get another one
+                                vec->len = len;
+                                goto intr;
+                        }
+#endif
+                        do c = fgetc(fp); while (c == '\0');
+                        if (c == EOF) {
+                                if (ferror(fp))
+                                        bb_perror_msg_and_die("input error");
+                                // Note: EOF does not append '\n'
+                                break;
+                        }
+                        bad_chars |= bad_input_byte(c);
+                        bc_vec_pushByte(vec, (char)c);
+                } while (c != '\n');
+
+                if (bad_chars) {
+                        // Bad chars on this line
+                        if (!G.prog.file) { // stdin
+                                // ignore entire line, get another one
+                                vec->len = len;
+                                goto again;
+                        }
+                        bb_perror_msg_and_die("file '%s' is not text", G.prog.file);
+                }
+                bc_vec_pushZeroByte(vec);
+        }
+}
+
+//
+// Parsing routines
+//
+
+static bool bc_num_strValid(const char *val, size_t base)
+{
+        BcDig b;
+        bool radix;
+
+        b = (BcDig)(base <= 10 ? base + '0' : base - 10 + 'A');
+        radix = false;
+        for (;;) {
+                BcDig c = *val++;
+                if (c == '\0')
+                        break;
+                if (c == '.') {
+                        if (radix) return false;
+                        radix = true;
+                        continue;
+                }
+                if (c < '0' || c >= b || (c > '9' && c < 'A'))
+                        return false;
+        }
+        return true;
+}
+
+// Note: n is already "bc_num_zero()"ed,
+// leading zeroes in "val" are removed
+static void bc_num_parseDecimal(BcNum *n, const char *val)
+{
+        size_t len, i;
+        const char *ptr;
+
+        len = strlen(val);
+        if (len == 0)
+                return;
+
+        bc_num_expand(n, len);
+
+        ptr = strchr(val, '.');
+
+        n->rdx = 0;
+        if (ptr != NULL)
+                n->rdx = (size_t)((val + len) - (ptr + 1));
+
+        for (i = 0; val[i]; ++i) {
+                if (val[i] != '0' && val[i] != '.') {
+                        // Not entirely zero value - convert it, and exit
+                        i = len - 1;
+                        for (;;) {
+                                n->num[n->len] = val[i] - '0';
+                                ++n->len;
+ skip_dot:
+                                if (i == 0) break;
+                                if (val[--i] == '.') goto skip_dot;
+                        }
+                        break;
+                }
+        }
+        // if for() exits without hitting if(), the value is entirely zero
+}
+
+// Note: n is already "bc_num_zero()"ed,
+// leading zeroes in "val" are removed
+static void bc_num_parseBase(BcNum *n, const char *val, unsigned base_t)
+{
+        BcStatus s;
+        BcNum temp, mult, result;
+        BcNum base;
+        BcDig base_digs[ULONG_NUM_BUFSIZE];
+        BcDig c = '\0';
+        unsigned long v;
+        size_t i, digits;
+
+        for (i = 0; ; ++i) {
+                if (val[i] == '\0')
+                        return;
+                if (val[i] != '.' && val[i] != '0')
+                        break;
+        }
+
+        bc_num_init_DEF_SIZE(&temp);
+        bc_num_init_DEF_SIZE(&mult);
+        base.cap = ARRAY_SIZE(base_digs);
+        base.num = base_digs;
+        bc_num_ulong2num(&base, base_t);
+
+        for (;;) {
+                c = *val++;
+                if (c == '\0') goto int_err;
+                if (c == '.') break;
+
+                v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
+
+                s = zbc_num_mul(n, &base, &mult, 0);
+                if (s) goto int_err;
+                bc_num_ulong2num(&temp, v);
+                s = zbc_num_add(&mult, &temp, n, 0);
+                if (s) goto int_err;
+        }
+
+        bc_num_init(&result, base.len);
+        //bc_num_zero(&result); - already is
+        bc_num_one(&mult);
+
+        digits = 0;
+        for (;;) {
+                c = *val++;
+                if (c == '\0') break;
+                digits++;
+
+                v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
+
+                s = zbc_num_mul(&result, &base, &result, 0);
+                if (s) goto err;
+                bc_num_ulong2num(&temp, v);
+                s = zbc_num_add(&result, &temp, &result, 0);
+                if (s) goto err;
+                s = zbc_num_mul(&mult, &base, &mult, 0);
+                if (s) goto err;
+        }
+
+        s = zbc_num_div(&result, &mult, &result, digits);
+        if (s) goto err;
+        s = zbc_num_add(n, &result, n, digits);
+        if (s) goto err;
+
+        if (n->len != 0) {
+                if (n->rdx < digits)
+                        bc_num_extend(n, digits - n->rdx);
+        } else
+                bc_num_zero(n);
+ err:
+        bc_num_free(&result);
+ int_err:
+        bc_num_free(&mult);
+        bc_num_free(&temp);
+}
+
+static BC_STATUS zbc_num_parse(BcNum *n, const char *val, unsigned base_t)
+{
+        if (!bc_num_strValid(val, base_t))
+                RETURN_STATUS(bc_error("bad number string"));
+
+        bc_num_zero(n);
+        while (*val == '0') val++;
+
+        if (base_t == 10)
+                bc_num_parseDecimal(n, val);
+        else
+                bc_num_parseBase(n, val, base_t);
+
+        RETURN_STATUS(BC_STATUS_SUCCESS);
+}
+#define zbc_num_parse(...) (zbc_num_parse(__VA_ARGS__) COMMA_SUCCESS)
+
 static void bc_lex_lineComment(BcLex *l)
 {
         // Try: echo -n '#foo' | bc
@@ -4333,6 +4311,27 @@ static BC_STATUS zbc_parse_break_or_continue(BcParse *p, BcLexType type)
 }
 #define zbc_parse_break_or_continue(...) (zbc_parse_break_or_continue(__VA_ARGS__) COMMA_SUCCESS)
 
+static BC_STATUS zbc_func_insert(BcFunc *f, char *name, bool var)
+{
+        BcId *autoid;
+        BcId a;
+        size_t i;
+
+        autoid = (void*)f->autos.v;
+        for (i = 0; i < f->autos.len; i++, autoid++) {
+                if (strcmp(name, autoid->name) == 0)
+                        RETURN_STATUS(bc_error("function parameter or auto var has the same name as another"));
+        }
+
+        a.idx = var;
+        a.name = name;
+
+        bc_vec_push(&f->autos, &a);
+
+        RETURN_STATUS(BC_STATUS_SUCCESS);
+}
+#define zbc_func_insert(...) (zbc_func_insert(__VA_ARGS__) COMMA_SUCCESS)
+
 static BC_STATUS zbc_parse_funcdef(BcParse *p)
 {
         BcStatus s;
@@ -5010,6 +5009,13 @@ static BC_STATUS zdc_parse_exprs_until_eof(BcParse *p)
 
 #endif // ENABLE_DC
 
+//
+// Execution engine
+//
+
+#define STACK_HAS_MORE_THAN(s, n)          ((s)->len > ((size_t)(n)))
+#define STACK_HAS_EQUAL_OR_MORE_THAN(s, n) ((s)->len >= ((size_t)(n)))
+
 static BcVec* bc_program_search(char *id, bool var)
 {
         BcId e, *ptr;
@@ -5400,6 +5406,8 @@ static void bc_num_printDecimal(BcNum *n)
                 bc_num_printHex((size_t) n->num[i], 1, i == rdx);
 }
 
+typedef void (*BcNumDigitOp)(size_t, size_t, bool) FAST_FUNC;
+
 static BC_STATUS zbc_num_printNum(BcNum *n, unsigned base_t, size_t width, BcNumDigitOp print)
 {
         BcStatus s;