miscutils/bc.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   4  * Adapted from https://github.com/gavinhoward/bc
   5  * Original code copyright (c) 2018 Gavin D. Howard and contributors.
   6  */
   7 //config:config BC
   8 //config:       bool "bc (45 kb; 49 kb when combined with dc)"
   9 //config:       default y
  10 //config:       help
  11 //config:       bc is a command-line, arbitrary-precision calculator with a
  12 //config:       Turing-complete language. See the GNU bc manual
  13 //config:       (https://www.gnu.org/software/bc/manual/bc.html) and bc spec
  14 //config:       (http://pubs.opengroup.org/onlinepubs/9699919799/utilities/bc.html).
  15 //config:
  16 //config:       This bc has five differences to the GNU bc:
  17 //config:         1) The period (.) is a shortcut for "last", as in the BSD bc.
  18 //config:         2) Arrays are copied before being passed as arguments to
  19 //config:            functions. This behavior is required by the bc spec.
  20 //config:         3) Arrays can be passed to the builtin "length" function to get
  21 //config:            the number of elements in the array. This prints "1":
  22 //config:               a[0] = 0; length(a[])
  23 //config:         4) The precedence of the boolean "not" operator (!) is equal to
  24 //config:            that of the unary minus (-) negation operator. This still
  25 //config:            allows POSIX-compliant scripts to work while somewhat
  26 //config:            preserving expected behavior (versus C) and making parsing
  27 //config:            easier.
  28 //config:         5) "read()" accepts expressions, not only numeric literals.
  29 //config:
  30 //config:       Options:
  31 //config:         -i  --interactive  force interactive mode
  32 //config:         -q  --quiet        don't print version and copyright
  33 //config:         -s  --standard     error if any non-POSIX extensions are used
  34 //config:         -w  --warn         warn if any non-POSIX extensions are used
  35 //config:         -l  --mathlib      use predefined math routines:
  36 //config:               s(expr) sine in radians
  37 //config:               c(expr) cosine in radians
  38 //config:               a(expr) arctangent, returning radians
  39 //config:               l(expr) natural log
  40 //config:               e(expr) raises e to the power of expr
  41 //config:               j(n, x) Bessel function of integer order n of x
  42 //config:
  43 //config:config DC
  44 //config:       bool "dc (38 kb; 49 kb when combined with bc)"
  45 //config:       default y
  46 //config:       help
  47 //config:       dc is a reverse-polish notation command-line calculator which
  48 //config:       supports unlimited precision arithmetic. See the FreeBSD man page
  49 //config:       (https://www.unix.com/man-page/FreeBSD/1/dc/) and GNU dc manual
  50 //config:       (https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html).
  51 //config:
  52 //config:       This dc has a few differences from the two above:
  53 //config:         1) When printing a byte stream (command "P"), this dc follows what
  54 //config:            the FreeBSD dc does.
  55 //config:         2) Implements the GNU extensions for divmod ("~") and
  56 //config:            modular exponentiation ("|").
  57 //config:         3) Implements all FreeBSD extensions, except for "J" and "M".
  58 //config:         4) Like the FreeBSD dc, this dc supports extended registers.
  59 //config:            However, they are implemented differently. When it encounters
  60 //config:            whitespace where a register should be, it skips the whitespace.
  61 //config:            If the character following is not a lowercase letter, an error
  62 //config:            is issued. Otherwise, the register name is parsed by the
  63 //config:            following regex:
  64 //config:               [a-z][a-z0-9_]*
  65 //config:            This generally means that register names will be surrounded by
  66 //config:            whitespace. Examples:
  67 //config:               l idx s temp L index S temp2 < do_thing
  68 //config:            Also note that, like the FreeBSD dc, extended registers are not
  69 //config:            allowed unless the "-x" option is given.
  70 //config:
  71 //config:config FEATURE_DC_SMALL
  72 //config:       bool "Minimal dc implementation (4.2 kb), not using bc code base"
  73 //config:       depends on DC && !BC
  74 //config:       default n
  75 //config:
  76 //config:config FEATURE_DC_LIBM
  77 //config:       bool "Enable power and exp functions (requires libm)"
  78 //config:       default y
  79 //config:       depends on FEATURE_DC_SMALL
  80 //config:       help
  81 //config:       Enable power and exp functions.
  82 //config:       NOTE: This will require libm to be present for linking.
  83 //config:
  84 //config:config FEATURE_BC_SIGNALS
  85 //config:       bool "Interactive mode (+4kb)"
  86 //config:       default y
  87 //config:       depends on (BC || DC) && !FEATURE_DC_SMALL
  88 //config:       help
  89 //config:       Enable interactive mode: when started on a tty,
  90 //config:       ^C interrupts execution and returns to command line,
  91 //config:       errors also return to command line instead of exiting,
  92 //config:       line editing with history is available.
  93 //config:
  94 //config:       With this option off, input can still be taken from tty,
  95 //config:       but all errors are fatal, ^C is fatal,
  96 //config:       tty is treated exactly the same as any other
  97 //config:       standard input (IOW: no line editing).
  98 //config:
  99 //config:config FEATURE_BC_LONG_OPTIONS
 100 //config:       bool "Enable bc/dc long options"
 101 //config:       default y
 102 //config:       depends on (BC || DC) && !FEATURE_DC_SMALL
 103 //config:       help
 104 //config:       Enable long options for bc and dc.
 105
 106 //applet:IF_BC(APPLET(bc, BB_DIR_USR_BIN, BB_SUID_DROP))
 107 //applet:IF_DC(APPLET(dc, BB_DIR_USR_BIN, BB_SUID_DROP))
 108
 109 //kbuild:lib-$(CONFIG_BC) += bc.o
 110 //kbuild:lib-$(CONFIG_DC) += bc.o
 111
 112 //See www.gnu.org/software/bc/manual/bc.html
 113 //usage:#define bc_trivial_usage
 114 //usage:       "[-sqlw] FILE..."
 115 //usage:
 116 //usage:#define bc_full_usage "\n"
 117 //usage:     "\nArbitrary precision calculator"
 118 //usage:     "\n"
 119 ///////:     "\n        -i      Interactive" - has no effect for now
 120 //usage:     "\n        -q      Quiet"
 121 //usage:     "\n        -l      Load standard math library"
 122 //usage:     "\n        -s      Be POSIX compatible"
 123 //usage:     "\n        -w      Warn if extensions are used"
 124 ///////:     "\n        -v      Version"
 125 //usage:     "\n"
 126 //usage:     "\n$BC_LINE_LENGTH changes output width"
 127 //usage:
 128 //usage:#define bc_example_usage
 129 //usage:       "3 + 4.129\n"
 130 //usage:       "1903 - 2893\n"
 131 //usage:       "-129 * 213.28935\n"
 132 //usage:       "12 / -1932\n"
 133 //usage:       "12 % 12\n"
 134 //usage:       "34 ^ 189\n"
 135 //usage:       "scale = 13\n"
 136 //usage:       "ibase = 2\n"
 137 //usage:       "obase = A\n"
 138 //usage:
 139 //usage:#define dc_trivial_usage
 140 //usage:       IF_NOT_FEATURE_DC_SMALL("[-x] ")"[-eSCRIPT]... [-fFILE]... [FILE]..."
 141 //usage:
 142 //usage:#define dc_full_usage "\n"
 143 //usage:     "\nTiny RPN calculator. Operations:"
 144 //usage:     "\n+, -, *, /, %, ~, ^," IF_NOT_FEATURE_DC_SMALL(" |,")
 145 //usage:     "\np - print top of the stack without popping"
 146 //usage:     "\nf - print entire stack"
 147 //usage:     "\nk - pop the value and set the precision"
 148 //usage:     "\ni - pop the value and set input radix"
 149 //usage:     "\no - pop the value and set output radix"
 150 //usage:     "\nExamples: dc -e'2 2 + p' -> 4, dc -e'8 8 * 2 2 + / p' -> 16"
 151 //usage:
 152 //usage:#define dc_example_usage
 153 //usage:       "$ dc -e'2 2 + p'\n"
 154 //usage:       "4\n"
 155 //usage:       "$ dc -e'8 8 \\* 2 2 + / p'\n"
 156 //usage:       "16\n"
 157 //usage:       "$ dc -e'0 1 & p'\n"
 158 //usage:       "0\n"
 159 //usage:       "$ dc -e'0 1 | p'\n"
 160 //usage:       "1\n"
 161 //usage:       "$ echo '72 9 / 8 * p' | dc\n"
 162 //usage:       "64\n"
 163
 164 #include "libbb.h"
 165 #include "common_bufsiz.h"
 166
 167 #if ENABLE_FEATURE_DC_SMALL
 168 # include "dc.c"
 169 #else
 170
 171 #define DEBUG_LEXER   0
 172 #define DEBUG_COMPILE 0
 173 #define DEBUG_EXEC    0
 174 // This can be left enabled for production as well:
 175 #define SANITY_CHECKS 1
 176
 177 #if DEBUG_LEXER
 178 static uint8_t lex_indent;
 179 #define dbg_lex(...) \
 180         do { \
 181                 fprintf(stderr, "%*s", lex_indent, ""); \
 182                 bb_error_msg(__VA_ARGS__); \
 183         } while (0)
 184 #define dbg_lex_enter(...) \
 185         do { \
 186                 dbg_lex(__VA_ARGS__); \
 187                 lex_indent++; \
 188         } while (0)
 189 #define dbg_lex_done(...) \
 190         do { \
 191                 lex_indent--; \
 192                 dbg_lex(__VA_ARGS__); \
 193         } while (0)
 194 #else
 195 # define dbg_lex(...)       ((void)0)
 196 # define dbg_lex_enter(...) ((void)0)
 197 # define dbg_lex_done(...)  ((void)0)
 198 #endif
 199
 200 #if DEBUG_COMPILE
 201 # define dbg_compile(...) bb_error_msg(__VA_ARGS__)
 202 #else
 203 # define dbg_compile(...) ((void)0)
 204 #endif
 205
 206 #if DEBUG_EXEC
 207 # define dbg_exec(...) bb_error_msg(__VA_ARGS__)
 208 #else
 209 # define dbg_exec(...) ((void)0)
 210 #endif
 211
 212 typedef enum BcStatus {
 213         BC_STATUS_SUCCESS = 0,
 214         BC_STATUS_FAILURE = 1,
 215         BC_STATUS_PARSE_EMPTY_EXP = 2, // bc_parse_expr_empty_ok() uses this
 216 } BcStatus;
 217
 218 #define BC_VEC_INVALID_IDX ((size_t) -1)
 219 #define BC_VEC_START_CAP (1 << 5)
 220
 221 typedef void (*BcVecFree)(void *) FAST_FUNC;
 222
 223 typedef struct BcVec {
 224         char *v;
 225         size_t len;
 226         size_t cap;
 227         size_t size;
 228         BcVecFree dtor;
 229 } BcVec;
 230
 231 typedef signed char BcDig;
 232
 233 typedef struct BcNum {
 234         BcDig *restrict num;
 235         size_t rdx;
 236         size_t len;
 237         size_t cap;
 238         bool neg;
 239 } BcNum;
 240
 241 #define BC_NUM_MAX_IBASE        ((unsigned long) 16)
 242 // larger value might speed up BIGNUM calculations a bit:
 243 #define BC_NUM_DEF_SIZE         (16)
 244 #define BC_NUM_PRINT_WIDTH      (69)
 245
 246 #define BC_NUM_KARATSUBA_LEN    (32)
 247
 248 typedef enum BcInst {
 249 #if ENABLE_BC
 250         BC_INST_INC_PRE,
 251         BC_INST_DEC_PRE,
 252         BC_INST_INC_POST,
 253         BC_INST_DEC_POST,
 254 #endif
 255         XC_INST_NEG,            // order
 256
 257         XC_INST_REL_EQ,         // should
 258         XC_INST_REL_LE,         // match
 259         XC_INST_REL_GE,         // LEX
 260         XC_INST_REL_NE,         // constants
 261         XC_INST_REL_LT,         // for
 262         XC_INST_REL_GT,         // these
 263
 264         XC_INST_POWER,          // operations
 265         XC_INST_MULTIPLY,       // |
 266         XC_INST_DIVIDE,         // |
 267         XC_INST_MODULUS,        // |
 268         XC_INST_PLUS,           // |
 269         XC_INST_MINUS,          // |
 270
 271         XC_INST_BOOL_NOT,       // |
 272         XC_INST_BOOL_OR,        // |
 273         XC_INST_BOOL_AND,       // |
 274 #if ENABLE_BC
 275         BC_INST_ASSIGN_POWER,   // |
 276         BC_INST_ASSIGN_MULTIPLY,// |
 277         BC_INST_ASSIGN_DIVIDE,  // |
 278         BC_INST_ASSIGN_MODULUS, // |
 279         BC_INST_ASSIGN_PLUS,    // |
 280         BC_INST_ASSIGN_MINUS,   // |
 281 #endif
 282         XC_INST_ASSIGN,         // V
 283
 284         XC_INST_NUM,
 285         XC_INST_VAR,
 286         XC_INST_ARRAY_ELEM,
 287         XC_INST_ARRAY,
 288         XC_INST_SCALE_FUNC,
 289
 290         XC_INST_IBASE,       // order of these constans should match other enums
 291         XC_INST_OBASE,       // order of these constans should match other enums
 292         XC_INST_SCALE,       // order of these constans should match other enums
 293         IF_BC(BC_INST_LAST,) // order of these constans should match other enums
 294         XC_INST_LENGTH,
 295         XC_INST_READ,
 296         XC_INST_SQRT,
 297
 298         XC_INST_PRINT,
 299         XC_INST_PRINT_POP,
 300         XC_INST_STR,
 301         XC_INST_PRINT_STR,
 302
 303 #if ENABLE_BC
 304         BC_INST_HALT,
 305         BC_INST_JUMP,
 306         BC_INST_JUMP_ZERO,
 307
 308         BC_INST_CALL,
 309         BC_INST_RET0,
 310 #endif
 311         XC_INST_RET,
 312
 313         XC_INST_POP,
 314 #if ENABLE_DC
 315         DC_INST_POP_EXEC,
 316
 317         DC_INST_MODEXP,
 318         DC_INST_DIVMOD,
 319
 320         DC_INST_EXECUTE,
 321         DC_INST_EXEC_COND,
 322
 323         DC_INST_ASCIIFY,
 324         DC_INST_PRINT_STREAM,
 325
 326         DC_INST_PRINT_STACK,
 327         DC_INST_CLEAR_STACK,
 328         DC_INST_STACK_LEN,
 329         DC_INST_DUPLICATE,
 330         DC_INST_SWAP,
 331
 332         DC_INST_LOAD,
 333         DC_INST_PUSH_VAR,
 334         DC_INST_PUSH_TO_VAR,
 335
 336         DC_INST_QUIT,
 337         DC_INST_NQUIT,
 338
 339         DC_INST_INVALID = -1,
 340 #endif
 341 } BcInst;
 342
 343 typedef struct BcId {
 344         char *name;
 345         size_t idx;
 346 } BcId;
 347
 348 typedef struct BcFunc {
 349         BcVec code;
 350         IF_BC(BcVec labels;)
 351         IF_BC(BcVec autos;)
 352         IF_BC(BcVec strs;)
 353         IF_BC(BcVec consts;)
 354         IF_BC(size_t nparams;)
 355 } BcFunc;
 356
 357 typedef enum BcResultType {
 358         XC_RESULT_TEMP,
 359
 360         XC_RESULT_VAR,
 361         XC_RESULT_ARRAY_ELEM,
 362         XC_RESULT_ARRAY,
 363
 364         XC_RESULT_STR,
 365
 366         //code uses "inst - XC_INST_IBASE + XC_RESULT_IBASE" construct,
 367         XC_RESULT_IBASE,       // relative order should match for: XC_INST_IBASE
 368         XC_RESULT_OBASE,       // relative order should match for: XC_INST_OBASE
 369         XC_RESULT_SCALE,       // relative order should match for: XC_INST_SCALE
 370         IF_BC(BC_RESULT_LAST,) // relative order should match for: BC_INST_LAST
 371         XC_RESULT_CONSTANT,
 372         IF_BC(BC_RESULT_ONE,)
 373 } BcResultType;
 374
 375 typedef union BcResultData {
 376         BcNum n;
 377         BcVec v;
 378         BcId id;
 379 } BcResultData;
 380
 381 typedef struct BcResult {
 382         BcResultType t;
 383         BcResultData d;
 384 } BcResult;
 385
 386 typedef struct BcInstPtr {
 387         size_t func;
 388         size_t inst_idx;
 389         IF_BC(size_t results_len_before_call;)
 390 } BcInstPtr;
 391
 392 typedef enum BcLexType {
 393         XC_LEX_EOF,
 394         XC_LEX_INVALID,
 395
 396         XC_LEX_NLINE,
 397         XC_LEX_WHITESPACE,
 398         XC_LEX_STR,
 399         XC_LEX_NAME,
 400         XC_LEX_NUMBER,
 401
 402         XC_LEX_1st_op,
 403         XC_LEX_NEG = XC_LEX_1st_op,     // order
 404
 405         XC_LEX_OP_REL_EQ,               // should
 406         XC_LEX_OP_REL_LE,               // match
 407         XC_LEX_OP_REL_GE,               // INST
 408         XC_LEX_OP_REL_NE,               // constants
 409         XC_LEX_OP_REL_LT,               // for
 410         XC_LEX_OP_REL_GT,               // these
 411
 412         XC_LEX_OP_POWER,                // operations
 413         XC_LEX_OP_MULTIPLY,             // |
 414         XC_LEX_OP_DIVIDE,               // |
 415         XC_LEX_OP_MODULUS,              // |
 416         XC_LEX_OP_PLUS,                 // |
 417         XC_LEX_OP_MINUS,                // |
 418         XC_LEX_OP_last = XC_LEX_OP_MINUS,
 419 #if ENABLE_BC
 420         BC_LEX_OP_BOOL_NOT,             // |
 421         BC_LEX_OP_BOOL_OR,              // |
 422         BC_LEX_OP_BOOL_AND,             // |
 423
 424         BC_LEX_OP_ASSIGN_POWER,         // |
 425         BC_LEX_OP_ASSIGN_MULTIPLY,      // |
 426         BC_LEX_OP_ASSIGN_DIVIDE,        // |
 427         BC_LEX_OP_ASSIGN_MODULUS,       // |
 428         BC_LEX_OP_ASSIGN_PLUS,          // |
 429         BC_LEX_OP_ASSIGN_MINUS,         // |
 430
 431         BC_LEX_OP_ASSIGN,               // V
 432
 433         BC_LEX_OP_INC,
 434         BC_LEX_OP_DEC,
 435
 436         BC_LEX_LPAREN, // () are 0x28 and 0x29
 437         BC_LEX_RPAREN, // must be LPAREN+1: code uses (c - '(' + BC_LEX_LPAREN)
 438
 439         BC_LEX_LBRACKET, // [] are 0x5B and 5D
 440         BC_LEX_COMMA,
 441         BC_LEX_RBRACKET, // must be LBRACKET+2: code uses (c - '[' + BC_LEX_LBRACKET)
 442
 443         BC_LEX_LBRACE, // {} are 0x7B and 0x7D
 444         BC_LEX_SCOLON,
 445         BC_LEX_RBRACE, // must be LBRACE+2: code uses (c - '{' + BC_LEX_LBRACE)
 446
 447         BC_LEX_KEY_1st_keyword,
 448         BC_LEX_KEY_AUTO = BC_LEX_KEY_1st_keyword,
 449         BC_LEX_KEY_BREAK,
 450         BC_LEX_KEY_CONTINUE,
 451         BC_LEX_KEY_DEFINE,
 452         BC_LEX_KEY_ELSE,
 453         BC_LEX_KEY_FOR,
 454         BC_LEX_KEY_HALT,
 455         // code uses "type - BC_LEX_KEY_IBASE + XC_INST_IBASE" construct,
 456         BC_LEX_KEY_IBASE,       // relative order should match for: XC_INST_IBASE
 457         BC_LEX_KEY_OBASE,       // relative order should match for: XC_INST_OBASE
 458         BC_LEX_KEY_IF,
 459         IF_BC(BC_LEX_KEY_LAST,) // relative order should match for: BC_INST_LAST
 460         BC_LEX_KEY_LENGTH,
 461         BC_LEX_KEY_LIMITS,
 462         BC_LEX_KEY_PRINT,
 463         BC_LEX_KEY_QUIT,
 464         BC_LEX_KEY_READ,
 465         BC_LEX_KEY_RETURN,
 466         BC_LEX_KEY_SCALE,
 467         BC_LEX_KEY_SQRT,
 468         BC_LEX_KEY_WHILE,
 469 #endif // ENABLE_BC
 470
 471 #if ENABLE_DC
 472         DC_LEX_OP_BOOL_NOT = XC_LEX_OP_last + 1,
 473         DC_LEX_OP_ASSIGN,
 474
 475         DC_LEX_LPAREN,
 476         DC_LEX_SCOLON,
 477         DC_LEX_READ,
 478         DC_LEX_IBASE,
 479         DC_LEX_SCALE,
 480         DC_LEX_OBASE,
 481         DC_LEX_LENGTH,
 482         DC_LEX_PRINT,
 483         DC_LEX_QUIT,
 484         DC_LEX_SQRT,
 485         DC_LEX_LBRACE,
 486
 487         DC_LEX_EQ_NO_REG,
 488         DC_LEX_OP_MODEXP,
 489         DC_LEX_OP_DIVMOD,
 490
 491         DC_LEX_COLON,
 492         DC_LEX_ELSE,
 493         DC_LEX_EXECUTE,
 494         DC_LEX_PRINT_STACK,
 495         DC_LEX_CLEAR_STACK,
 496         DC_LEX_STACK_LEVEL,
 497         DC_LEX_DUPLICATE,
 498         DC_LEX_SWAP,
 499         DC_LEX_POP,
 500
 501         DC_LEX_ASCIIFY,
 502         DC_LEX_PRINT_STREAM,
 503
 504         // code uses "t - DC_LEX_STORE_IBASE + XC_INST_IBASE" construct,
 505         DC_LEX_STORE_IBASE,  // relative order should match for: XC_INST_IBASE
 506         DC_LEX_STORE_OBASE,  // relative order should match for: XC_INST_OBASE
 507         DC_LEX_STORE_SCALE,  // relative order should match for: XC_INST_SCALE
 508         DC_LEX_LOAD,
 509         DC_LEX_LOAD_POP,
 510         DC_LEX_STORE_PUSH,
 511         DC_LEX_PRINT_POP,
 512         DC_LEX_NQUIT,
 513         DC_LEX_SCALE_FACTOR,
 514 #endif
 515 } BcLexType;
 516 // must match order of BC_LEX_KEY_foo etc above
 517 #if ENABLE_BC
 518 struct BcLexKeyword {
 519         char name8[8];
 520 };
 521 #define BC_LEX_KW_ENTRY(a, b) \
 522         { .name8 = a /*, .posix = b */ }
 523 static const struct BcLexKeyword bc_lex_kws[20] = {
 524         BC_LEX_KW_ENTRY("auto"    , 1), // 0
 525         BC_LEX_KW_ENTRY("break"   , 1), // 1
 526         BC_LEX_KW_ENTRY("continue", 0), // 2 note: this one has no terminating NUL
 527         BC_LEX_KW_ENTRY("define"  , 1), // 3
 528         BC_LEX_KW_ENTRY("else"    , 0), // 4
 529         BC_LEX_KW_ENTRY("for"     , 1), // 5
 530         BC_LEX_KW_ENTRY("halt"    , 0), // 6
 531         BC_LEX_KW_ENTRY("ibase"   , 1), // 7
 532         BC_LEX_KW_ENTRY("obase"   , 1), // 8
 533         BC_LEX_KW_ENTRY("if"      , 1), // 9
 534         BC_LEX_KW_ENTRY("last"    , 0), // 10
 535         BC_LEX_KW_ENTRY("length"  , 1), // 11
 536         BC_LEX_KW_ENTRY("limits"  , 0), // 12
 537         BC_LEX_KW_ENTRY("print"   , 0), // 13
 538         BC_LEX_KW_ENTRY("quit"    , 1), // 14
 539         BC_LEX_KW_ENTRY("read"    , 0), // 15
 540         BC_LEX_KW_ENTRY("return"  , 1), // 16
 541         BC_LEX_KW_ENTRY("scale"   , 1), // 17
 542         BC_LEX_KW_ENTRY("sqrt"    , 1), // 18
 543         BC_LEX_KW_ENTRY("while"   , 1), // 19
 544 };
 545 #undef BC_LEX_KW_ENTRY
 546 #define STRING_else  (bc_lex_kws[4].name8)
 547 #define STRING_for   (bc_lex_kws[5].name8)
 548 #define STRING_if    (bc_lex_kws[9].name8)
 549 #define STRING_while (bc_lex_kws[19].name8)
 550 enum {
 551         POSIX_KWORD_MASK = 0
 552                 | (1 << 0)  // 0
 553                 | (1 << 1)  // 1
 554                 | (0 << 2)  // 2
 555                 | (1 << 3)  // 3
 556                 | (0 << 4)  // 4
 557                 | (1 << 5)  // 5
 558                 | (0 << 6)  // 6
 559                 | (1 << 7)  // 7
 560                 | (1 << 8)  // 8
 561                 | (1 << 9)  // 9
 562                 | (0 << 10) // 10
 563                 | (1 << 11) // 11
 564                 | (0 << 12) // 12
 565                 | (0 << 13) // 13
 566                 | (1 << 14) // 14
 567                 | (0 << 15) // 15
 568                 | (1 << 16) // 16
 569                 | (1 << 17) // 17
 570                 | (1 << 18) // 18
 571                 | (1 << 19) // 19
 572 };
 573 #define bc_lex_kws_POSIX(i) ((1 << (i)) & POSIX_KWORD_MASK)
 574
 575 // This is a bit array that corresponds to token types. An entry is
 576 // true if the token is valid in an expression, false otherwise.
 577 // Used to figure out when expr parsing should stop *without error message*
 578 // - 0 element indicates this condition. 1 means "this token is to be eaten
 579 // as part of the expression", it can then still be determined to be invalid
 580 // by later processing.
 581 enum {
 582 #define EXBITS(a,b,c,d,e,f,g,h) \
 583         ((uint64_t)((a << 0)+(b << 1)+(c << 2)+(d << 3)+(e << 4)+(f << 5)+(g << 6)+(h << 7)))
 584         BC_PARSE_EXPRS_BITS = 0              // corresponding BC_LEX_xyz:
 585         + (EXBITS(0,0,0,0,0,1,1,1) << (0*8)) //  0: EOF    INVAL  NL     WS     STR    NAME   NUM    -
 586         + (EXBITS(1,1,1,1,1,1,1,1) << (1*8)) //  8: ==     <=     >=     !=     <      >      ^      *
 587         + (EXBITS(1,1,1,1,1,1,1,1) << (2*8)) // 16: /      %      +      -      !      ||     &&     ^=
 588         + (EXBITS(1,1,1,1,1,1,1,1) << (3*8)) // 24: *=     /=     %=     +=     -=     =      ++     --
 589         + (EXBITS(1,1,0,0,0,0,0,0) << (4*8)) // 32: (      )      [      ,      ]      {      ;      }
 590         + (EXBITS(0,0,0,0,0,0,0,1) << (5*8)) // 40: auto   break  cont   define else   for    halt   ibase
 591         + (EXBITS(1,0,1,1,0,0,0,1) << (6*8)) // 48: obase  if     last   length limits print  quit   read
 592         + (EXBITS(0,1,1,0,0,0,0,0) << (7*8)) // 56: return scale  sqrt   while
 593 #undef EXBITS
 594 };
 595 static ALWAYS_INLINE long lex_allowed_in_bc_expr(unsigned i)
 596 {
 597 #if ULONG_MAX > 0xffffffff
 598         // 64-bit version (will not work correctly for 32-bit longs!)
 599         return BC_PARSE_EXPRS_BITS & (1UL << i);
 600 #else
 601         // 32-bit version
 602         unsigned long m = (uint32_t)BC_PARSE_EXPRS_BITS;
 603         if (i >= 32) {
 604                 m = (uint32_t)(BC_PARSE_EXPRS_BITS >> 32);
 605                 i &= 31;
 606         }
 607         return m & (1UL << i);
 608 #endif
 609 }
 610
 611 // This is an array of data for operators that correspond to
 612 // [XC_LEX_1st_op...] token types.
 613 static const uint8_t bc_parse_ops[] = {
 614 #define OP(p,l) ((int)(l) * 0x10 + (p))
 615         OP(1, false), // neg
 616         OP(6, true ), OP( 6, true  ), OP( 6, true  ), OP( 6, true  ), OP( 6, true  ), OP( 6, true ), // == <= >= != < >
 617         OP(2, false), // pow
 618         OP(3, true ), OP( 3, true  ), OP( 3, true  ), // mul div mod
 619         OP(4, true ), OP( 4, true  ), // + -
 620         OP(1, false), // not
 621         OP(7, true ), OP( 7, true  ), // or and
 622         OP(5, false), OP( 5, false ), OP( 5, false ), OP( 5, false ), OP( 5, false ), // ^= *= /= %= +=
 623         OP(5, false), OP( 5, false ), // -= =
 624         OP(0, false), OP( 0, false ), // inc dec
 625 #undef OP
 626 };
 627 #define bc_parse_op_PREC(i) (bc_parse_ops[i] & 0x0f)
 628 #define bc_parse_op_LEFT(i) (bc_parse_ops[i] & 0x10)
 629 #endif // ENABLE_BC
 630
 631 #if ENABLE_DC
 632 static const //BcLexType - should be this type
 633 uint8_t
 634 dc_char_to_LEX[] = {
 635         /* %&'( */
 636         XC_LEX_OP_MODULUS, XC_LEX_INVALID, XC_LEX_INVALID, DC_LEX_LPAREN,
 637         /* )*+, */
 638         XC_LEX_INVALID, XC_LEX_OP_MULTIPLY, XC_LEX_OP_PLUS, XC_LEX_INVALID,
 639         /* -./ */
 640         XC_LEX_OP_MINUS, XC_LEX_INVALID, XC_LEX_OP_DIVIDE,
 641         /* 0123456789 */
 642         XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
 643         XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
 644         XC_LEX_INVALID, XC_LEX_INVALID,
 645         /* :;<=>?@ */
 646         DC_LEX_COLON, DC_LEX_SCOLON, XC_LEX_OP_REL_GT, XC_LEX_OP_REL_EQ,
 647         XC_LEX_OP_REL_LT, DC_LEX_READ, XC_LEX_INVALID,
 648         /* ABCDEFGH */
 649         XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
 650         XC_LEX_INVALID, XC_LEX_INVALID, DC_LEX_EQ_NO_REG, XC_LEX_INVALID,
 651         /* IJKLMNOP */
 652         DC_LEX_IBASE, XC_LEX_INVALID, DC_LEX_SCALE, DC_LEX_LOAD_POP,
 653         XC_LEX_INVALID, DC_LEX_OP_BOOL_NOT, DC_LEX_OBASE, DC_LEX_PRINT_STREAM,
 654         /* QRSTUVWXY */
 655         DC_LEX_NQUIT, DC_LEX_POP, DC_LEX_STORE_PUSH, XC_LEX_INVALID, XC_LEX_INVALID,
 656         XC_LEX_INVALID, XC_LEX_INVALID, DC_LEX_SCALE_FACTOR, XC_LEX_INVALID,
 657         /* Z[\] */
 658         DC_LEX_LENGTH, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
 659         /* ^_` */
 660         XC_LEX_OP_POWER, XC_LEX_NEG, XC_LEX_INVALID,
 661         /* abcdefgh */
 662         DC_LEX_ASCIIFY, XC_LEX_INVALID, DC_LEX_CLEAR_STACK, DC_LEX_DUPLICATE,
 663         DC_LEX_ELSE, DC_LEX_PRINT_STACK, XC_LEX_INVALID, XC_LEX_INVALID,
 664         /* ijklmnop */
 665         DC_LEX_STORE_IBASE, XC_LEX_INVALID, DC_LEX_STORE_SCALE, DC_LEX_LOAD,
 666         XC_LEX_INVALID, DC_LEX_PRINT_POP, DC_LEX_STORE_OBASE, DC_LEX_PRINT,
 667         /* qrstuvwx */
 668         DC_LEX_QUIT, DC_LEX_SWAP, DC_LEX_OP_ASSIGN, XC_LEX_INVALID,
 669         XC_LEX_INVALID, DC_LEX_SQRT, XC_LEX_INVALID, DC_LEX_EXECUTE,
 670         /* yz */
 671         XC_LEX_INVALID, DC_LEX_STACK_LEVEL,
 672         /* {|}~ */
 673         DC_LEX_LBRACE, DC_LEX_OP_MODEXP, XC_LEX_INVALID, DC_LEX_OP_DIVMOD,
 674 };
 675 static const //BcInst - should be this type. Using signed narrow type since DC_INST_INVALID is -1
 676 int8_t
 677 dc_LEX_to_INST[] = { // starts at XC_LEX_OP_POWER       // corresponding XC/DC_LEX_xyz:
 678         XC_INST_POWER,       XC_INST_MULTIPLY,          // OP_POWER     OP_MULTIPLY
 679         XC_INST_DIVIDE,      XC_INST_MODULUS,           // OP_DIVIDE    OP_MODULUS
 680         XC_INST_PLUS,        XC_INST_MINUS,             // OP_PLUS      OP_MINUS
 681         XC_INST_BOOL_NOT,                               // DC_LEX_OP_BOOL_NOT
 682         DC_INST_INVALID,                                // DC_LEX_OP_ASSIGN
 683         XC_INST_REL_GT,                                 // DC_LEX_LPAREN
 684         DC_INST_INVALID,                                // DC_LEX_SCOLON
 685         DC_INST_INVALID,                                // DC_LEX_READ
 686         XC_INST_IBASE,                                  // DC_LEX_IBASE
 687         XC_INST_SCALE,                                  // DC_LEX_SCALE
 688         XC_INST_OBASE,                                  // DC_LEX_OBASE
 689         XC_INST_LENGTH,                                 // DC_LEX_LENGTH
 690         XC_INST_PRINT,                                  // DC_LEX_PRINT
 691         DC_INST_QUIT,                                   // DC_LEX_QUIT
 692         XC_INST_SQRT,                                   // DC_LEX_SQRT
 693         XC_INST_REL_GE,                                 // DC_LEX_LBRACE
 694         XC_INST_REL_EQ,                                 // DC_LEX_EQ_NO_REG
 695         DC_INST_MODEXP,      DC_INST_DIVMOD,            // OP_MODEXP    OP_DIVMOD
 696         DC_INST_INVALID,     DC_INST_INVALID,           // COLON        ELSE
 697         DC_INST_EXECUTE,                                // EXECUTE
 698         DC_INST_PRINT_STACK, DC_INST_CLEAR_STACK,       // PRINT_STACK  CLEAR_STACK
 699         DC_INST_STACK_LEN,   DC_INST_DUPLICATE,         // STACK_LEVEL  DUPLICATE
 700         DC_INST_SWAP,        XC_INST_POP,               // SWAP         POP
 701         DC_INST_ASCIIFY,     DC_INST_PRINT_STREAM,      // ASCIIFY      PRINT_STREAM
 702         DC_INST_INVALID,     DC_INST_INVALID,           // STORE_IBASE  STORE_OBASE
 703         DC_INST_INVALID,     DC_INST_INVALID,           // STORE_SCALE  LOAD
 704         DC_INST_INVALID,     DC_INST_INVALID,           // LOAD_POP     STORE_PUSH
 705         XC_INST_PRINT,       DC_INST_NQUIT,             // PRINT_POP    NQUIT
 706         XC_INST_SCALE_FUNC,                             // SCALE_FACTOR
 707         // DC_INST_INVALID in this table either means that corresponding LEX
 708         // is not possible for dc, or that it does not compile one-to-one
 709         // to a single INST.
 710 };
 711 #endif // ENABLE_DC
 712
 713 typedef struct BcLex {
 714         const char *buf;
 715         const char *lex_next_at; // last lex_next() was called at this string
 716         size_t i;
 717         size_t line;
 718         size_t len;
 719         bool   newline;
 720         smallint lex;      // was BcLexType
 721         smallint lex_last; // was BcLexType
 722         BcVec  lex_buf;
 723 } BcLex;
 724
 725 #define BC_PARSE_STREND         (0xff)
 726
 727 #if ENABLE_BC
 728 # define BC_PARSE_REL           (1 << 0)
 729 # define BC_PARSE_PRINT         (1 << 1)
 730 # define BC_PARSE_ARRAY         (1 << 2)
 731 # define BC_PARSE_NOCALL        (1 << 3)
 732 #endif
 733
 734 typedef struct BcParse {
 735         BcLex l;
 736
 737         IF_BC(BcVec exits;)
 738         IF_BC(BcVec conds;)
 739         IF_BC(BcVec ops;)
 740
 741         const char *filename;
 742         FILE *input_fp;
 743
 744         BcFunc *func;
 745         size_t fidx;
 746
 747         IF_BC(size_t in_funcdef;)
 748 } BcParse;
 749
 750 typedef struct BcProgram {
 751         size_t len;
 752         size_t nchars;
 753
 754         size_t scale;
 755         size_t ib_t;
 756         size_t ob_t;
 757
 758         BcVec results;
 759         BcVec exestack;
 760
 761         BcVec fns;
 762         IF_BC(BcVec fn_map;)
 763
 764         BcVec vars;
 765         BcVec var_map;
 766
 767         BcVec arrs;
 768         BcVec arr_map;
 769
 770         IF_DC(BcVec strs;)
 771         IF_DC(BcVec consts;)
 772
 773         BcNum zero;
 774         IF_BC(BcNum one;)
 775         IF_BC(BcNum last;)
 776 } BcProgram;
 777
 778 #define BC_PROG_MAIN (0)
 779 #define BC_PROG_READ (1)
 780 #if ENABLE_DC
 781 #define BC_PROG_REQ_FUNCS (2)
 782 #endif
 783
 784 #define BC_PROG_STR(n) (!(n)->num && !(n)->cap)
 785 #define BC_PROG_NUM(r, n) \
 786         ((r)->t != XC_RESULT_ARRAY && (r)->t != XC_RESULT_STR && !BC_PROG_STR(n))
 787
 788 #define BC_FLAG_W (1 << 0)
 789 #define BC_FLAG_V (1 << 1)
 790 #define BC_FLAG_S (1 << 2)
 791 #define BC_FLAG_Q (1 << 3)
 792 #define BC_FLAG_L (1 << 4)
 793 #define BC_FLAG_I (1 << 5)
 794 #define DC_FLAG_X (1 << 6)
 795
 796 #define BC_MAX(a, b) ((a) > (b) ? (a) : (b))
 797 #define BC_MIN(a, b) ((a) < (b) ? (a) : (b))
 798
 799 #define BC_MAX_OBASE    ((unsigned) 999)
 800 #define BC_MAX_DIM      ((unsigned) INT_MAX)
 801 #define BC_MAX_SCALE    ((unsigned) UINT_MAX)
 802 #define BC_MAX_STRING   ((unsigned) UINT_MAX - 1)
 803 #define BC_MAX_NUM      BC_MAX_STRING
 804 // Unused apart from "limits" message. Just show a "biggish number" there.
 805 //#define BC_MAX_NAME     BC_MAX_STRING
 806 //#define BC_MAX_EXP      ((unsigned long) LONG_MAX)
 807 //#define BC_MAX_VARS     ((unsigned long) SIZE_MAX - 1)
 808 #define BC_MAX_NAME_STR "999999999"
 809 #define BC_MAX_EXP_STR  "999999999"
 810 #define BC_MAX_VARS_STR "999999999"
 811
 812 #define BC_MAX_OBASE_STR "999"
 813
 814 #if INT_MAX == 2147483647
 815 # define BC_MAX_DIM_STR "2147483647"
 816 #elif INT_MAX == 9223372036854775807
 817 # define BC_MAX_DIM_STR "9223372036854775807"
 818 #else
 819 # error Strange INT_MAX
 820 #endif
 821
 822 #if UINT_MAX == 4294967295
 823 # define BC_MAX_SCALE_STR  "4294967295"
 824 # define BC_MAX_STRING_STR "4294967294"
 825 #elif UINT_MAX == 18446744073709551615
 826 # define BC_MAX_SCALE_STR  "18446744073709551615"
 827 # define BC_MAX_STRING_STR "18446744073709551614"
 828 #else
 829 # error Strange UINT_MAX
 830 #endif
 831 #define BC_MAX_NUM_STR BC_MAX_STRING_STR
 832
 833 struct globals {
 834         IF_FEATURE_BC_SIGNALS(smallint ttyin;)
 835         IF_FEATURE_CLEAN_UP(smallint exiting;)
 836
 837         BcParse prs;
 838         BcProgram prog;
 839
 840         // For error messages. Can be set to current parsed line,
 841         // or [TODO] to current executing line (can be before last parsed one)
 842         unsigned err_line;
 843
 844         BcVec files;
 845         BcVec input_buffer;
 846
 847         char *env_args;
 848
 849 #if ENABLE_FEATURE_EDITING
 850         line_input_t *line_input_state;
 851 #endif
 852 } FIX_ALIASING;
 853 #define G (*ptr_to_globals)
 854 #define INIT_G() do { \
 855         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 856 } while (0)
 857 #define FREE_G() do { \
 858         FREE_PTR_TO_GLOBALS(); \
 859 } while (0)
 860 #define G_posix (ENABLE_BC && (option_mask32 & BC_FLAG_S))
 861 #define G_warn  (ENABLE_BC && (option_mask32 & BC_FLAG_W))
 862 #define G_exreg (ENABLE_DC && (option_mask32 & DC_FLAG_X))
 863 #if ENABLE_FEATURE_BC_SIGNALS
 864 # define G_interrupt bb_got_signal
 865 # define G_ttyin     G.ttyin
 866 #else
 867 # define G_interrupt 0
 868 # define G_ttyin     0
 869 #endif
 870 #if ENABLE_FEATURE_CLEAN_UP
 871 # define G_exiting G.exiting
 872 #else
 873 # define G_exiting 0
 874 #endif
 875 #define IS_BC (ENABLE_BC && (!ENABLE_DC || applet_name[0] == 'b'))
 876 #define IS_DC (ENABLE_DC && (!ENABLE_BC || applet_name[0] != 'b'))
 877
 878 // In configurations where errors abort instead of propagating error
 879 // return code up the call chain, functions returning BC_STATUS
 880 // actually don't return anything, they always succeed and return "void".
 881 // A macro wrapper is provided, which makes this statement work:
 882 //  s = zbc_func(...)
 883 // and makes it visible to the compiler that s is always zero,
 884 // allowing compiler to optimize dead code after the statement.
 885 //
 886 // To make code more readable, each such function has a "z"
 887 // ("always returning zero") prefix, i.e. zbc_foo or zdc_foo.
 888 //
 889 #if ENABLE_FEATURE_BC_SIGNALS || ENABLE_FEATURE_CLEAN_UP
 890 # define ERRORS_ARE_FATAL 0
 891 # define ERRORFUNC        /*nothing*/
 892 # define IF_ERROR_RETURN_POSSIBLE(a)  a
 893 # define BC_STATUS        BcStatus
 894 # define RETURN_STATUS(v) return (v)
 895 # define COMMA_SUCCESS    /*nothing*/
 896 #else
 897 # define ERRORS_ARE_FATAL 1
 898 # define ERRORFUNC        NORETURN
 899 # define IF_ERROR_RETURN_POSSIBLE(a)  /*nothing*/
 900 # define BC_STATUS        void
 901 # define RETURN_STATUS(v) do { ((void)(v)); return; } while (0)
 902 # define COMMA_SUCCESS    ,BC_STATUS_SUCCESS
 903 #endif
 904
 905 //
 906 // Utility routines
 907 //
 908
 909 static void fflush_and_check(void)
 910 {
 911         fflush_all();
 912         if (ferror(stdout) || ferror(stderr))
 913                 bb_perror_msg_and_die("output error");
 914 }
 915
 916 #if ENABLE_FEATURE_CLEAN_UP
 917 #define QUIT_OR_RETURN_TO_MAIN \
 918 do { \
 919         IF_FEATURE_BC_SIGNALS(G_ttyin = 0;) /* do not loop in main loop anymore */ \
 920         G_exiting = 1; \
 921         return BC_STATUS_FAILURE; \
 922 } while (0)
 923 #else
 924 #define QUIT_OR_RETURN_TO_MAIN quit()
 925 #endif
 926
 927 static void quit(void) NORETURN;
 928 static void quit(void)
 929 {
 930         if (ferror(stdin))
 931                 bb_perror_msg_and_die("input error");
 932         fflush_and_check();
 933         dbg_exec("quit(): exiting with exitcode SUCCESS");
 934         exit(0);
 935 }
 936
 937 static void bc_verror_msg(const char *fmt, va_list p)
 938 {
 939         const char *sv = sv; // for compiler
 940         if (G.prs.filename) {
 941                 sv = applet_name;
 942                 applet_name = xasprintf("%s: %s:%u", applet_name, G.prs.filename, G.err_line);
 943         }
 944         bb_verror_msg(fmt, p, NULL);
 945         if (G.prs.filename) {
 946                 free((char*)applet_name);
 947                 applet_name = sv;
 948         }
 949 }
 950
 951 static NOINLINE ERRORFUNC int bc_error_fmt(const char *fmt, ...)
 952 {
 953         va_list p;
 954
 955         va_start(p, fmt);
 956         bc_verror_msg(fmt, p);
 957         va_end(p);
 958
 959         if (ENABLE_FEATURE_CLEAN_UP || G_ttyin)
 960                 IF_ERROR_RETURN_POSSIBLE(return BC_STATUS_FAILURE);
 961         exit(1);
 962 }
 963
 964 #if ENABLE_BC
 965 static NOINLINE BC_STATUS zbc_posix_error_fmt(const char *fmt, ...)
 966 {
 967         va_list p;
 968
 969         // Are non-POSIX constructs totally ok?
 970         if (!(option_mask32 & (BC_FLAG_S|BC_FLAG_W)))
 971                 RETURN_STATUS(BC_STATUS_SUCCESS); // yes
 972
 973         va_start(p, fmt);
 974         bc_verror_msg(fmt, p);
 975         va_end(p);
 976
 977         // Do we treat non-POSIX constructs as errors?
 978         if (!(option_mask32 & BC_FLAG_S))
 979                 RETURN_STATUS(BC_STATUS_SUCCESS); // no, it's a warning
 980
 981         if (ENABLE_FEATURE_CLEAN_UP || G_ttyin)
 982                 RETURN_STATUS(BC_STATUS_FAILURE);
 983         exit(1);
 984 }
 985 #define zbc_posix_error_fmt(...) (zbc_posix_error_fmt(__VA_ARGS__) COMMA_SUCCESS)
 986 #endif
 987
 988 // We use error functions with "return bc_error(FMT[, PARAMS])" idiom.
 989 // This idiom begs for tail-call optimization, but for it to work,
 990 // function must not have caller-cleaned parameters on stack.
 991 // Unfortunately, vararg function API does exactly that on most arches.
 992 // Thus, use these shims for the cases when we have no vararg PARAMS:
 993 static ERRORFUNC int bc_error(const char *msg)
 994 {
 995         IF_ERROR_RETURN_POSSIBLE(return) bc_error_fmt("%s", msg);
 996 }
 997 static ERRORFUNC int bc_error_bad_character(char c)
 998 {
 999         if (!c)
1000                 IF_ERROR_RETURN_POSSIBLE(return) bc_error("NUL character");
1001         IF_ERROR_RETURN_POSSIBLE(return) bc_error_fmt("bad character '%c'", c);
1002 }
1003 static ERRORFUNC int bc_error_bad_expression(void)
1004 {
1005         IF_ERROR_RETURN_POSSIBLE(return) bc_error("bad expression");
1006 }
1007 static ERRORFUNC int bc_error_bad_token(void)
1008 {
1009         IF_ERROR_RETURN_POSSIBLE(return) bc_error("bad token");
1010 }
1011 static ERRORFUNC int bc_error_stack_has_too_few_elements(void)
1012 {
1013         IF_ERROR_RETURN_POSSIBLE(return) bc_error("stack has too few elements");
1014 }
1015 static ERRORFUNC int bc_error_variable_is_wrong_type(void)
1016 {
1017         IF_ERROR_RETURN_POSSIBLE(return) bc_error("variable is wrong type");
1018 }
1019 #if ENABLE_BC
1020 static BC_STATUS zbc_POSIX_requires(const char *msg)
1021 {
1022         RETURN_STATUS(zbc_posix_error_fmt("POSIX requires %s", msg));
1023 }
1024 #define zbc_POSIX_requires(...) (zbc_POSIX_requires(__VA_ARGS__) COMMA_SUCCESS)
1025 static BC_STATUS zbc_POSIX_does_not_allow(const char *msg)
1026 {
1027         RETURN_STATUS(zbc_posix_error_fmt("%s%s", "POSIX does not allow ", msg));
1028 }
1029 #define zbc_POSIX_does_not_allow(...) (zbc_POSIX_does_not_allow(__VA_ARGS__) COMMA_SUCCESS)
1030 static BC_STATUS zbc_POSIX_does_not_allow_bool_ops_this_is_bad(const char *msg)
1031 {
1032         RETURN_STATUS(zbc_posix_error_fmt("%s%s %s", "POSIX does not allow ", "boolean operators; this is bad:", msg));
1033 }
1034 #define zbc_POSIX_does_not_allow_bool_ops_this_is_bad(...) (zbc_POSIX_does_not_allow_bool_ops_this_is_bad(__VA_ARGS__) COMMA_SUCCESS)
1035 static BC_STATUS zbc_POSIX_does_not_allow_empty_X_expression_in_for(const char *msg)
1036 {
1037         RETURN_STATUS(zbc_posix_error_fmt("%san empty %s expression in 'for()'", "POSIX does not allow ", msg));
1038 }
1039 #define zbc_POSIX_does_not_allow_empty_X_expression_in_for(...) (zbc_POSIX_does_not_allow_empty_X_expression_in_for(__VA_ARGS__) COMMA_SUCCESS)
1040 #endif
1041
1042 static void bc_vec_grow(BcVec *v, size_t n)
1043 {
1044         size_t cap = v->cap * 2;
1045         while (cap < v->len + n) cap *= 2;
1046         v->v = xrealloc(v->v, v->size * cap);
1047         v->cap = cap;
1048 }
1049
1050 static void bc_vec_init(BcVec *v, size_t esize, BcVecFree dtor)
1051 {
1052         v->size = esize;
1053         v->cap = BC_VEC_START_CAP;
1054         v->len = 0;
1055         v->dtor = dtor;
1056         v->v = xmalloc(esize * BC_VEC_START_CAP);
1057 }
1058
1059 static void bc_char_vec_init(BcVec *v)
1060 {
1061         bc_vec_init(v, sizeof(char), NULL);
1062 }
1063
1064 static void bc_vec_expand(BcVec *v, size_t req)
1065 {
1066         if (v->cap < req) {
1067                 v->v = xrealloc(v->v, v->size * req);
1068                 v->cap = req;
1069         }
1070 }
1071
1072 static void bc_vec_pop(BcVec *v)
1073 {
1074         v->len--;
1075         if (v->dtor)
1076                 v->dtor(v->v + (v->size * v->len));
1077 }
1078
1079 static void bc_vec_npop(BcVec *v, size_t n)
1080 {
1081         if (!v->dtor)
1082                 v->len -= n;
1083         else {
1084                 size_t len = v->len - n;
1085                 while (v->len > len) v->dtor(v->v + (v->size * --v->len));
1086         }
1087 }
1088
1089 static void bc_vec_pop_all(BcVec *v)
1090 {
1091         bc_vec_npop(v, v->len);
1092 }
1093
1094 static size_t bc_vec_push(BcVec *v, const void *data)
1095 {
1096         size_t len = v->len;
1097         if (len >= v->cap) bc_vec_grow(v, 1);
1098         memmove(v->v + (v->size * len), data, v->size);
1099         v->len++;
1100         return len;
1101 }
1102
1103 // G.prog.results often needs "pop old operand, push result" idiom.
1104 // Can do this without a few extra ops
1105 static size_t bc_result_pop_and_push(const void *data)
1106 {
1107         BcVec *v = &G.prog.results;
1108         char *last;
1109         size_t len = v->len - 1;
1110
1111         last = v->v + (v->size * len);
1112         if (v->dtor)
1113                 v->dtor(last);
1114         memmove(last, data, v->size);
1115         return len;
1116 }
1117
1118 static size_t bc_vec_pushByte(BcVec *v, char data)
1119 {
1120         return bc_vec_push(v, &data);
1121 }
1122
1123 static size_t bc_vec_pushZeroByte(BcVec *v)
1124 {
1125         //return bc_vec_pushByte(v, '\0');
1126         // better:
1127         return bc_vec_push(v, &const_int_0);
1128 }
1129
1130 static void bc_vec_pushAt(BcVec *v, const void *data, size_t idx)
1131 {
1132         if (idx == v->len)
1133                 bc_vec_push(v, data);
1134         else {
1135                 char *ptr;
1136
1137                 if (v->len == v->cap) bc_vec_grow(v, 1);
1138
1139                 ptr = v->v + v->size * idx;
1140
1141                 memmove(ptr + v->size, ptr, v->size * (v->len++ - idx));
1142                 memmove(ptr, data, v->size);
1143         }
1144 }
1145
1146 static void bc_vec_string(BcVec *v, size_t len, const char *str)
1147 {
1148         bc_vec_pop_all(v);
1149         bc_vec_expand(v, len + 1);
1150         memcpy(v->v, str, len);
1151         v->len = len;
1152
1153         bc_vec_pushZeroByte(v);
1154 }
1155
1156 #if ENABLE_FEATURE_BC_SIGNALS && ENABLE_FEATURE_EDITING
1157 static void bc_vec_concat(BcVec *v, const char *str)
1158 {
1159         size_t len, slen;
1160
1161         if (v->len == 0) bc_vec_pushZeroByte(v);
1162
1163         slen = strlen(str);
1164         len = v->len + slen;
1165
1166         if (v->cap < len) bc_vec_grow(v, slen);
1167         strcpy(v->v + v->len - 1, str);
1168
1169         v->len = len;
1170 }
1171 #endif
1172
1173 static void *bc_vec_item(const BcVec *v, size_t idx)
1174 {
1175         return v->v + v->size * idx;
1176 }
1177
1178 static void *bc_vec_item_rev(const BcVec *v, size_t idx)
1179 {
1180         return v->v + v->size * (v->len - idx - 1);
1181 }
1182
1183 static void *bc_vec_top(const BcVec *v)
1184 {
1185         return v->v + v->size * (v->len - 1);
1186 }
1187
1188 static FAST_FUNC void bc_vec_free(void *vec)
1189 {
1190         BcVec *v = (BcVec *) vec;
1191         bc_vec_pop_all(v);
1192         free(v->v);
1193 }
1194
1195 static BcFunc* bc_program_func(size_t idx)
1196 {
1197         return bc_vec_item(&G.prog.fns, idx);
1198 }
1199 // BC_PROG_MAIN is zeroth element, so:
1200 #define bc_program_func_BC_PROG_MAIN() ((BcFunc*)(G.prog.fns.v))
1201
1202 #if ENABLE_BC
1203 static BcFunc* bc_program_current_func(void)
1204 {
1205         BcInstPtr *ip = bc_vec_top(&G.prog.exestack);
1206         BcFunc *func = bc_program_func(ip->func);
1207         return func;
1208 }
1209 #endif
1210
1211 static char** bc_program_str(size_t idx)
1212 {
1213 #if ENABLE_BC
1214         if (IS_BC) {
1215                 BcFunc *func = bc_program_current_func();
1216                 return bc_vec_item(&func->strs, idx);
1217         }
1218 #endif
1219         IF_DC(return bc_vec_item(&G.prog.strs, idx);)
1220 }
1221
1222 static char** bc_program_const(size_t idx)
1223 {
1224 #if ENABLE_BC
1225         if (IS_BC) {
1226                 BcFunc *func = bc_program_current_func();
1227                 return bc_vec_item(&func->consts, idx);
1228         }
1229 #endif
1230         IF_DC(return bc_vec_item(&G.prog.consts, idx);)
1231 }
1232
1233 static int bc_id_cmp(const void *e1, const void *e2)
1234 {
1235         return strcmp(((const BcId *) e1)->name, ((const BcId *) e2)->name);
1236 }
1237
1238 static FAST_FUNC void bc_id_free(void *id)
1239 {
1240         free(((BcId *) id)->name);
1241 }
1242
1243 static size_t bc_map_find_ge(const BcVec *v, const void *ptr)
1244 {
1245         size_t low = 0, high = v->len;
1246
1247         while (low < high) {
1248                 size_t mid = (low + high) / 2;
1249                 BcId *id = bc_vec_item(v, mid);
1250                 int result = bc_id_cmp(ptr, id);
1251
1252                 if (result == 0)
1253                         return mid;
1254                 if (result < 0)
1255                         high = mid;
1256                 else
1257                         low = mid + 1;
1258         }
1259
1260         return low;
1261 }
1262
1263 static int bc_map_insert(BcVec *v, const void *ptr, size_t *i)
1264 {
1265         size_t n = *i = bc_map_find_ge(v, ptr);
1266
1267         if (n == v->len)
1268                 bc_vec_push(v, ptr);
1269         else if (!bc_id_cmp(ptr, bc_vec_item(v, n)))
1270                 return 0; // "was not inserted"
1271         else
1272                 bc_vec_pushAt(v, ptr, n);
1273         return 1; // "was inserted"
1274 }
1275
1276 #if ENABLE_BC
1277 static size_t bc_map_find_exact(const BcVec *v, const void *ptr)
1278 {
1279         size_t i = bc_map_find_ge(v, ptr);
1280         if (i >= v->len) return BC_VEC_INVALID_IDX;
1281         return bc_id_cmp(ptr, bc_vec_item(v, i)) ? BC_VEC_INVALID_IDX : i;
1282 }
1283 #endif
1284
1285 static void bc_num_setToZero(BcNum *n, size_t scale)
1286 {
1287         n->len = 0;
1288         n->neg = false;
1289         n->rdx = scale;
1290 }
1291
1292 static void bc_num_zero(BcNum *n)
1293 {
1294         bc_num_setToZero(n, 0);
1295 }
1296
1297 static void bc_num_one(BcNum *n)
1298 {
1299         bc_num_setToZero(n, 0);
1300         n->len = 1;
1301         n->num[0] = 1;
1302 }
1303
1304 // Note: this also sets BcNum to zero
1305 static void bc_num_init(BcNum *n, size_t req)
1306 {
1307         req = req >= BC_NUM_DEF_SIZE ? req : BC_NUM_DEF_SIZE;
1308         //memset(n, 0, sizeof(BcNum)); - cleared by assignments below
1309         n->num = xmalloc(req);
1310         n->cap = req;
1311         n->rdx = 0;
1312         n->len = 0;
1313         n->neg = false;
1314 }
1315
1316 static void bc_num_init_DEF_SIZE(BcNum *n)
1317 {
1318         bc_num_init(n, BC_NUM_DEF_SIZE);
1319 }
1320
1321 static void bc_num_expand(BcNum *n, size_t req)
1322 {
1323         req = req >= BC_NUM_DEF_SIZE ? req : BC_NUM_DEF_SIZE;
1324         if (req > n->cap) {
1325                 n->num = xrealloc(n->num, req);
1326                 n->cap = req;
1327         }
1328 }
1329
1330 static FAST_FUNC void bc_num_free(void *num)
1331 {
1332         free(((BcNum *) num)->num);
1333 }
1334
1335 static void bc_num_copy(BcNum *d, BcNum *s)
1336 {
1337         if (d != s) {
1338                 bc_num_expand(d, s->cap);
1339                 d->len = s->len;
1340                 d->neg = s->neg;
1341                 d->rdx = s->rdx;
1342                 memcpy(d->num, s->num, sizeof(BcDig) * d->len);
1343         }
1344 }
1345
1346 static BC_STATUS zbc_num_ulong_abs(BcNum *n, unsigned long *result_p)
1347 {
1348         size_t i;
1349         unsigned long result;
1350
1351         result = 0;
1352         i = n->len;
1353         while (i > n->rdx) {
1354                 unsigned long prev = result;
1355                 result = result * 10 + n->num[--i];
1356                 // Even overflowed N*10 can still satisfy N*10>=N. For example,
1357                 //    0x1ff00000 * 10 is 0x13f600000,
1358                 // or 0x3f600000 truncated to 32 bits. Which is larger.
1359                 // However, (N*10)/8 < N check is always correct.
1360                 if ((result / 8) < prev)
1361                         RETURN_STATUS(bc_error("overflow"));
1362         }
1363         *result_p = result;
1364
1365         RETURN_STATUS(BC_STATUS_SUCCESS);
1366 }
1367 #define zbc_num_ulong_abs(...) (zbc_num_ulong_abs(__VA_ARGS__) COMMA_SUCCESS)
1368
1369 static BC_STATUS zbc_num_ulong(BcNum *n, unsigned long *result_p)
1370 {
1371         if (n->neg) RETURN_STATUS(bc_error("negative number"));
1372
1373         RETURN_STATUS(zbc_num_ulong_abs(n, result_p));
1374 }
1375 #define zbc_num_ulong(...) (zbc_num_ulong(__VA_ARGS__) COMMA_SUCCESS)
1376
1377 #if ULONG_MAX == 0xffffffffUL // 10 digits: 4294967295
1378 # define ULONG_NUM_BUFSIZE (10 > BC_NUM_DEF_SIZE ? 10 : BC_NUM_DEF_SIZE)
1379 #elif ULONG_MAX == 0xffffffffffffffffULL // 20 digits: 18446744073709551615
1380 # define ULONG_NUM_BUFSIZE (20 > BC_NUM_DEF_SIZE ? 20 : BC_NUM_DEF_SIZE)
1381 #endif
1382 // minimum BC_NUM_DEF_SIZE, so that bc_num_expand() in bc_num_ulong2num()
1383 // would not hit realloc() code path - not good if num[] is not malloced
1384
1385 static void bc_num_ulong2num(BcNum *n, unsigned long val)
1386 {
1387         BcDig *ptr;
1388
1389         bc_num_zero(n);
1390
1391         if (val == 0) return;
1392
1393         bc_num_expand(n, ULONG_NUM_BUFSIZE);
1394
1395         ptr = n->num;
1396         for (;;) {
1397                 n->len++;
1398                 *ptr++ = val % 10;
1399                 val /= 10;
1400                 if (val == 0) break;
1401         }
1402 }
1403
1404 static void bc_num_subArrays(BcDig *restrict a, BcDig *restrict b, size_t len)
1405 {
1406         size_t i, j;
1407         for (i = 0; i < len; ++i) {
1408                 a[i] -= b[i];
1409                 for (j = i; a[j] < 0;) {
1410                         a[j++] += 10;
1411                         a[j] -= 1;
1412                 }
1413         }
1414 }
1415
1416 static ssize_t bc_num_compare(BcDig *restrict a, BcDig *restrict b, size_t len)
1417 {
1418         size_t i = len;
1419         for (;;) {
1420                 int c;
1421                 if (i == 0)
1422                         return 0;
1423                 i--;
1424                 c = a[i] - b[i];
1425                 if (c != 0) {
1426                         i++;
1427                         if (c < 0)
1428                                 return -i;
1429                         return i;
1430                 }
1431         }
1432 }
1433
1434 #define BC_NUM_NEG(n, neg)      ((((ssize_t)(n)) ^ -((ssize_t)(neg))) + (neg))
1435 #define BC_NUM_ONE(n)           ((n)->len == 1 && (n)->rdx == 0 && (n)->num[0] == 1)
1436 #define BC_NUM_INT(n)           ((n)->len - (n)->rdx)
1437 //#define BC_NUM_AREQ(a, b)       (BC_MAX((a)->rdx, (b)->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1)
1438 static /*ALWAYS_INLINE*/ size_t BC_NUM_AREQ(BcNum *a, BcNum *b)
1439 {
1440         return BC_MAX(a->rdx, b->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1;
1441 }
1442 //#define BC_NUM_MREQ(a, b, scale) (BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX((scale), (a)->rdx + (b)->rdx) + 1)
1443 static /*ALWAYS_INLINE*/ size_t BC_NUM_MREQ(BcNum *a, BcNum *b, size_t scale)
1444 {
1445         return BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX(scale, a->rdx + b->rdx) + 1;
1446 }
1447
1448 static ssize_t bc_num_cmp(BcNum *a, BcNum *b)
1449 {
1450         size_t i, min, a_int, b_int, diff;
1451         BcDig *max_num, *min_num;
1452         bool a_max, neg;
1453         ssize_t cmp;
1454
1455         if (a == b) return 0;
1456         if (a->len == 0) return BC_NUM_NEG(!!b->len, !b->neg);
1457         if (b->len == 0) return BC_NUM_NEG(1, a->neg);
1458
1459         if (a->neg != b->neg) // signs of a and b differ
1460                 // +a,-b = a>b = 1 or -a,+b = a<b = -1
1461                 return (int)b->neg - (int)a->neg;
1462         neg = a->neg; // 1 if both negative, 0 if both positive
1463
1464         a_int = BC_NUM_INT(a);
1465         b_int = BC_NUM_INT(b);
1466         a_int -= b_int;
1467
1468         if (a_int != 0) return (ssize_t) a_int;
1469
1470         a_max = (a->rdx > b->rdx);
1471         if (a_max) {
1472                 min = b->rdx;
1473                 diff = a->rdx - b->rdx;
1474                 max_num = a->num + diff;
1475                 min_num = b->num;
1476                 // neg = (a_max == neg); - NOP (maps 1->1 and 0->0)
1477         } else {
1478                 min = a->rdx;
1479                 diff = b->rdx - a->rdx;
1480                 max_num = b->num + diff;
1481                 min_num = a->num;
1482                 neg = !neg; // same as "neg = (a_max == neg)"
1483         }
1484
1485         cmp = bc_num_compare(max_num, min_num, b_int + min);
1486         if (cmp != 0) return BC_NUM_NEG(cmp, neg);
1487
1488         for (max_num -= diff, i = diff - 1; i < diff; --i) {
1489                 if (max_num[i]) return BC_NUM_NEG(1, neg);
1490         }
1491
1492         return 0;
1493 }
1494
1495 static void bc_num_truncate(BcNum *n, size_t places)
1496 {
1497         if (places == 0) return;
1498
1499         n->rdx -= places;
1500
1501         if (n->len != 0) {
1502                 n->len -= places;
1503                 memmove(n->num, n->num + places, n->len * sizeof(BcDig));
1504         }
1505 }
1506
1507 static void bc_num_extend(BcNum *n, size_t places)
1508 {
1509         size_t len = n->len + places;
1510
1511         if (places != 0) {
1512                 if (n->cap < len) bc_num_expand(n, len);
1513
1514                 memmove(n->num + places, n->num, sizeof(BcDig) * n->len);
1515                 memset(n->num, 0, sizeof(BcDig) * places);
1516
1517                 n->len += places;
1518                 n->rdx += places;
1519         }
1520 }
1521
1522 static void bc_num_clean(BcNum *n)
1523 {
1524         while (n->len > 0 && n->num[n->len - 1] == 0) --n->len;
1525         if (n->len == 0)
1526                 n->neg = false;
1527         else if (n->len < n->rdx)
1528                 n->len = n->rdx;
1529 }
1530
1531 static void bc_num_retireMul(BcNum *n, size_t scale, bool neg1, bool neg2)
1532 {
1533         if (n->rdx < scale)
1534                 bc_num_extend(n, scale - n->rdx);
1535         else
1536                 bc_num_truncate(n, n->rdx - scale);
1537
1538         bc_num_clean(n);
1539         if (n->len != 0) n->neg = !neg1 != !neg2;
1540 }
1541
1542 static void bc_num_split(BcNum *restrict n, size_t idx, BcNum *restrict a,
1543                          BcNum *restrict b)
1544 {
1545         if (idx < n->len) {
1546                 b->len = n->len - idx;
1547                 a->len = idx;
1548                 a->rdx = b->rdx = 0;
1549
1550                 memcpy(b->num, n->num + idx, b->len * sizeof(BcDig));
1551                 memcpy(a->num, n->num, idx * sizeof(BcDig));
1552         } else {
1553                 bc_num_zero(b);
1554                 bc_num_copy(a, n);
1555         }
1556
1557         bc_num_clean(a);
1558         bc_num_clean(b);
1559 }
1560
1561 static BC_STATUS zbc_num_shift(BcNum *n, size_t places)
1562 {
1563         if (places == 0 || n->len == 0) RETURN_STATUS(BC_STATUS_SUCCESS);
1564
1565         // This check makes sense only if size_t is (much) larger than BC_MAX_NUM.
1566         if (SIZE_MAX > (BC_MAX_NUM | 0xff)) {
1567                 if (places + n->len > BC_MAX_NUM)
1568                         RETURN_STATUS(bc_error("number too long: must be [1,"BC_MAX_NUM_STR"]"));
1569         }
1570
1571         if (n->rdx >= places)
1572                 n->rdx -= places;
1573         else {
1574                 bc_num_extend(n, places - n->rdx);
1575                 n->rdx = 0;
1576         }
1577
1578         bc_num_clean(n);
1579
1580         RETURN_STATUS(BC_STATUS_SUCCESS);
1581 }
1582 #define zbc_num_shift(...) (zbc_num_shift(__VA_ARGS__) COMMA_SUCCESS)
1583
1584 typedef BC_STATUS (*BcNumBinaryOp)(BcNum *, BcNum *, BcNum *, size_t) FAST_FUNC;
1585
1586 static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
1587                               BcNumBinaryOp op, size_t req)
1588 {
1589         BcStatus s;
1590         BcNum num2, *ptr_a, *ptr_b;
1591         bool init = false;
1592
1593         if (c == a) {
1594                 ptr_a = &num2;
1595                 memcpy(ptr_a, c, sizeof(BcNum));
1596                 init = true;
1597         } else
1598                 ptr_a = a;
1599
1600         if (c == b) {
1601                 ptr_b = &num2;
1602                 if (c != a) {
1603                         memcpy(ptr_b, c, sizeof(BcNum));
1604                         init = true;
1605                 }
1606         } else
1607                 ptr_b = b;
1608
1609         if (init)
1610                 bc_num_init(c, req);
1611         else
1612                 bc_num_expand(c, req);
1613
1614         s = BC_STATUS_SUCCESS;
1615         IF_ERROR_RETURN_POSSIBLE(s =) op(ptr_a, ptr_b, c, scale);
1616
1617         if (init) bc_num_free(&num2);
1618
1619         RETURN_STATUS(s);
1620 }
1621 #define zbc_num_binary(...) (zbc_num_binary(__VA_ARGS__) COMMA_SUCCESS)
1622
1623 static FAST_FUNC BC_STATUS zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
1624 static FAST_FUNC BC_STATUS zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
1625 static FAST_FUNC BC_STATUS zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
1626 static FAST_FUNC BC_STATUS zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
1627 static FAST_FUNC BC_STATUS zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
1628 static FAST_FUNC BC_STATUS zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
1629
1630 static FAST_FUNC BC_STATUS zbc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale)
1631 {
1632         BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_a : zbc_num_s;
1633         (void) scale;
1634         RETURN_STATUS(zbc_num_binary(a, b, c, false, op, BC_NUM_AREQ(a, b)));
1635 }
1636
1637 static FAST_FUNC BC_STATUS zbc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale)
1638 {
1639         BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_s : zbc_num_a;
1640         (void) scale;
1641         RETURN_STATUS(zbc_num_binary(a, b, c, true, op, BC_NUM_AREQ(a, b)));
1642 }
1643
1644 static FAST_FUNC BC_STATUS zbc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale)
1645 {
1646         size_t req = BC_NUM_MREQ(a, b, scale);
1647         RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_m, req));
1648 }
1649
1650 static FAST_FUNC BC_STATUS zbc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale)
1651 {
1652         size_t req = BC_NUM_MREQ(a, b, scale);
1653         RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_d, req));
1654 }
1655
1656 static FAST_FUNC BC_STATUS zbc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale)
1657 {
1658         size_t req = BC_NUM_MREQ(a, b, scale);
1659         RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_rem, req));
1660 }
1661
1662 static FAST_FUNC BC_STATUS zbc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale)
1663 {
1664         RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_p, a->len * b->len + 1));
1665 }
1666
1667 static const BcNumBinaryOp zbc_program_ops[] = {
1668         zbc_num_pow, zbc_num_mul, zbc_num_div, zbc_num_mod, zbc_num_add, zbc_num_sub,
1669 };
1670 #define zbc_num_add(...) (zbc_num_add(__VA_ARGS__) COMMA_SUCCESS)
1671 #define zbc_num_sub(...) (zbc_num_sub(__VA_ARGS__) COMMA_SUCCESS)
1672 #define zbc_num_mul(...) (zbc_num_mul(__VA_ARGS__) COMMA_SUCCESS)
1673 #define zbc_num_div(...) (zbc_num_div(__VA_ARGS__) COMMA_SUCCESS)
1674 #define zbc_num_mod(...) (zbc_num_mod(__VA_ARGS__) COMMA_SUCCESS)
1675 #define zbc_num_pow(...) (zbc_num_pow(__VA_ARGS__) COMMA_SUCCESS)
1676
1677 static BC_STATUS zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
1678 {
1679         BcNum one;
1680         BcDig num[2];
1681
1682         one.cap = 2;
1683         one.num = num;
1684         bc_num_one(&one);
1685
1686         RETURN_STATUS(zbc_num_div(&one, a, b, scale));
1687 }
1688 #define zbc_num_inv(...) (zbc_num_inv(__VA_ARGS__) COMMA_SUCCESS)
1689
1690 static FAST_FUNC BC_STATUS zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
1691 {
1692         BcDig *ptr, *ptr_a, *ptr_b, *ptr_c;
1693         size_t i, max, min_rdx, min_int, diff, a_int, b_int;
1694         unsigned carry;
1695
1696         // Because this function doesn't need to use scale (per the bc spec),
1697         // I am hijacking it to say whether it's doing an add or a subtract.
1698
1699         if (a->len == 0) {
1700                 bc_num_copy(c, b);
1701                 if (sub && c->len) c->neg = !c->neg;
1702                 RETURN_STATUS(BC_STATUS_SUCCESS);
1703         }
1704         if (b->len == 0) {
1705                 bc_num_copy(c, a);
1706                 RETURN_STATUS(BC_STATUS_SUCCESS);
1707         }
1708
1709         c->neg = a->neg;
1710         c->rdx = BC_MAX(a->rdx, b->rdx);
1711         min_rdx = BC_MIN(a->rdx, b->rdx);
1712         c->len = 0;
1713
1714         if (a->rdx > b->rdx) {
1715                 diff = a->rdx - b->rdx;
1716                 ptr = a->num;
1717                 ptr_a = a->num + diff;
1718                 ptr_b = b->num;
1719         } else {
1720                 diff = b->rdx - a->rdx;
1721                 ptr = b->num;
1722                 ptr_a = a->num;
1723                 ptr_b = b->num + diff;
1724         }
1725
1726         ptr_c = c->num;
1727         for (i = 0; i < diff; ++i, ++c->len)
1728                 ptr_c[i] = ptr[i];
1729
1730         ptr_c += diff;
1731         a_int = BC_NUM_INT(a);
1732         b_int = BC_NUM_INT(b);
1733
1734         if (a_int > b_int) {
1735                 min_int = b_int;
1736                 max = a_int;
1737                 ptr = ptr_a;
1738         } else {
1739                 min_int = a_int;
1740                 max = b_int;
1741                 ptr = ptr_b;
1742         }
1743
1744         carry = 0;
1745         for (i = 0; i < min_rdx + min_int; ++i) {
1746                 unsigned in = (unsigned)ptr_a[i] + (unsigned)ptr_b[i] + carry;
1747                 carry = in / 10;
1748                 ptr_c[i] = (BcDig)(in % 10);
1749         }
1750         for (; i < max + min_rdx; ++i) {
1751                 unsigned in = (unsigned)ptr[i] + carry;
1752                 carry = in / 10;
1753                 ptr_c[i] = (BcDig)(in % 10);
1754         }
1755         c->len += i;
1756
1757         if (carry != 0) c->num[c->len++] = (BcDig) carry;
1758
1759         RETURN_STATUS(BC_STATUS_SUCCESS); // can't make void, see zbc_num_binary()
1760 }
1761
1762 static FAST_FUNC BC_STATUS zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
1763 {
1764         ssize_t cmp;
1765         BcNum *minuend, *subtrahend;
1766         size_t start;
1767         bool aneg, bneg, neg;
1768
1769         // Because this function doesn't need to use scale (per the bc spec),
1770         // I am hijacking it to say whether it's doing an add or a subtract.
1771
1772         if (a->len == 0) {
1773                 bc_num_copy(c, b);
1774                 if (sub && c->len) c->neg = !c->neg;
1775                 RETURN_STATUS(BC_STATUS_SUCCESS);
1776         }
1777         if (b->len == 0) {
1778                 bc_num_copy(c, a);
1779                 RETURN_STATUS(BC_STATUS_SUCCESS);
1780         }
1781
1782         aneg = a->neg;
1783         bneg = b->neg;
1784         a->neg = b->neg = false;
1785
1786         cmp = bc_num_cmp(a, b);
1787
1788         a->neg = aneg;
1789         b->neg = bneg;
1790
1791         if (cmp == 0) {
1792                 bc_num_setToZero(c, BC_MAX(a->rdx, b->rdx));
1793                 RETURN_STATUS(BC_STATUS_SUCCESS);
1794         }
1795         if (cmp > 0) {
1796                 neg = a->neg;
1797                 minuend = a;
1798                 subtrahend = b;
1799         } else {
1800                 neg = b->neg;
1801                 if (sub) neg = !neg;
1802                 minuend = b;
1803                 subtrahend = a;
1804         }
1805
1806         bc_num_copy(c, minuend);
1807         c->neg = neg;
1808
1809         if (c->rdx < subtrahend->rdx) {
1810                 bc_num_extend(c, subtrahend->rdx - c->rdx);
1811                 start = 0;
1812         } else
1813                 start = c->rdx - subtrahend->rdx;
1814
1815         bc_num_subArrays(c->num + start, subtrahend->num, subtrahend->len);
1816
1817         bc_num_clean(c);
1818
1819         RETURN_STATUS(BC_STATUS_SUCCESS); // can't make void, see zbc_num_binary()
1820 }
1821
1822 static FAST_FUNC BC_STATUS zbc_num_k(BcNum *restrict a, BcNum *restrict b,
1823                          BcNum *restrict c)
1824 #define zbc_num_k(...) (zbc_num_k(__VA_ARGS__) COMMA_SUCCESS)
1825 {
1826         BcStatus s;
1827         size_t max = BC_MAX(a->len, b->len), max2 = (max + 1) / 2;
1828         BcNum l1, h1, l2, h2, m2, m1, z0, z1, z2, temp;
1829         bool aone;
1830
1831         if (a->len == 0 || b->len == 0) {
1832                 bc_num_zero(c);
1833                 RETURN_STATUS(BC_STATUS_SUCCESS);
1834         }
1835         aone = BC_NUM_ONE(a);
1836         if (aone || BC_NUM_ONE(b)) {
1837                 bc_num_copy(c, aone ? b : a);
1838                 RETURN_STATUS(BC_STATUS_SUCCESS);
1839         }
1840
1841         if (a->len + b->len < BC_NUM_KARATSUBA_LEN
1842          || a->len < BC_NUM_KARATSUBA_LEN
1843          || b->len < BC_NUM_KARATSUBA_LEN
1844         ) {
1845                 size_t i, j, len;
1846
1847                 bc_num_expand(c, a->len + b->len + 1);
1848
1849                 memset(c->num, 0, sizeof(BcDig) * c->cap);
1850                 c->len = len = 0;
1851
1852                 for (i = 0; i < b->len; ++i) {
1853                         unsigned carry = 0;
1854                         for (j = 0; j < a->len; ++j) {
1855                                 unsigned in = c->num[i + j];
1856                                 in += (unsigned)a->num[j] * (unsigned)b->num[i] + carry;
1857                                 // note: compilers prefer _unsigned_ div/const
1858                                 carry = in / 10;
1859                                 c->num[i + j] = (BcDig)(in % 10);
1860                         }
1861
1862                         c->num[i + j] += (BcDig) carry;
1863                         len = BC_MAX(len, i + j + !!carry);
1864
1865 #if ENABLE_FEATURE_BC_SIGNALS
1866                         // a=2^1000000
1867                         // a*a <- without check below, this will not be interruptible
1868                         if (G_interrupt) return BC_STATUS_FAILURE;
1869 #endif
1870                 }
1871
1872                 c->len = len;
1873
1874                 RETURN_STATUS(BC_STATUS_SUCCESS);
1875         }
1876
1877         bc_num_init(&l1, max);
1878         bc_num_init(&h1, max);
1879         bc_num_init(&l2, max);
1880         bc_num_init(&h2, max);
1881         bc_num_init(&m1, max);
1882         bc_num_init(&m2, max);
1883         bc_num_init(&z0, max);
1884         bc_num_init(&z1, max);
1885         bc_num_init(&z2, max);
1886         bc_num_init(&temp, max + max);
1887
1888         bc_num_split(a, max2, &l1, &h1);
1889         bc_num_split(b, max2, &l2, &h2);
1890
1891         s = zbc_num_add(&h1, &l1, &m1, 0);
1892         if (s) goto err;
1893         s = zbc_num_add(&h2, &l2, &m2, 0);
1894         if (s) goto err;
1895
1896         s = zbc_num_k(&h1, &h2, &z0);
1897         if (s) goto err;
1898         s = zbc_num_k(&m1, &m2, &z1);
1899         if (s) goto err;
1900         s = zbc_num_k(&l1, &l2, &z2);
1901         if (s) goto err;
1902
1903         s = zbc_num_sub(&z1, &z0, &temp, 0);
1904         if (s) goto err;
1905         s = zbc_num_sub(&temp, &z2, &z1, 0);
1906         if (s) goto err;
1907
1908         s = zbc_num_shift(&z0, max2 * 2);
1909         if (s) goto err;
1910         s = zbc_num_shift(&z1, max2);
1911         if (s) goto err;
1912         s = zbc_num_add(&z0, &z1, &temp, 0);
1913         if (s) goto err;
1914         s = zbc_num_add(&temp, &z2, c, 0);
1915  err:
1916         bc_num_free(&temp);
1917         bc_num_free(&z2);
1918         bc_num_free(&z1);
1919         bc_num_free(&z0);
1920         bc_num_free(&m2);
1921         bc_num_free(&m1);
1922         bc_num_free(&h2);
1923         bc_num_free(&l2);
1924         bc_num_free(&h1);
1925         bc_num_free(&l1);
1926         RETURN_STATUS(s);
1927 }
1928
1929 static FAST_FUNC BC_STATUS zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
1930 {
1931         BcStatus s;
1932         BcNum cpa, cpb;
1933         size_t maxrdx = BC_MAX(a->rdx, b->rdx);
1934
1935         scale = BC_MAX(scale, a->rdx);
1936         scale = BC_MAX(scale, b->rdx);
1937         scale = BC_MIN(a->rdx + b->rdx, scale);
1938         maxrdx = BC_MAX(maxrdx, scale);
1939
1940         bc_num_init(&cpa, a->len);
1941         bc_num_init(&cpb, b->len);
1942
1943         bc_num_copy(&cpa, a);
1944         bc_num_copy(&cpb, b);
1945         cpa.neg = cpb.neg = false;
1946
1947         s = zbc_num_shift(&cpa, maxrdx);
1948         if (s) goto err;
1949         s = zbc_num_shift(&cpb, maxrdx);
1950         if (s) goto err;
1951         s = zbc_num_k(&cpa, &cpb, c);
1952         if (s) goto err;
1953
1954         maxrdx += scale;
1955         bc_num_expand(c, c->len + maxrdx);
1956
1957         if (c->len < maxrdx) {
1958                 memset(c->num + c->len, 0, (c->cap - c->len) * sizeof(BcDig));
1959                 c->len += maxrdx;
1960         }
1961
1962         c->rdx = maxrdx;
1963         bc_num_retireMul(c, scale, a->neg, b->neg);
1964  err:
1965         bc_num_free(&cpb);
1966         bc_num_free(&cpa);
1967         RETURN_STATUS(s);
1968 }
1969 #define zbc_num_m(...) (zbc_num_m(__VA_ARGS__) COMMA_SUCCESS)
1970
1971 static FAST_FUNC BC_STATUS zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
1972 {
1973         BcStatus s;
1974         size_t len, end, i;
1975         BcNum cp;
1976
1977         if (b->len == 0)
1978                 RETURN_STATUS(bc_error("divide by zero"));
1979         if (a->len == 0) {
1980                 bc_num_setToZero(c, scale);
1981                 RETURN_STATUS(BC_STATUS_SUCCESS);
1982         }
1983         if (BC_NUM_ONE(b)) {
1984                 bc_num_copy(c, a);
1985                 bc_num_retireMul(c, scale, a->neg, b->neg);
1986                 RETURN_STATUS(BC_STATUS_SUCCESS);
1987         }
1988
1989         bc_num_init(&cp, BC_NUM_MREQ(a, b, scale));
1990         bc_num_copy(&cp, a);
1991         len = b->len;
1992
1993         if (len > cp.len) {
1994                 bc_num_expand(&cp, len + 2);
1995                 bc_num_extend(&cp, len - cp.len);
1996         }
1997
1998         if (b->rdx > cp.rdx) bc_num_extend(&cp, b->rdx - cp.rdx);
1999         cp.rdx -= b->rdx;
2000         if (scale > cp.rdx) bc_num_extend(&cp, scale - cp.rdx);
2001
2002         if (b->rdx == b->len) {
2003                 for (;;) {
2004                         if (len == 0) break;
2005                         len--;
2006                         if (b->num[len] != 0)
2007                                 break;
2008                 }
2009                 len++;
2010         }
2011
2012         if (cp.cap == cp.len) bc_num_expand(&cp, cp.len + 1);
2013
2014         // We want an extra zero in front to make things simpler.
2015         cp.num[cp.len++] = 0;
2016         end = cp.len - len;
2017
2018         bc_num_expand(c, cp.len);
2019
2020         bc_num_zero(c);
2021         memset(c->num + end, 0, (c->cap - end) * sizeof(BcDig));
2022         c->rdx = cp.rdx;
2023         c->len = cp.len;
2024
2025         s = BC_STATUS_SUCCESS;
2026         for (i = end - 1; i < end; --i) {
2027                 BcDig *n, q;
2028                 n = cp.num + i;
2029                 for (q = 0; n[len] != 0 || bc_num_compare(n, b->num, len) >= 0; ++q)
2030                         bc_num_subArrays(n, b->num, len);
2031                 c->num[i] = q;
2032 #if ENABLE_FEATURE_BC_SIGNALS
2033                 // a=2^100000
2034                 // scale=40000
2035                 // 1/a <- without check below, this will not be interruptible
2036                 if (G_interrupt) {
2037                         s = BC_STATUS_FAILURE;
2038                         break;
2039                 }
2040 #endif
2041         }
2042
2043         bc_num_retireMul(c, scale, a->neg, b->neg);
2044         bc_num_free(&cp);
2045
2046         RETURN_STATUS(s);
2047 }
2048 #define zbc_num_d(...) (zbc_num_d(__VA_ARGS__) COMMA_SUCCESS)
2049
2050 static FAST_FUNC BC_STATUS zbc_num_r(BcNum *a, BcNum *b, BcNum *restrict c,
2051                          BcNum *restrict d, size_t scale, size_t ts)
2052 {
2053         BcStatus s;
2054         BcNum temp;
2055         bool neg;
2056
2057         if (b->len == 0)
2058                 RETURN_STATUS(bc_error("divide by zero"));
2059
2060         if (a->len == 0) {
2061                 bc_num_setToZero(d, ts);
2062                 RETURN_STATUS(BC_STATUS_SUCCESS);
2063         }
2064
2065         bc_num_init(&temp, d->cap);
2066         s = zbc_num_d(a, b, c, scale);
2067         if (s) goto err;
2068
2069         if (scale != 0) scale = ts;
2070
2071         s = zbc_num_m(c, b, &temp, scale);
2072         if (s) goto err;
2073         s = zbc_num_sub(a, &temp, d, scale);
2074         if (s) goto err;
2075
2076         if (ts > d->rdx && d->len) bc_num_extend(d, ts - d->rdx);
2077
2078         neg = d->neg;
2079         bc_num_retireMul(d, ts, a->neg, b->neg);
2080         d->neg = neg;
2081  err:
2082         bc_num_free(&temp);
2083         RETURN_STATUS(s);
2084 }
2085 #define zbc_num_r(...) (zbc_num_r(__VA_ARGS__) COMMA_SUCCESS)
2086
2087 static FAST_FUNC BC_STATUS zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
2088 {
2089         BcStatus s;
2090         BcNum c1;
2091         size_t ts = BC_MAX(scale + b->rdx, a->rdx), len = BC_NUM_MREQ(a, b, ts);
2092
2093         bc_num_init(&c1, len);
2094         s = zbc_num_r(a, b, &c1, c, scale, ts);
2095         bc_num_free(&c1);
2096
2097         RETURN_STATUS(s);
2098 }
2099 #define zbc_num_rem(...) (zbc_num_rem(__VA_ARGS__) COMMA_SUCCESS)
2100
2101 static FAST_FUNC BC_STATUS zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
2102 {
2103         BcStatus s = BC_STATUS_SUCCESS;
2104         BcNum copy;
2105         unsigned long pow;
2106         size_t i, powrdx, resrdx;
2107         bool neg;
2108
2109         // GNU bc does not allow 2^2.0 - we do
2110         for (i = 0; i < b->rdx; i++)
2111                 if (b->num[i] != 0)
2112                         RETURN_STATUS(bc_error("not an integer"));
2113
2114         if (b->len == 0) {
2115                 bc_num_one(c);
2116                 RETURN_STATUS(BC_STATUS_SUCCESS);
2117         }
2118         if (a->len == 0) {
2119                 bc_num_setToZero(c, scale);
2120                 RETURN_STATUS(BC_STATUS_SUCCESS);
2121         }
2122         if (BC_NUM_ONE(b)) {
2123                 if (!b->neg)
2124                         bc_num_copy(c, a);
2125                 else
2126                         s = zbc_num_inv(a, c, scale);
2127                 RETURN_STATUS(s);
2128         }
2129
2130         neg = b->neg;
2131         s = zbc_num_ulong_abs(b, &pow);
2132         if (s) RETURN_STATUS(s);
2133         // b is not used beyond this point
2134
2135         bc_num_init(&copy, a->len);
2136         bc_num_copy(&copy, a);
2137
2138         if (!neg) {
2139                 if (a->rdx > scale)
2140                         scale = a->rdx;
2141                 if (a->rdx * pow < scale)
2142                         scale = a->rdx * pow;
2143         }
2144
2145
2146         for (powrdx = a->rdx; !(pow & 1); pow >>= 1) {
2147                 powrdx <<= 1;
2148                 s = zbc_num_mul(&copy, &copy, &copy, powrdx);
2149                 if (s) goto err;
2150                 // Not needed: zbc_num_mul() has a check for ^C:
2151                 //if (G_interrupt) {
2152                 //      s = BC_STATUS_FAILURE;
2153                 //      goto err;
2154                 //}
2155         }
2156
2157         bc_num_copy(c, &copy);
2158
2159         for (resrdx = powrdx, pow >>= 1; pow != 0; pow >>= 1) {
2160                 powrdx <<= 1;
2161                 s = zbc_num_mul(&copy, &copy, &copy, powrdx);
2162                 if (s) goto err;
2163
2164                 if (pow & 1) {
2165                         resrdx += powrdx;
2166                         s = zbc_num_mul(c, &copy, c, resrdx);
2167                         if (s) goto err;
2168                 }
2169                 // Not needed: zbc_num_mul() has a check for ^C:
2170                 //if (G_interrupt) {
2171                 //      s = BC_STATUS_FAILURE;
2172                 //      goto err;
2173                 //}
2174         }
2175
2176         if (neg) {
2177                 s = zbc_num_inv(c, c, scale);
2178                 if (s) goto err;
2179         }
2180
2181         if (c->rdx > scale) bc_num_truncate(c, c->rdx - scale);
2182
2183         // We can't use bc_num_clean() here.
2184         for (i = 0; i < c->len; ++i)
2185                 if (c->num[i] != 0)
2186                         goto skip;
2187         bc_num_setToZero(c, scale);
2188  skip:
2189
2190  err:
2191         bc_num_free(&copy);
2192         RETURN_STATUS(s);
2193 }
2194 #define zbc_num_p(...) (zbc_num_p(__VA_ARGS__) COMMA_SUCCESS)
2195
2196 static BC_STATUS zbc_num_sqrt(BcNum *a, BcNum *restrict b, size_t scale)
2197 {
2198         BcStatus s;
2199         BcNum num1, num2, half, f, fprime, *x0, *x1, *temp;
2200         size_t pow, len, digs, digs1, resrdx, req, times = 0;
2201         ssize_t cmp = 1, cmp1 = SSIZE_MAX, cmp2 = SSIZE_MAX;
2202
2203         req = BC_MAX(scale, a->rdx) + ((BC_NUM_INT(a) + 1) >> 1) + 1;
2204         bc_num_expand(b, req);
2205
2206         if (a->len == 0) {
2207                 bc_num_setToZero(b, scale);
2208                 RETURN_STATUS(BC_STATUS_SUCCESS);
2209         }
2210         if (a->neg) {
2211                 RETURN_STATUS(bc_error("negative number"));
2212         }
2213         if (BC_NUM_ONE(a)) {
2214                 bc_num_one(b);
2215                 bc_num_extend(b, scale);
2216                 RETURN_STATUS(BC_STATUS_SUCCESS);
2217         }
2218
2219         scale = BC_MAX(scale, a->rdx) + 1;
2220         len = a->len + scale;
2221
2222         bc_num_init(&num1, len);
2223         bc_num_init(&num2, len);
2224         bc_num_init_DEF_SIZE(&half);
2225
2226         bc_num_one(&half);
2227         half.num[0] = 5;
2228         half.rdx = 1;
2229
2230         bc_num_init(&f, len);
2231         bc_num_init(&fprime, len);
2232
2233         x0 = &num1;
2234         x1 = &num2;
2235
2236         bc_num_one(x0);
2237         pow = BC_NUM_INT(a);
2238
2239         if (pow) {
2240                 if (pow & 1)
2241                         x0->num[0] = 2;
2242                 else
2243                         x0->num[0] = 6;
2244
2245                 pow -= 2 - (pow & 1);
2246
2247                 bc_num_extend(x0, pow);
2248
2249                 // Make sure to move the radix back.
2250                 x0->rdx -= pow;
2251         }
2252
2253         x0->rdx = digs = digs1 = 0;
2254         resrdx = scale + 2;
2255         len = BC_NUM_INT(x0) + resrdx - 1;
2256
2257         while (cmp != 0 || digs < len) {
2258                 s = zbc_num_div(a, x0, &f, resrdx);
2259                 if (s) goto err;
2260                 s = zbc_num_add(x0, &f, &fprime, resrdx);
2261                 if (s) goto err;
2262                 s = zbc_num_mul(&fprime, &half, x1, resrdx);
2263                 if (s) goto err;
2264
2265                 cmp = bc_num_cmp(x1, x0);
2266                 digs = x1->len - (unsigned long long) llabs(cmp);
2267
2268                 if (cmp == cmp2 && digs == digs1)
2269                         times += 1;
2270                 else
2271                         times = 0;
2272
2273                 resrdx += times > 4;
2274
2275                 cmp2 = cmp1;
2276                 cmp1 = cmp;
2277                 digs1 = digs;
2278
2279                 temp = x0;
2280                 x0 = x1;
2281                 x1 = temp;
2282         }
2283
2284         bc_num_copy(b, x0);
2285         scale -= 1;
2286         if (b->rdx > scale) bc_num_truncate(b, b->rdx - scale);
2287  err:
2288         bc_num_free(&fprime);
2289         bc_num_free(&f);
2290         bc_num_free(&half);
2291         bc_num_free(&num2);
2292         bc_num_free(&num1);
2293         RETURN_STATUS(s);
2294 }
2295 #define zbc_num_sqrt(...) (zbc_num_sqrt(__VA_ARGS__) COMMA_SUCCESS)
2296
2297 static BC_STATUS zbc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d,
2298                               size_t scale)
2299 {
2300         BcStatus s;
2301         BcNum num2, *ptr_a;
2302         bool init = false;
2303         size_t ts = BC_MAX(scale + b->rdx, a->rdx), len = BC_NUM_MREQ(a, b, ts);
2304
2305         if (c == a) {
2306                 memcpy(&num2, c, sizeof(BcNum));
2307                 ptr_a = &num2;
2308                 bc_num_init(c, len);
2309                 init = true;
2310         } else {
2311                 ptr_a = a;
2312                 bc_num_expand(c, len);
2313         }
2314
2315         s = zbc_num_r(ptr_a, b, c, d, scale, ts);
2316
2317         if (init) bc_num_free(&num2);
2318
2319         RETURN_STATUS(s);
2320 }
2321 #define zbc_num_divmod(...) (zbc_num_divmod(__VA_ARGS__) COMMA_SUCCESS)
2322
2323 #if ENABLE_DC
2324 static BC_STATUS zdc_num_modexp(BcNum *a, BcNum *b, BcNum *c, BcNum *restrict d)
2325 {
2326         BcStatus s;
2327         BcNum base, exp, two, temp;
2328         BcDig two_digs[2];
2329
2330         if (c->len == 0)
2331                 RETURN_STATUS(bc_error("divide by zero"));
2332         if (a->rdx || b->rdx || c->rdx)
2333                 RETURN_STATUS(bc_error("not an integer"));
2334         if (b->neg)
2335                 RETURN_STATUS(bc_error("negative number"));
2336
2337         bc_num_expand(d, c->len);
2338         bc_num_init(&base, c->len);
2339         bc_num_init(&exp, b->len);
2340         bc_num_init(&temp, b->len);
2341
2342         two.cap = ARRAY_SIZE(two_digs);
2343         two.num = two_digs;
2344         bc_num_one(&two);
2345         two_digs[0] = 2;
2346
2347         bc_num_one(d);
2348
2349         s = zbc_num_rem(a, c, &base, 0);
2350         if (s) goto err;
2351         bc_num_copy(&exp, b);
2352
2353         while (exp.len != 0) {
2354                 s = zbc_num_divmod(&exp, &two, &exp, &temp, 0);
2355                 if (s) goto err;
2356
2357                 if (BC_NUM_ONE(&temp)) {
2358                         s = zbc_num_mul(d, &base, &temp, 0);
2359                         if (s) goto err;
2360                         s = zbc_num_rem(&temp, c, d, 0);
2361                         if (s) goto err;
2362                 }
2363
2364                 s = zbc_num_mul(&base, &base, &temp, 0);
2365                 if (s) goto err;
2366                 s = zbc_num_rem(&temp, c, &base, 0);
2367                 if (s) goto err;
2368         }
2369  err:
2370         bc_num_free(&temp);
2371         bc_num_free(&exp);
2372         bc_num_free(&base);
2373         RETURN_STATUS(s);
2374 }
2375 #define zdc_num_modexp(...) (zdc_num_modexp(__VA_ARGS__) COMMA_SUCCESS)
2376 #endif // ENABLE_DC
2377
2378 static FAST_FUNC void bc_string_free(void *string)
2379 {
2380         free(*(char**)string);
2381 }
2382
2383 static void bc_func_init(BcFunc *f)
2384 {
2385         bc_char_vec_init(&f->code);
2386         IF_BC(bc_vec_init(&f->labels, sizeof(size_t), NULL);)
2387         IF_BC(bc_vec_init(&f->autos, sizeof(BcId), bc_id_free);)
2388         IF_BC(bc_vec_init(&f->strs, sizeof(char *), bc_string_free);)
2389         IF_BC(bc_vec_init(&f->consts, sizeof(char *), bc_string_free);)
2390         IF_BC(f->nparams = 0;)
2391 }
2392
2393 static FAST_FUNC void bc_func_free(void *func)
2394 {
2395         BcFunc *f = (BcFunc *) func;
2396         bc_vec_free(&f->code);
2397         IF_BC(bc_vec_free(&f->labels);)
2398         IF_BC(bc_vec_free(&f->autos);)
2399         IF_BC(bc_vec_free(&f->strs);)
2400         IF_BC(bc_vec_free(&f->consts);)
2401 }
2402
2403 static void bc_array_expand(BcVec *a, size_t len);
2404
2405 static void bc_array_init(BcVec *a, bool nums)
2406 {
2407         if (nums)
2408                 bc_vec_init(a, sizeof(BcNum), bc_num_free);
2409         else
2410                 bc_vec_init(a, sizeof(BcVec), bc_vec_free);
2411         bc_array_expand(a, 1);
2412 }
2413
2414 static void bc_array_expand(BcVec *a, size_t len)
2415 {
2416         if (a->dtor == bc_num_free
2417          // && a->size == sizeof(BcNum) - always true
2418         ) {
2419                 BcNum n;
2420                 while (len > a->len) {
2421                         bc_num_init_DEF_SIZE(&n);
2422                         bc_vec_push(a, &n);
2423                 }
2424         } else {
2425                 BcVec v;
2426                 while (len > a->len) {
2427                         bc_array_init(&v, true);
2428                         bc_vec_push(a, &v);
2429                 }
2430         }
2431 }
2432
2433 static void bc_array_copy(BcVec *d, const BcVec *s)
2434 {
2435         BcNum *dnum, *snum;
2436         size_t i;
2437
2438         bc_vec_pop_all(d);
2439         bc_vec_expand(d, s->cap);
2440         d->len = s->len;
2441
2442         dnum = (void*)d->v;
2443         snum = (void*)s->v;
2444         for (i = 0; i < s->len; i++, dnum++, snum++) {
2445                 bc_num_init(dnum, snum->len);
2446                 bc_num_copy(dnum, snum);
2447         }
2448 }
2449
2450 #if ENABLE_DC
2451 static void dc_result_copy(BcResult *d, BcResult *src)
2452 {
2453         d->t = src->t;
2454
2455         switch (d->t) {
2456                 case XC_RESULT_TEMP:
2457                 case XC_RESULT_IBASE:
2458                 case XC_RESULT_SCALE:
2459                 case XC_RESULT_OBASE:
2460                         bc_num_init(&d->d.n, src->d.n.len);
2461                         bc_num_copy(&d->d.n, &src->d.n);
2462                         break;
2463                 case XC_RESULT_VAR:
2464                 case XC_RESULT_ARRAY:
2465                 case XC_RESULT_ARRAY_ELEM:
2466                         d->d.id.name = xstrdup(src->d.id.name);
2467                         break;
2468                 case XC_RESULT_CONSTANT:
2469                 IF_BC(case BC_RESULT_LAST:)
2470                 IF_BC(case BC_RESULT_ONE:)
2471                 case XC_RESULT_STR:
2472                         memcpy(&d->d.n, &src->d.n, sizeof(BcNum));
2473                         break;
2474         }
2475 }
2476 #endif // ENABLE_DC
2477
2478 static FAST_FUNC void bc_result_free(void *result)
2479 {
2480         BcResult *r = (BcResult *) result;
2481
2482         switch (r->t) {
2483                 case XC_RESULT_TEMP:
2484                 case XC_RESULT_IBASE:
2485                 case XC_RESULT_SCALE:
2486                 case XC_RESULT_OBASE:
2487                         bc_num_free(&r->d.n);
2488                         break;
2489                 case XC_RESULT_VAR:
2490                 case XC_RESULT_ARRAY:
2491                 case XC_RESULT_ARRAY_ELEM:
2492                         free(r->d.id.name);
2493                         break;
2494                 default:
2495                         // Do nothing.
2496                         break;
2497         }
2498 }
2499
2500 static int bad_input_byte(char c)
2501 {
2502         if ((c < ' ' && c != '\t' && c != '\r' && c != '\n') // also allow '\v' '\f'?
2503          || c > 0x7e
2504         ) {
2505                 bc_error_fmt("illegal character 0x%02x", c);
2506                 return 1;
2507         }
2508         return 0;
2509 }
2510
2511 // Note: it _appends_ data from fp to vec.
2512 static void bc_read_line(BcVec *vec, FILE *fp)
2513 {
2514  again:
2515         fflush_and_check();
2516
2517 #if ENABLE_FEATURE_BC_SIGNALS
2518         if (G_interrupt) { // ^C was pressed
2519  intr:
2520                 if (fp != stdin) {
2521                         // ^C while running a script (bc SCRIPT): die.
2522                         // We do not return to interactive prompt:
2523                         // user might be running us from a shell,
2524                         // and SCRIPT might be intended to terminate
2525                         // (e.g. contain a "halt" stmt).
2526                         // ^C dropping user into a bc prompt instead of
2527                         // the shell would be unexpected.
2528                         xfunc_die();
2529                 }
2530                 // ^C while interactive input
2531                 G_interrupt = 0;
2532                 // GNU bc says "interrupted execution."
2533                 // GNU dc says "Interrupt!"
2534                 fputs("\ninterrupted execution\n", stderr);
2535         }
2536
2537 # if ENABLE_FEATURE_EDITING
2538         if (G_ttyin && fp == stdin) {
2539                 int n, i;
2540 #  define line_buf bb_common_bufsiz1
2541                 n = read_line_input(G.line_input_state, "", line_buf, COMMON_BUFSIZE);
2542                 if (n <= 0) { // read errors or EOF, or ^D, or ^C
2543                         if (n == 0) // ^C
2544                                 goto intr;
2545                         bc_vec_pushZeroByte(vec); // ^D or EOF (or error)
2546                         return;
2547                 }
2548                 i = 0;
2549                 for (;;) {
2550                         char c = line_buf[i++];
2551                         if (!c) break;
2552                         if (bad_input_byte(c)) goto again;
2553                 }
2554                 bc_vec_concat(vec, line_buf);
2555 #  undef line_buf
2556         } else
2557 # endif
2558 #endif
2559         {
2560                 int c;
2561                 bool bad_chars = 0;
2562                 size_t len = vec->len;
2563
2564                 do {
2565 #if ENABLE_FEATURE_BC_SIGNALS
2566                         if (G_interrupt) {
2567                                 // ^C was pressed: ignore entire line, get another one
2568                                 vec->len = len;
2569                                 goto intr;
2570                         }
2571 #endif
2572                         do c = fgetc(fp); while (c == '\0');
2573                         if (c == EOF) {
2574                                 if (ferror(fp))
2575                                         bb_perror_msg_and_die("input error");
2576                                 // Note: EOF does not append '\n'
2577                                 break;
2578                         }
2579                         bad_chars |= bad_input_byte(c);
2580                         bc_vec_pushByte(vec, (char)c);
2581                 } while (c != '\n');
2582
2583                 if (bad_chars) {
2584                         // Bad chars on this line
2585                         if (!G.prs.filename) { // stdin
2586                                 // ignore entire line, get another one
2587                                 vec->len = len;
2588                                 goto again;
2589                         }
2590                         bb_perror_msg_and_die("file '%s' is not text", G.prs.filename);
2591                 }
2592                 bc_vec_pushZeroByte(vec);
2593         }
2594 }
2595
2596 //
2597 // Parsing routines
2598 //
2599
2600 static bool bc_num_strValid(const char *val, size_t base)
2601 {
2602         BcDig b;
2603         bool radix;
2604
2605         b = (BcDig)(base <= 10 ? base + '0' : base - 10 + 'A');
2606         radix = false;
2607         for (;;) {
2608                 BcDig c = *val++;
2609                 if (c == '\0')
2610                         break;
2611                 if (c == '.') {
2612                         if (radix) return false;
2613                         radix = true;
2614                         continue;
2615                 }
2616                 if (c < '0' || c >= b || (c > '9' && c < 'A'))
2617                         return false;
2618         }
2619         return true;
2620 }
2621
2622 // Note: n is already "bc_num_zero()"ed,
2623 // leading zeroes in "val" are removed
2624 static void bc_num_parseDecimal(BcNum *n, const char *val)
2625 {
2626         size_t len, i;
2627         const char *ptr;
2628
2629         len = strlen(val);
2630         if (len == 0)
2631                 return;
2632
2633         bc_num_expand(n, len);
2634
2635         ptr = strchr(val, '.');
2636
2637         n->rdx = 0;
2638         if (ptr != NULL)
2639                 n->rdx = (size_t)((val + len) - (ptr + 1));
2640
2641         for (i = 0; val[i]; ++i) {
2642                 if (val[i] != '0' && val[i] != '.') {
2643                         // Not entirely zero value - convert it, and exit
2644                         i = len - 1;
2645                         for (;;) {
2646                                 n->num[n->len] = val[i] - '0';
2647                                 ++n->len;
2648  skip_dot:
2649                                 if (i == 0) break;
2650                                 if (val[--i] == '.') goto skip_dot;
2651                         }
2652                         break;
2653                 }
2654         }
2655         // if for() exits without hitting if(), the value is entirely zero
2656 }
2657
2658 // Note: n is already "bc_num_zero()"ed,
2659 // leading zeroes in "val" are removed
2660 static void bc_num_parseBase(BcNum *n, const char *val, unsigned base_t)
2661 {
2662         BcStatus s;
2663         BcNum temp, mult, result;
2664         BcNum base;
2665         BcDig base_digs[ULONG_NUM_BUFSIZE];
2666         BcDig c = '\0';
2667         unsigned long v;
2668         size_t i, digits;
2669
2670         for (i = 0; ; ++i) {
2671                 if (val[i] == '\0')
2672                         return;
2673                 if (val[i] != '.' && val[i] != '0')
2674                         break;
2675         }
2676
2677         bc_num_init_DEF_SIZE(&temp);
2678         bc_num_init_DEF_SIZE(&mult);
2679         base.cap = ARRAY_SIZE(base_digs);
2680         base.num = base_digs;
2681         bc_num_ulong2num(&base, base_t);
2682
2683         for (;;) {
2684                 c = *val++;
2685                 if (c == '\0') goto int_err;
2686                 if (c == '.') break;
2687
2688                 v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
2689
2690                 s = zbc_num_mul(n, &base, &mult, 0);
2691                 if (s) goto int_err;
2692                 bc_num_ulong2num(&temp, v);
2693                 s = zbc_num_add(&mult, &temp, n, 0);
2694                 if (s) goto int_err;
2695         }
2696
2697         bc_num_init(&result, base.len);
2698         //bc_num_zero(&result); - already is
2699         bc_num_one(&mult);
2700
2701         digits = 0;
2702         for (;;) {
2703                 c = *val++;
2704                 if (c == '\0') break;
2705                 digits++;
2706
2707                 v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
2708
2709                 s = zbc_num_mul(&result, &base, &result, 0);
2710                 if (s) goto err;
2711                 bc_num_ulong2num(&temp, v);
2712                 s = zbc_num_add(&result, &temp, &result, 0);
2713                 if (s) goto err;
2714                 s = zbc_num_mul(&mult, &base, &mult, 0);
2715                 if (s) goto err;
2716         }
2717
2718         s = zbc_num_div(&result, &mult, &result, digits);
2719         if (s) goto err;
2720         s = zbc_num_add(n, &result, n, digits);
2721         if (s) goto err;
2722
2723         if (n->len != 0) {
2724                 if (n->rdx < digits)
2725                         bc_num_extend(n, digits - n->rdx);
2726         } else
2727                 bc_num_zero(n);
2728  err:
2729         bc_num_free(&result);
2730  int_err:
2731         bc_num_free(&mult);
2732         bc_num_free(&temp);
2733 }
2734
2735 static BC_STATUS zbc_num_parse(BcNum *n, const char *val, unsigned base_t)
2736 {
2737         if (!bc_num_strValid(val, base_t))
2738                 RETURN_STATUS(bc_error("bad number string"));
2739
2740         bc_num_zero(n);
2741         while (*val == '0') val++;
2742
2743         if (base_t == 10)
2744                 bc_num_parseDecimal(n, val);
2745         else
2746                 bc_num_parseBase(n, val, base_t);
2747
2748         RETURN_STATUS(BC_STATUS_SUCCESS);
2749 }
2750 #define zbc_num_parse(...) (zbc_num_parse(__VA_ARGS__) COMMA_SUCCESS)
2751
2752 static void bc_lex_lineComment(void)
2753 {
2754         BcLex *l = &G.prs.l;
2755         // Try: echo -n '#foo' | bc
2756         size_t i;
2757         l->lex = XC_LEX_WHITESPACE;
2758         i = l->i;
2759         while (i < l->len && l->buf[i] != '\n')
2760                 i++;
2761         l->i = i;
2762 }
2763
2764 static void bc_lex_whitespace(void)
2765 {
2766         BcLex *l = &G.prs.l;
2767         l->lex = XC_LEX_WHITESPACE;
2768         for (;;) {
2769                 char c = l->buf[l->i];
2770                 if (c == '\n') // this is XC_LEX_NLINE, not XC_LEX_WHITESPACE
2771                         break;
2772                 if (!isspace(c))
2773                         break;
2774                 l->i++;
2775         }
2776 }
2777
2778 static BC_STATUS zbc_lex_number(char start)
2779 {
2780         BcLex *l = &G.prs.l;
2781         const char *buf = l->buf + l->i;
2782         size_t len, i, ccnt;
2783         bool pt;
2784
2785         pt = (start == '.');
2786         l->lex = XC_LEX_NUMBER;
2787         ccnt = i = 0;
2788         for (;;) {
2789                 char c = buf[i];
2790                 if (c == '\0')
2791                         break;
2792                 if (c == '\\' && buf[i + 1] == '\n') {
2793                         i += 2;
2794                         //number_of_backslashes++ - see comment below
2795                         continue;
2796                 }
2797                 if (!isdigit(c) && (c < 'A' || c > 'F')) {
2798                         if (c != '.') break;
2799                         // if '.' was already seen, stop on second one:
2800                         if (pt) break;
2801                         pt = true;
2802                 }
2803                 // buf[i] is one of "0-9A-F."
2804                 i++;
2805                 if (c != '.')
2806                         ccnt = i;
2807         }
2808         //ccnt is the number of chars in the number string, excluding possible
2809         //trailing "[\<newline>].[\<newline>]" (with any number of \<NL> repetitions).
2810         //i is buf[i] index of the first not-yet-parsed char after that.
2811         l->i += i;
2812
2813         // This might overestimate the size, if there are "\<NL>"'s
2814         // in the number. Subtracting number_of_backslashes*2 correctly
2815         // is not that easy: consider that in the case of "NNN.\<NL>"
2816         // loop above will count "\<NL>" before it realizes it is not
2817         // in fact *inside* the number:
2818         len = ccnt + 1; // +1 byte for NUL termination
2819
2820         // This check makes sense only if size_t is (much) larger than BC_MAX_NUM.
2821         if (SIZE_MAX > (BC_MAX_NUM | 0xff)) {
2822                 if (len > BC_MAX_NUM)
2823                         RETURN_STATUS(bc_error("number too long: must be [1,"BC_MAX_NUM_STR"]"));
2824         }
2825
2826         bc_vec_pop_all(&l->lex_buf);
2827         bc_vec_expand(&l->lex_buf, 1 + len);
2828         bc_vec_push(&l->lex_buf, &start);
2829
2830         while (ccnt != 0) {
2831                 // If we have hit a backslash, skip it. We don't have
2832                 // to check for a newline because it's guaranteed.
2833                 if (*buf == '\\') {
2834                         buf += 2;
2835                         ccnt -= 2;
2836                         continue;
2837                 }
2838                 bc_vec_push(&l->lex_buf, buf);
2839                 buf++;
2840                 ccnt--;
2841         }
2842
2843         bc_vec_pushZeroByte(&l->lex_buf);
2844
2845         RETURN_STATUS(BC_STATUS_SUCCESS);
2846 }
2847 #define zbc_lex_number(...) (zbc_lex_number(__VA_ARGS__) COMMA_SUCCESS)
2848
2849 static void bc_lex_name(void)
2850 {
2851         BcLex *l = &G.prs.l;
2852         size_t i;
2853         const char *buf;
2854
2855         l->lex = XC_LEX_NAME;
2856
2857         i = 0;
2858         buf = l->buf + l->i - 1;
2859         for (;;) {
2860                 char c = buf[i];
2861                 if ((c < 'a' || c > 'z') && !isdigit(c) && c != '_') break;
2862                 i++;
2863         }
2864
2865 #if 0 // We do not protect against people with gigabyte-long names
2866         // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
2867         if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
2868                 if (i > BC_MAX_STRING)
2869                         return bc_error("name too long: must be [1,"BC_MAX_STRING_STR"]");
2870         }
2871 #endif
2872         bc_vec_string(&l->lex_buf, i, buf);
2873
2874         // Increment the index. We minus 1 because it has already been incremented.
2875         l->i += i - 1;
2876
2877         //return BC_STATUS_SUCCESS;
2878 }
2879
2880 static void bc_lex_init(void)
2881 {
2882         bc_char_vec_init(&G.prs.l.lex_buf);
2883 }
2884
2885 static void bc_lex_free(void)
2886 {
2887         bc_vec_free(&G.prs.l.lex_buf);
2888 }
2889
2890 static void bc_lex_file(void)
2891 {
2892         G.err_line = G.prs.l.line = 1;
2893         G.prs.l.newline = false;
2894 }
2895
2896 static bool bc_lex_more_input(void)
2897 {
2898         BcLex *l = &G.prs.l;
2899         size_t str;
2900         bool comment;
2901
2902         bc_vec_pop_all(&G.input_buffer);
2903
2904         // This loop is complex because the vm tries not to send any lines that end
2905         // with a backslash to the parser. The reason for that is because the parser
2906         // treats a backslash+newline combo as whitespace, per the bc spec. In that
2907         // case, and for strings and comments, the parser will expect more stuff.
2908         comment = false;
2909         str = 0;
2910         for (;;) {
2911                 size_t prevlen = G.input_buffer.len;
2912                 char *string;
2913
2914                 bc_read_line(&G.input_buffer, G.prs.input_fp);
2915                 // No more input means EOF
2916                 if (G.input_buffer.len <= prevlen + 1) // (we expect +1 for NUL byte)
2917                         break;
2918
2919                 string = G.input_buffer.v + prevlen;
2920                 while (*string) {
2921                         char c = *string;
2922                         if (string == G.input_buffer.v || string[-1] != '\\') {
2923                                 if (IS_BC)
2924                                         str ^= (c == '"');
2925                                 else {
2926                                         if (c == ']')
2927                                                 str -= 1;
2928                                         else if (c == '[')
2929                                                 str += 1;
2930                                 }
2931                         }
2932                         string++;
2933                         if (c == '/' && *string == '*') {
2934                                 comment = true;
2935                                 string++;
2936                                 continue;
2937                         }
2938                         if (c == '*' && *string == '/') {
2939                                 comment = false;
2940                                 string++;
2941                         }
2942                 }
2943                 if (str != 0 || comment) {
2944                         G.input_buffer.len--; // backstep over the trailing NUL byte
2945                         continue;
2946                 }
2947
2948                 // Check for backslash+newline.
2949                 // we do not check that last char is '\n' -
2950                 // if it is not, then it's EOF, and looping back
2951                 // to bc_read_line() will detect it:
2952                 string -= 2;
2953                 if (string >= G.input_buffer.v && *string == '\\') {
2954                         G.input_buffer.len--;
2955                         continue;
2956                 }
2957
2958                 break;
2959         }
2960
2961         l->buf = G.input_buffer.v;
2962         l->i = 0;
2963 //      bb_error_msg("G.input_buffer.len:%d '%s'", G.input_buffer.len, G.input_buffer.v);
2964         l->len = G.input_buffer.len - 1; // do not include NUL
2965
2966         return l->len != 0;
2967 }
2968
2969 IF_BC(static BC_STATUS zbc_lex_token(void);)
2970 IF_DC(static BC_STATUS zdc_lex_token(void);)
2971 #define zbc_lex_token(...) (zbc_lex_token(__VA_ARGS__) COMMA_SUCCESS)
2972 #define zdc_lex_token(...) (zdc_lex_token(__VA_ARGS__) COMMA_SUCCESS)
2973
2974 static BC_STATUS zbc_lex_next(void)
2975 {
2976         BcLex *l = &G.prs.l;
2977         BcStatus s;
2978
2979         l->lex_last = l->lex;
2980         if (l->lex_last == XC_LEX_EOF) RETURN_STATUS(bc_error("end of file"));
2981
2982         l->line += l->newline;
2983         G.err_line = l->line;
2984         l->newline = false;
2985
2986         // Loop until failure or we don't have whitespace. This
2987         // is so the parser doesn't get inundated with whitespace.
2988         // Comments are also XC_LEX_WHITESPACE tokens and eaten here.
2989         s = BC_STATUS_SUCCESS;
2990         do {
2991                 if (l->i == l->len) {
2992                         l->lex = XC_LEX_EOF;
2993                         if (!G.prs.input_fp)
2994                                 RETURN_STATUS(BC_STATUS_SUCCESS);
2995                         if (!bc_lex_more_input()) {
2996                                 G.prs.input_fp = NULL;
2997                                 RETURN_STATUS(BC_STATUS_SUCCESS);
2998                         }
2999                         // here it's guaranteed that l->i is below l->len
3000                 }
3001                 l->lex_next_at = l->buf + l->i;
3002                 dbg_lex("next string to parse:'%.*s'",
3003                         (int)(strchrnul(l->lex_next_at, '\n') - l->lex_next_at),
3004                         l->lex_next_at
3005                 );
3006                 if (IS_BC) {
3007                         IF_BC(s = zbc_lex_token());
3008                 } else {
3009                         IF_DC(s = zdc_lex_token());
3010                 }
3011         } while (!s && l->lex == XC_LEX_WHITESPACE);
3012         dbg_lex("l->lex from string:%d", l->lex);
3013
3014         RETURN_STATUS(s);
3015 }
3016 #define zbc_lex_next(...) (zbc_lex_next(__VA_ARGS__) COMMA_SUCCESS)
3017
3018 #if ENABLE_BC
3019 static BC_STATUS zbc_lex_skip_if_at_NLINE(void)
3020 {
3021         if (G.prs.l.lex == XC_LEX_NLINE)
3022                 RETURN_STATUS(zbc_lex_next());
3023         RETURN_STATUS(BC_STATUS_SUCCESS);
3024 }
3025 #define zbc_lex_skip_if_at_NLINE(...) (zbc_lex_skip_if_at_NLINE(__VA_ARGS__) COMMA_SUCCESS)
3026
3027 static BC_STATUS zbc_lex_next_and_skip_NLINE(void)
3028 {
3029         BcStatus s;
3030         s = zbc_lex_next();
3031         if (s) RETURN_STATUS(s);
3032         // if(cond)<newline>stmt is accepted too (but not 2+ newlines)
3033         s = zbc_lex_skip_if_at_NLINE();
3034         RETURN_STATUS(s);
3035 }
3036 #define zbc_lex_next_and_skip_NLINE(...) (zbc_lex_next_and_skip_NLINE(__VA_ARGS__) COMMA_SUCCESS)
3037 #endif
3038
3039 static BC_STATUS zbc_lex_text_init(const char *text)
3040 {
3041         G.prs.l.buf = text;
3042         G.prs.l.i = 0;
3043         G.prs.l.len = strlen(text);
3044         G.prs.l.lex = G.prs.l.lex_last = XC_LEX_INVALID;
3045         RETURN_STATUS(zbc_lex_next());
3046 }
3047 #define zbc_lex_text_init(...) (zbc_lex_text_init(__VA_ARGS__) COMMA_SUCCESS)
3048
3049 #if ENABLE_BC
3050 static BC_STATUS zbc_lex_identifier(void)
3051 {
3052         BcLex *l = &G.prs.l;
3053         BcStatus s;
3054         unsigned i;
3055         const char *buf = l->buf + l->i - 1;
3056
3057         for (i = 0; i < ARRAY_SIZE(bc_lex_kws); ++i) {
3058                 const char *keyword8 = bc_lex_kws[i].name8;
3059                 unsigned j = 0;
3060                 while (buf[j] != '\0' && buf[j] == keyword8[j]) {
3061                         j++;
3062                         if (j == 8) goto match;
3063                 }
3064                 if (keyword8[j] != '\0')
3065                         continue;
3066  match:
3067                 // buf starts with keyword bc_lex_kws[i]
3068                 if (isalnum(buf[j]) || buf[j]=='_')
3069                         continue; // "ifz" does not match "if" keyword, "if." does
3070                 l->lex = BC_LEX_KEY_1st_keyword + i;
3071                 if (!bc_lex_kws_POSIX(i)) {
3072                         s = zbc_posix_error_fmt("%sthe '%.8s' keyword", "POSIX does not allow ", bc_lex_kws[i].name8);
3073                         if (s) RETURN_STATUS(s);
3074                 }
3075
3076                 // We minus 1 because the index has already been incremented.
3077                 l->i += j - 1;
3078                 RETURN_STATUS(BC_STATUS_SUCCESS);
3079         }
3080
3081         bc_lex_name();
3082         s = BC_STATUS_SUCCESS;
3083
3084         if (l->lex_buf.len > 2) {
3085                 // Prevent this:
3086                 // >>> qwe=1
3087                 // bc: POSIX only allows one character names; this is bad: 'qwe=1
3088                 // '
3089                 unsigned len = strchrnul(buf, '\n') - buf;
3090                 s = zbc_posix_error_fmt("POSIX only allows one character names; this is bad: '%.*s'", len, buf);
3091         }
3092
3093         RETURN_STATUS(s);
3094 }
3095 #define zbc_lex_identifier(...) (zbc_lex_identifier(__VA_ARGS__) COMMA_SUCCESS)
3096
3097 static BC_STATUS zbc_lex_string(void)
3098 {
3099         BcLex *l = &G.prs.l;
3100         size_t len, nls, i;
3101
3102         l->lex = XC_LEX_STR;
3103
3104         nls = 0;
3105         i = l->i;
3106         for (;;) {
3107                 char c = l->buf[i];
3108                 if (c == '\0') {
3109                         l->i = i;
3110                         RETURN_STATUS(bc_error("unterminated string"));
3111                 }
3112                 if (c == '"')
3113                         break;
3114                 nls += (c == '\n');
3115                 i++;
3116         }
3117
3118         len = i - l->i;
3119         // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
3120         if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
3121                 if (len > BC_MAX_STRING)
3122                         RETURN_STATUS(bc_error("string too long: must be [1,"BC_MAX_STRING_STR"]"));
3123         }
3124         bc_vec_string(&l->lex_buf, len, l->buf + l->i);
3125
3126         l->i = i + 1;
3127         l->line += nls;
3128         G.err_line = l->line;
3129
3130         RETURN_STATUS(BC_STATUS_SUCCESS);
3131 }
3132 #define zbc_lex_string(...) (zbc_lex_string(__VA_ARGS__) COMMA_SUCCESS)
3133
3134 static void bc_lex_assign(unsigned with_and_without)
3135 {
3136         BcLex *l = &G.prs.l;
3137         if (l->buf[l->i] == '=') {
3138                 ++l->i;
3139                 with_and_without >>= 8; // store "with" value
3140         } // else store "without" value
3141         l->lex = (with_and_without & 0xff);
3142 }
3143 #define bc_lex_assign(with, without) \
3144         bc_lex_assign(((with)<<8)|(without))
3145
3146 static BC_STATUS zbc_lex_comment(void)
3147 {
3148         BcLex *l = &G.prs.l;
3149         size_t i, nls = 0;
3150         const char *buf = l->buf;
3151
3152         l->lex = XC_LEX_WHITESPACE;
3153         i = l->i; /* here buf[l->i] is the '*' of opening comment delimiter */
3154         for (;;) {
3155                 char c = buf[++i];
3156  check_star:
3157                 if (c == '*') {
3158                         c = buf[++i];
3159                         if (c == '/')
3160                                 break;
3161                         goto check_star;
3162                 }
3163                 if (c == '\0') {
3164                         l->i = i;
3165                         RETURN_STATUS(bc_error("unterminated comment"));
3166                 }
3167                 nls += (c == '\n');
3168         }
3169
3170         l->i = i + 1;
3171         l->line += nls;
3172         G.err_line = l->line;
3173
3174         RETURN_STATUS(BC_STATUS_SUCCESS);
3175 }
3176 #define zbc_lex_comment(...) (zbc_lex_comment(__VA_ARGS__) COMMA_SUCCESS)
3177
3178 #undef zbc_lex_token
3179 static BC_STATUS zbc_lex_token(void)
3180 {
3181         BcLex *l = &G.prs.l;
3182         BcStatus s = BC_STATUS_SUCCESS;
3183         char c = l->buf[l->i++], c2;
3184
3185         // This is the workhorse of the lexer.
3186         switch (c) {
3187 //              case '\0': // probably never reached
3188 //                      l->i--;
3189 //                      l->lex = XC_LEX_EOF;
3190 //                      l->newline = true;
3191 //                      break;
3192                 case '\n':
3193                         l->lex = XC_LEX_NLINE;
3194                         l->newline = true;
3195                         break;
3196                 case '\t':
3197                 case '\v':
3198                 case '\f':
3199                 case '\r':
3200                 case ' ':
3201                         bc_lex_whitespace();
3202                         break;
3203                 case '!':
3204                         bc_lex_assign(XC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT);
3205                         if (l->lex == BC_LEX_OP_BOOL_NOT) {
3206                                 s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("!");
3207                                 if (s) RETURN_STATUS(s);
3208                         }
3209                         break;
3210                 case '"':
3211                         s = zbc_lex_string();
3212                         break;
3213                 case '#':
3214                         s = zbc_POSIX_does_not_allow("'#' script comments");
3215                         if (s) RETURN_STATUS(s);
3216                         bc_lex_lineComment();
3217                         break;
3218                 case '%':
3219                         bc_lex_assign(BC_LEX_OP_ASSIGN_MODULUS, XC_LEX_OP_MODULUS);
3220                         break;
3221                 case '&':
3222                         c2 = l->buf[l->i];
3223                         if (c2 == '&') {
3224                                 s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("&&");
3225                                 if (s) RETURN_STATUS(s);
3226                                 ++l->i;
3227                                 l->lex = BC_LEX_OP_BOOL_AND;
3228                         } else {
3229                                 l->lex = XC_LEX_INVALID;
3230                                 s = bc_error_bad_character('&');
3231                         }
3232                         break;
3233                 case '(':
3234                 case ')':
3235                         l->lex = (BcLexType)(c - '(' + BC_LEX_LPAREN);
3236                         break;
3237                 case '*':
3238                         bc_lex_assign(BC_LEX_OP_ASSIGN_MULTIPLY, XC_LEX_OP_MULTIPLY);
3239                         break;
3240                 case '+':
3241                         c2 = l->buf[l->i];
3242                         if (c2 == '+') {
3243                                 ++l->i;
3244                                 l->lex = BC_LEX_OP_INC;
3245                         } else
3246                                 bc_lex_assign(BC_LEX_OP_ASSIGN_PLUS, XC_LEX_OP_PLUS);
3247                         break;
3248                 case ',':
3249                         l->lex = BC_LEX_COMMA;
3250                         break;
3251                 case '-':
3252                         c2 = l->buf[l->i];
3253                         if (c2 == '-') {
3254                                 ++l->i;
3255                                 l->lex = BC_LEX_OP_DEC;
3256                         } else
3257                                 bc_lex_assign(BC_LEX_OP_ASSIGN_MINUS, XC_LEX_OP_MINUS);
3258                         break;
3259                 case '.':
3260                         if (isdigit(l->buf[l->i]))
3261                                 s = zbc_lex_number(c);
3262                         else {
3263                                 l->lex = BC_LEX_KEY_LAST;
3264                                 s = zbc_POSIX_does_not_allow("'.' as 'last'");
3265                         }
3266                         break;
3267                 case '/':
3268                         c2 = l->buf[l->i];
3269                         if (c2 == '*')
3270                                 s = zbc_lex_comment();
3271                         else
3272                                 bc_lex_assign(BC_LEX_OP_ASSIGN_DIVIDE, XC_LEX_OP_DIVIDE);
3273                         break;
3274                 case '0':
3275                 case '1':
3276                 case '2':
3277                 case '3':
3278                 case '4':
3279                 case '5':
3280                 case '6':
3281                 case '7':
3282                 case '8':
3283                 case '9':
3284                 case 'A':
3285                 case 'B':
3286                 case 'C':
3287                 case 'D':
3288                 case 'E':
3289                 case 'F':
3290                         s = zbc_lex_number(c);
3291                         break;
3292                 case ';':
3293                         l->lex = BC_LEX_SCOLON;
3294                         break;
3295                 case '<':
3296                         bc_lex_assign(XC_LEX_OP_REL_LE, XC_LEX_OP_REL_LT);
3297                         break;
3298                 case '=':
3299                         bc_lex_assign(XC_LEX_OP_REL_EQ, BC_LEX_OP_ASSIGN);
3300                         break;
3301                 case '>':
3302                         bc_lex_assign(XC_LEX_OP_REL_GE, XC_LEX_OP_REL_GT);
3303                         break;
3304                 case '[':
3305                 case ']':
3306                         l->lex = (BcLexType)(c - '[' + BC_LEX_LBRACKET);
3307                         break;
3308                 case '\\':
3309                         if (l->buf[l->i] == '\n') {
3310                                 l->lex = XC_LEX_WHITESPACE;
3311                                 ++l->i;
3312                         } else
3313                                 s = bc_error_bad_character(c);
3314                         break;
3315                 case '^':
3316                         bc_lex_assign(BC_LEX_OP_ASSIGN_POWER, XC_LEX_OP_POWER);
3317                         break;
3318                 case 'a':
3319                 case 'b':
3320                 case 'c':
3321                 case 'd':
3322                 case 'e':
3323                 case 'f':
3324                 case 'g':
3325                 case 'h':
3326                 case 'i':
3327                 case 'j':
3328                 case 'k':
3329                 case 'l':
3330                 case 'm':
3331                 case 'n':
3332                 case 'o':
3333                 case 'p':
3334                 case 'q':
3335                 case 'r':
3336                 case 's':
3337                 case 't':
3338                 case 'u':
3339                 case 'v':
3340                 case 'w':
3341                 case 'x':
3342                 case 'y':
3343                 case 'z':
3344                         s = zbc_lex_identifier();
3345                         break;
3346                 case '{':
3347                 case '}':
3348                         l->lex = (BcLexType)(c - '{' + BC_LEX_LBRACE);
3349                         break;
3350                 case '|':
3351                         c2 = l->buf[l->i];
3352                         if (c2 == '|') {
3353                                 s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("||");
3354                                 if (s) RETURN_STATUS(s);
3355                                 ++l->i;
3356                                 l->lex = BC_LEX_OP_BOOL_OR;
3357                         } else {
3358                                 l->lex = XC_LEX_INVALID;
3359                                 s = bc_error_bad_character(c);
3360                         }
3361                         break;
3362                 default:
3363                         l->lex = XC_LEX_INVALID;
3364                         s = bc_error_bad_character(c);
3365                         break;
3366         }
3367
3368         RETURN_STATUS(s);
3369 }
3370 #define zbc_lex_token(...) (zbc_lex_token(__VA_ARGS__) COMMA_SUCCESS)
3371 #endif // ENABLE_BC
3372
3373 #if ENABLE_DC
3374 static BC_STATUS zdc_lex_register(void)
3375 {
3376         BcLex *l = &G.prs.l;
3377         if (G_exreg && isspace(l->buf[l->i])) {
3378                 bc_lex_whitespace(); // eats whitespace (but not newline)
3379                 l->i++; // bc_lex_name() expects this
3380                 bc_lex_name();
3381         } else {
3382                 bc_vec_pop_all(&l->lex_buf);
3383                 bc_vec_push(&l->lex_buf, &l->buf[l->i++]);
3384                 bc_vec_pushZeroByte(&l->lex_buf);
3385                 l->lex = XC_LEX_NAME;
3386         }
3387
3388         RETURN_STATUS(BC_STATUS_SUCCESS);
3389 }
3390 #define zdc_lex_register(...) (zdc_lex_register(__VA_ARGS__) COMMA_SUCCESS)
3391
3392 static BC_STATUS zdc_lex_string(void)
3393 {
3394         BcLex *l = &G.prs.l;
3395         size_t depth, nls, i;
3396
3397         l->lex = XC_LEX_STR;
3398         bc_vec_pop_all(&l->lex_buf);
3399
3400         nls = 0;
3401         depth = 1;
3402         i = l->i;
3403         for (;;) {
3404                 char c = l->buf[i];
3405                 if (c == '\0') {
3406                         l->i = i;
3407                         RETURN_STATUS(bc_error("string end could not be found"));
3408                 }
3409                 nls += (c == '\n');
3410                 if (i == l->i || l->buf[i - 1] != '\\') {
3411                         if (c == '[') depth++;
3412                         if (c == ']')
3413                                 if (--depth == 0)
3414                                         break;
3415                 }
3416                 bc_vec_push(&l->lex_buf, &l->buf[i]);
3417                 i++;
3418         }
3419         i++;
3420
3421         bc_vec_pushZeroByte(&l->lex_buf);
3422         // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
3423         if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
3424                 if (i - l->i > BC_MAX_STRING)
3425                         RETURN_STATUS(bc_error("string too long: must be [1,"BC_MAX_STRING_STR"]"));
3426         }
3427
3428         l->i = i;
3429         l->line += nls;
3430         G.err_line = l->line;
3431
3432         RETURN_STATUS(BC_STATUS_SUCCESS);
3433 }
3434 #define zdc_lex_string(...) (zdc_lex_string(__VA_ARGS__) COMMA_SUCCESS)
3435
3436 #undef zdc_lex_token
3437 static BC_STATUS zdc_lex_token(void)
3438 {
3439         BcLex *l = &G.prs.l;
3440         static const //BcLexType - should be this type, but narrower type saves size:
3441         uint8_t
3442         dc_lex_regs[] = {
3443                 XC_LEX_OP_REL_EQ, XC_LEX_OP_REL_LE, XC_LEX_OP_REL_GE, XC_LEX_OP_REL_NE,
3444                 XC_LEX_OP_REL_LT, XC_LEX_OP_REL_GT, DC_LEX_SCOLON, DC_LEX_COLON,
3445                 DC_LEX_ELSE, DC_LEX_LOAD, DC_LEX_LOAD_POP, DC_LEX_OP_ASSIGN,
3446                 DC_LEX_STORE_PUSH,
3447         };
3448
3449         BcStatus s;
3450         char c, c2;
3451         size_t i;
3452
3453         for (i = 0; i < ARRAY_SIZE(dc_lex_regs); ++i) {
3454                 if (l->lex_last == dc_lex_regs[i])
3455                         RETURN_STATUS(zdc_lex_register());
3456         }
3457
3458         s = BC_STATUS_SUCCESS;
3459         c = l->buf[l->i++];
3460         if (c >= '%' && c <= '~'
3461          && (l->lex = dc_char_to_LEX[c - '%']) != XC_LEX_INVALID
3462         ) {
3463                 RETURN_STATUS(s);
3464         }
3465
3466         // This is the workhorse of the lexer.
3467         switch (c) {
3468 //              case '\0': // probably never reached
3469 //                      l->lex = XC_LEX_EOF;
3470 //                      break;
3471                 case '\n':
3472                         // '\n' is XC_LEX_NLINE, not XC_LEX_WHITESPACE
3473                         // (and "case '\n':" is not just empty here)
3474                         // only to allow interactive dc have a way to exit
3475                         // "parse" stage of "parse,execute" loop
3476                         // on <enter>, not on _next_ token (which would mean
3477                         // commands are not executed on pressing <enter>).
3478                         // IOW: typing "1p<enter>" should print "1" _at once_,
3479                         // not after some more input.
3480                         l->lex = XC_LEX_NLINE;
3481                         l->newline = true;
3482                         break;
3483                 case '\t':
3484                 case '\v':
3485                 case '\f':
3486                 case '\r':
3487                 case ' ':
3488                         l->newline = 0; // was (c == '\n')
3489                         bc_lex_whitespace();
3490                         break;
3491                 case '!':
3492                         c2 = l->buf[l->i];
3493                         if (c2 == '=')
3494                                 l->lex = XC_LEX_OP_REL_NE;
3495                         else if (c2 == '<')
3496                                 l->lex = XC_LEX_OP_REL_LE;
3497                         else if (c2 == '>')
3498                                 l->lex = XC_LEX_OP_REL_GE;
3499                         else
3500                                 RETURN_STATUS(bc_error_bad_character(c));
3501                         ++l->i;
3502                         break;
3503                 case '#':
3504                         bc_lex_lineComment();
3505                         break;
3506                 case '.':
3507                         if (isdigit(l->buf[l->i]))
3508                                 s = zbc_lex_number(c);
3509                         else
3510                                 s = bc_error_bad_character(c);
3511                         break;
3512                 case '0':
3513                 case '1':
3514                 case '2':
3515                 case '3':
3516                 case '4':
3517                 case '5':
3518                 case '6':
3519                 case '7':
3520                 case '8':
3521                 case '9':
3522                 case 'A':
3523                 case 'B':
3524                 case 'C':
3525                 case 'D':
3526                 case 'E':
3527                 case 'F':
3528                         s = zbc_lex_number(c);
3529                         break;
3530                 case '[':
3531                         s = zdc_lex_string();
3532                         break;
3533                 default:
3534                         l->lex = XC_LEX_INVALID;
3535                         s = bc_error_bad_character(c);
3536                         break;
3537         }
3538
3539         RETURN_STATUS(s);
3540 }
3541 #define zdc_lex_token(...) (zdc_lex_token(__VA_ARGS__) COMMA_SUCCESS)
3542 #endif // ENABLE_DC
3543
3544 static void bc_parse_push(char i)
3545 {
3546         BcParse *p = &G.prs;
3547         dbg_compile("%s:%d pushing bytecode %zd:%d", __func__, __LINE__, p->func->code.len, i);
3548         bc_vec_pushByte(&p->func->code, i);
3549 }
3550
3551 static void bc_parse_pushName(char *name)
3552 {
3553         while (*name)
3554                 bc_parse_push(*name++);
3555         bc_parse_push(BC_PARSE_STREND);
3556 }
3557
3558 static void bc_parse_pushIndex(size_t idx)
3559 {
3560         size_t mask;
3561         unsigned amt;
3562
3563         dbg_lex("%s:%d pushing index %zd", __func__, __LINE__, idx);
3564         mask = ((size_t)0xff) << (sizeof(idx) * 8 - 8);
3565         amt = sizeof(idx);
3566         do {
3567                 if (idx & mask) break;
3568                 mask >>= 8;
3569                 amt--;
3570         } while (amt != 0);
3571
3572         bc_parse_push(amt);
3573
3574         while (idx != 0) {
3575                 bc_parse_push((unsigned char)idx);
3576                 idx >>= 8;
3577         }
3578 }
3579
3580 #if ENABLE_BC
3581 static void bc_parse_pushJUMP(size_t idx)
3582 {
3583         bc_parse_push(BC_INST_JUMP);
3584         bc_parse_pushIndex(idx);
3585 }
3586
3587 static void bc_parse_pushJUMP_ZERO(size_t idx)
3588 {
3589         bc_parse_push(BC_INST_JUMP_ZERO);
3590         bc_parse_pushIndex(idx);
3591 }
3592
3593 static BC_STATUS zbc_parse_pushSTR(void)
3594 {
3595         BcParse *p = &G.prs;
3596         char *str = xstrdup(p->l.lex_buf.v);
3597
3598         bc_parse_push(XC_INST_STR);
3599         bc_parse_pushIndex(p->func->strs.len);
3600         bc_vec_push(&p->func->strs, &str);
3601
3602         RETURN_STATUS(zbc_lex_next());
3603 }
3604 #define zbc_parse_pushSTR(...) (zbc_parse_pushSTR(__VA_ARGS__) COMMA_SUCCESS)
3605 #endif
3606
3607 static void bc_parse_pushNUM(void)
3608 {
3609         BcParse *p = &G.prs;
3610         char *num = xstrdup(p->l.lex_buf.v);
3611 #if ENABLE_BC && ENABLE_DC
3612         size_t idx = bc_vec_push(IS_BC ? &p->func->consts : &G.prog.consts, &num);
3613 #elif ENABLE_BC
3614         size_t idx = bc_vec_push(&p->func->consts, &num);
3615 #else // DC
3616         size_t idx = bc_vec_push(&G.prog.consts, &num);
3617 #endif
3618         bc_parse_push(XC_INST_NUM);
3619         bc_parse_pushIndex(idx);
3620 }
3621
3622 static BC_STATUS zbc_parse_text_init(const char *text)
3623 {
3624         BcParse *p = &G.prs;
3625         p->func = bc_program_func(p->fidx);
3626
3627         RETURN_STATUS(zbc_lex_text_init(text));
3628 }
3629 #define zbc_parse_text_init(...) (zbc_parse_text_init(__VA_ARGS__) COMMA_SUCCESS)
3630
3631 // Called when parsing or execution detects a failure,
3632 // resets execution structures.
3633 static void bc_program_reset(void)
3634 {
3635         BcFunc *f;
3636         BcInstPtr *ip;
3637
3638         bc_vec_npop(&G.prog.exestack, G.prog.exestack.len - 1);
3639         bc_vec_pop_all(&G.prog.results);
3640
3641         f = bc_program_func_BC_PROG_MAIN();
3642         ip = bc_vec_top(&G.prog.exestack);
3643         ip->inst_idx = f->code.len;
3644 }
3645
3646 // Called when parsing code detects a failure,
3647 // resets parsing structures.
3648 static void bc_parse_reset(void)
3649 {
3650         BcParse *p = &G.prs;
3651         if (p->fidx != BC_PROG_MAIN) {
3652                 bc_func_free(p->func);
3653                 bc_func_init(p->func);
3654
3655                 p->fidx = BC_PROG_MAIN;
3656                 p->func = bc_program_func_BC_PROG_MAIN();
3657         }
3658
3659         p->l.i = p->l.len;
3660         p->l.lex = XC_LEX_EOF;
3661
3662         IF_BC(bc_vec_pop_all(&p->exits);)
3663         IF_BC(bc_vec_pop_all(&p->conds);)
3664         IF_BC(bc_vec_pop_all(&p->ops);)
3665
3666         bc_program_reset();
3667 }
3668
3669 static void bc_parse_free(void)
3670 {
3671         BcParse *p = &G.prs;
3672         IF_BC(bc_vec_free(&p->exits);)
3673         IF_BC(bc_vec_free(&p->conds);)
3674         IF_BC(bc_vec_free(&p->ops);)
3675         bc_lex_free();
3676 }
3677
3678 static void bc_parse_create(size_t fidx)
3679 {
3680         BcParse *p = &G.prs;
3681         memset(p, 0, sizeof(BcParse));
3682
3683         bc_lex_init();
3684         IF_BC(bc_vec_init(&p->exits, sizeof(size_t), NULL);)
3685         IF_BC(bc_vec_init(&p->conds, sizeof(size_t), NULL);)
3686         IF_BC(bc_vec_init(&p->ops, sizeof(BcLexType), NULL);)
3687
3688         p->fidx = fidx;
3689         p->func = bc_program_func(fidx);
3690 }
3691
3692 static void bc_program_add_fn(void)
3693 {
3694         //size_t idx;
3695         BcFunc f;
3696         bc_func_init(&f);
3697         //idx =
3698         bc_vec_push(&G.prog.fns, &f);
3699         //return idx;
3700 }
3701
3702 #if ENABLE_BC
3703
3704 // Note: takes ownership of 'name' (must be malloced)
3705 static size_t bc_program_addFunc(char *name)
3706 {
3707         size_t idx;
3708         BcId entry, *entry_ptr;
3709         int inserted;
3710
3711         entry.name = name;
3712         entry.idx = G.prog.fns.len;
3713
3714         inserted = bc_map_insert(&G.prog.fn_map, &entry, &idx);
3715         if (!inserted) free(name);
3716
3717         entry_ptr = bc_vec_item(&G.prog.fn_map, idx);
3718         idx = entry_ptr->idx;
3719
3720         if (!inserted) {
3721                 // There is already a function with this name.
3722                 // It'll be redefined now, clear old definition.
3723                 BcFunc *func = bc_program_func(entry_ptr->idx);
3724                 bc_func_free(func);
3725                 bc_func_init(func);
3726         } else {
3727                 bc_program_add_fn();
3728         }
3729
3730         return idx;
3731 }
3732
3733 #define BC_PARSE_TOP_OP(p) (*(BcLexType*)bc_vec_top(&(p)->ops))
3734 // We can calculate the conversion between tokens and exprs by subtracting the
3735 // position of the first operator in the lex enum and adding the position of the
3736 // first in the expr enum. Note: This only works for binary operators.
3737 #define BC_TOKEN_2_INST(t) ((char) ((t) - XC_LEX_OP_POWER + XC_INST_POWER))
3738
3739 static BcStatus bc_parse_expr_empty_ok(uint8_t flags);
3740
3741 static BC_STATUS zbc_parse_expr(uint8_t flags)
3742 {
3743         BcStatus s;
3744
3745         s = bc_parse_expr_empty_ok(flags);
3746         if (s == BC_STATUS_PARSE_EMPTY_EXP)
3747                 RETURN_STATUS(bc_error("empty expression"));
3748         RETURN_STATUS(s);
3749 }
3750 #define zbc_parse_expr(...) (zbc_parse_expr(__VA_ARGS__) COMMA_SUCCESS)
3751
3752 static BC_STATUS zbc_parse_stmt_possibly_auto(bool auto_allowed);
3753 #define zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__) COMMA_SUCCESS)
3754
3755 static BC_STATUS zbc_parse_stmt(void)
3756 {
3757         RETURN_STATUS(zbc_parse_stmt_possibly_auto(false));
3758 }
3759 #define zbc_parse_stmt(...) (zbc_parse_stmt(__VA_ARGS__) COMMA_SUCCESS)
3760
3761 static BC_STATUS zbc_parse_stmt_allow_NLINE_before(const char *after_X)
3762 {
3763         BcParse *p = &G.prs;
3764         // "if(cond)<newline>stmt" is accepted too, but not 2+ newlines.
3765         // Same for "else", "while()", "for()".
3766         BcStatus s = zbc_lex_next_and_skip_NLINE();
3767         if (s) RETURN_STATUS(s);
3768         if (p->l.lex == XC_LEX_NLINE)
3769                 RETURN_STATUS(bc_error_fmt("no statement after '%s'", after_X));
3770
3771         RETURN_STATUS(zbc_parse_stmt());
3772 }
3773 #define zbc_parse_stmt_allow_NLINE_before(...) (zbc_parse_stmt_allow_NLINE_before(__VA_ARGS__) COMMA_SUCCESS)
3774
3775 static void bc_parse_operator(BcLexType type, size_t start, size_t *nexprs)
3776 {
3777         BcParse *p = &G.prs;
3778         char l, r = bc_parse_op_PREC(type - XC_LEX_1st_op);
3779         bool left = bc_parse_op_LEFT(type - XC_LEX_1st_op);
3780
3781         while (p->ops.len > start) {
3782                 BcLexType t = BC_PARSE_TOP_OP(p);
3783                 if (t == BC_LEX_LPAREN) break;
3784
3785                 l = bc_parse_op_PREC(t - XC_LEX_1st_op);
3786                 if (l >= r && (l != r || !left)) break;
3787
3788                 bc_parse_push(BC_TOKEN_2_INST(t));
3789                 bc_vec_pop(&p->ops);
3790                 *nexprs -= (t != BC_LEX_OP_BOOL_NOT && t != XC_LEX_NEG);
3791         }
3792
3793         bc_vec_push(&p->ops, &type);
3794 }
3795
3796 static BC_STATUS zbc_parse_rightParen(size_t ops_bgn, size_t *nexs)
3797 {
3798         BcParse *p = &G.prs;
3799         BcLexType top;
3800
3801         if (p->ops.len <= ops_bgn)
3802                 RETURN_STATUS(bc_error_bad_expression());
3803         top = BC_PARSE_TOP_OP(p);
3804
3805         while (top != BC_LEX_LPAREN) {
3806                 bc_parse_push(BC_TOKEN_2_INST(top));
3807
3808                 bc_vec_pop(&p->ops);
3809                 *nexs -= (top != BC_LEX_OP_BOOL_NOT && top != XC_LEX_NEG);
3810
3811                 if (p->ops.len <= ops_bgn)
3812                         RETURN_STATUS(bc_error_bad_expression());
3813                 top = BC_PARSE_TOP_OP(p);
3814         }
3815
3816         bc_vec_pop(&p->ops);
3817
3818         RETURN_STATUS(BC_STATUS_SUCCESS);
3819 }
3820 #define zbc_parse_rightParen(...) (zbc_parse_rightParen(__VA_ARGS__) COMMA_SUCCESS)
3821
3822 static BC_STATUS zbc_parse_params(uint8_t flags)
3823 {
3824         BcParse *p = &G.prs;
3825         BcStatus s;
3826         size_t nparams;
3827
3828         dbg_lex("%s:%d p->l.lex:%d", __func__, __LINE__, p->l.lex);
3829         flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
3830
3831         s = zbc_lex_next();
3832         if (s) RETURN_STATUS(s);
3833
3834         nparams = 0;
3835         if (p->l.lex != BC_LEX_RPAREN) {
3836                 for (;;) {
3837                         s = zbc_parse_expr(flags);
3838                         if (s) RETURN_STATUS(s);
3839                         nparams++;
3840                         if (p->l.lex != BC_LEX_COMMA) {
3841                                 if (p->l.lex == BC_LEX_RPAREN)
3842                                         break;
3843                                 RETURN_STATUS(bc_error_bad_token());
3844                         }
3845                         s = zbc_lex_next();
3846                         if (s) RETURN_STATUS(s);
3847                 }
3848         }
3849
3850         bc_parse_push(BC_INST_CALL);
3851         bc_parse_pushIndex(nparams);
3852
3853         RETURN_STATUS(BC_STATUS_SUCCESS);
3854 }
3855 #define zbc_parse_params(...) (zbc_parse_params(__VA_ARGS__) COMMA_SUCCESS)
3856
3857 // Note: takes ownership of 'name' (must be malloced)
3858 static BC_STATUS zbc_parse_call(char *name, uint8_t flags)
3859 {
3860         BcParse *p = &G.prs;
3861         BcStatus s;
3862         BcId entry, *entry_ptr;
3863         size_t idx;
3864
3865         entry.name = name;
3866
3867         s = zbc_parse_params(flags);
3868         if (s) goto err;
3869
3870         if (p->l.lex != BC_LEX_RPAREN) {
3871                 s = bc_error_bad_token();
3872                 goto err;
3873         }
3874
3875         idx = bc_map_find_exact(&G.prog.fn_map, &entry);
3876
3877         if (idx == BC_VEC_INVALID_IDX) {
3878                 // No such function exists, create an empty one
3879                 bc_program_addFunc(name);
3880                 idx = bc_map_find_exact(&G.prog.fn_map, &entry);
3881         } else
3882                 free(name);
3883
3884         entry_ptr = bc_vec_item(&G.prog.fn_map, idx);
3885         bc_parse_pushIndex(entry_ptr->idx);
3886
3887         RETURN_STATUS(zbc_lex_next());
3888  err:
3889         free(name);
3890         RETURN_STATUS(s);
3891 }
3892 #define zbc_parse_call(...) (zbc_parse_call(__VA_ARGS__) COMMA_SUCCESS)
3893
3894 static BC_STATUS zbc_parse_name(BcInst *type, uint8_t flags)
3895 {
3896         BcParse *p = &G.prs;
3897         BcStatus s;
3898         char *name;
3899
3900         name = xstrdup(p->l.lex_buf.v);
3901         s = zbc_lex_next();
3902         if (s) goto err;
3903
3904         if (p->l.lex == BC_LEX_LBRACKET) {
3905                 s = zbc_lex_next();
3906                 if (s) goto err;
3907
3908                 if (p->l.lex == BC_LEX_RBRACKET) {
3909                         if (!(flags & BC_PARSE_ARRAY)) {
3910                                 s = bc_error_bad_expression();
3911                                 goto err;
3912                         }
3913                         *type = XC_INST_ARRAY;
3914                 } else {
3915                         *type = XC_INST_ARRAY_ELEM;
3916                         flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
3917                         s = zbc_parse_expr(flags);
3918                         if (s) goto err;
3919                 }
3920                 s = zbc_lex_next();
3921                 if (s) goto err;
3922                 bc_parse_push(*type);
3923                 bc_parse_pushName(name);
3924                 free(name);
3925         } else if (p->l.lex == BC_LEX_LPAREN) {
3926                 if (flags & BC_PARSE_NOCALL) {
3927                         s = bc_error_bad_token();
3928                         goto err;
3929                 }
3930                 *type = BC_INST_CALL;
3931                 s = zbc_parse_call(name, flags);
3932         } else {
3933                 *type = XC_INST_VAR;
3934                 bc_parse_push(XC_INST_VAR);
3935                 bc_parse_pushName(name);
3936                 free(name);
3937         }
3938
3939         RETURN_STATUS(s);
3940  err:
3941         free(name);
3942         RETURN_STATUS(s);
3943 }
3944 #define zbc_parse_name(...) (zbc_parse_name(__VA_ARGS__) COMMA_SUCCESS)
3945
3946 static BC_STATUS zbc_parse_read(void)
3947 {
3948         BcParse *p = &G.prs;
3949         BcStatus s;
3950
3951         s = zbc_lex_next();
3952         if (s) RETURN_STATUS(s);
3953         if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
3954
3955         s = zbc_lex_next();
3956         if (s) RETURN_STATUS(s);
3957         if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
3958
3959         bc_parse_push(XC_INST_READ);
3960
3961         RETURN_STATUS(s);
3962 }
3963 #define zbc_parse_read(...) (zbc_parse_read(__VA_ARGS__) COMMA_SUCCESS)
3964
3965 static BC_STATUS zbc_parse_builtin(BcLexType type, uint8_t flags, BcInst *prev)
3966 {
3967         BcParse *p = &G.prs;
3968         BcStatus s;
3969
3970         s = zbc_lex_next();
3971         if (s) RETURN_STATUS(s);
3972         if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
3973
3974         flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
3975
3976         s = zbc_lex_next();
3977         if (s) RETURN_STATUS(s);
3978
3979         s = zbc_parse_expr(flags);
3980         if (s) RETURN_STATUS(s);
3981
3982         if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
3983
3984         *prev = (type == BC_LEX_KEY_LENGTH) ? XC_INST_LENGTH : XC_INST_SQRT;
3985         bc_parse_push(*prev);
3986
3987         RETURN_STATUS(s);
3988 }
3989 #define zbc_parse_builtin(...) (zbc_parse_builtin(__VA_ARGS__) COMMA_SUCCESS)
3990
3991 static BC_STATUS zbc_parse_scale(BcInst *type, uint8_t flags)
3992 {
3993         BcParse *p = &G.prs;
3994         BcStatus s;
3995
3996         s = zbc_lex_next();
3997         if (s) RETURN_STATUS(s);
3998
3999         if (p->l.lex != BC_LEX_LPAREN) {
4000                 *type = XC_INST_SCALE;
4001                 bc_parse_push(XC_INST_SCALE);
4002                 RETURN_STATUS(BC_STATUS_SUCCESS);
4003         }
4004
4005         *type = XC_INST_SCALE_FUNC;
4006         flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
4007
4008         s = zbc_lex_next();
4009         if (s) RETURN_STATUS(s);
4010
4011         s = zbc_parse_expr(flags);
4012         if (s) RETURN_STATUS(s);
4013         if (p->l.lex != BC_LEX_RPAREN)
4014                 RETURN_STATUS(bc_error_bad_token());
4015         bc_parse_push(XC_INST_SCALE_FUNC);
4016
4017         RETURN_STATUS(zbc_lex_next());
4018 }
4019 #define zbc_parse_scale(...) (zbc_parse_scale(__VA_ARGS__) COMMA_SUCCESS)
4020
4021 static BC_STATUS zbc_parse_incdec(BcInst *prev, bool *paren_expr,
4022                                 size_t *nexprs, uint8_t flags)
4023 {
4024         BcParse *p = &G.prs;
4025         BcStatus s;
4026         BcLexType type;
4027         char inst;
4028         BcInst etype = *prev;
4029
4030         if (etype == XC_INST_VAR || etype == XC_INST_ARRAY_ELEM
4031          || etype == XC_INST_SCALE || etype == BC_INST_LAST
4032          || etype == XC_INST_IBASE || etype == XC_INST_OBASE
4033         ) {
4034                 *prev = inst = BC_INST_INC_POST + (p->l.lex != BC_LEX_OP_INC);
4035                 bc_parse_push(inst);
4036                 s = zbc_lex_next();
4037         } else {
4038                 *prev = inst = BC_INST_INC_PRE + (p->l.lex != BC_LEX_OP_INC);
4039                 *paren_expr = true;
4040
4041                 s = zbc_lex_next();
4042                 if (s) RETURN_STATUS(s);
4043                 type = p->l.lex;
4044
4045                 // Because we parse the next part of the expression
4046                 // right here, we need to increment this.
4047                 *nexprs = *nexprs + 1;
4048
4049                 switch (type) {
4050                         case XC_LEX_NAME:
4051                                 s = zbc_parse_name(prev, flags | BC_PARSE_NOCALL);
4052                                 break;
4053                         case BC_LEX_KEY_IBASE:
4054                         case BC_LEX_KEY_LAST:
4055                         case BC_LEX_KEY_OBASE:
4056                                 bc_parse_push(type - BC_LEX_KEY_IBASE + XC_INST_IBASE);
4057                                 s = zbc_lex_next();
4058                                 break;
4059                         case BC_LEX_KEY_SCALE:
4060                                 s = zbc_lex_next();
4061                                 if (s) RETURN_STATUS(s);
4062                                 if (p->l.lex == BC_LEX_LPAREN)
4063                                         s = bc_error_bad_token();
4064                                 else
4065                                         bc_parse_push(XC_INST_SCALE);
4066                                 break;
4067                         default:
4068                                 s = bc_error_bad_token();
4069                                 break;
4070                 }
4071
4072                 if (!s) bc_parse_push(inst);
4073         }
4074
4075         RETURN_STATUS(s);
4076 }
4077 #define zbc_parse_incdec(...) (zbc_parse_incdec(__VA_ARGS__) COMMA_SUCCESS)
4078
4079 #if 0
4080 #define BC_PARSE_LEAF(p, rparen) \
4081         ((rparen) \
4082          || ((p) >= XC_INST_NUM && (p) <= XC_INST_SQRT) \
4083          || (p) == BC_INST_INC_POST \
4084          || (p) == BC_INST_DEC_POST \
4085         )
4086 #else
4087 static int ok_in_expr(BcInst p)
4088 {
4089         return (p >= XC_INST_NUM && p <= XC_INST_SQRT)
4090                 || p == BC_INST_INC_POST
4091                 || p == BC_INST_DEC_POST
4092                 ;
4093 }
4094 #define BC_PARSE_LEAF(p, rparen) ((rparen) || ok_in_expr(p))
4095 #endif
4096
4097 static BC_STATUS zbc_parse_minus(BcInst *prev, size_t ops_bgn,
4098                                 bool rparen, size_t *nexprs)
4099 {
4100         BcParse *p = &G.prs;
4101         BcStatus s;
4102         BcLexType type;
4103         BcInst etype = *prev;
4104
4105         s = zbc_lex_next();
4106         if (s) RETURN_STATUS(s);
4107
4108         type = BC_PARSE_LEAF(etype, rparen) ? XC_LEX_OP_MINUS : XC_LEX_NEG;
4109         *prev = BC_TOKEN_2_INST(type);
4110
4111         // We can just push onto the op stack because this is the largest
4112         // precedence operator that gets pushed. Inc/dec does not.
4113         if (type != XC_LEX_OP_MINUS)
4114                 bc_vec_push(&p->ops, &type);
4115         else
4116                 bc_parse_operator(type, ops_bgn, nexprs);
4117
4118         RETURN_STATUS(s);
4119 }
4120 #define zbc_parse_minus(...) (zbc_parse_minus(__VA_ARGS__) COMMA_SUCCESS)
4121
4122 static BC_STATUS zbc_parse_print(void)
4123 {
4124         BcParse *p = &G.prs;
4125         BcStatus s;
4126         BcLexType type;
4127
4128         for (;;) {
4129                 s = zbc_lex_next();
4130                 if (s) RETURN_STATUS(s);
4131                 type = p->l.lex;
4132                 if (type == XC_LEX_STR) {
4133                         s = zbc_parse_pushSTR();
4134                 } else {
4135                         s = zbc_parse_expr(0);
4136                 }
4137                 if (s) RETURN_STATUS(s);
4138                 bc_parse_push(XC_INST_PRINT_POP);
4139                 if (p->l.lex != BC_LEX_COMMA)
4140                         break;
4141         }
4142
4143         RETURN_STATUS(s);
4144 }
4145 #define zbc_parse_print(...) (zbc_parse_print(__VA_ARGS__) COMMA_SUCCESS)
4146
4147 static BC_STATUS zbc_parse_return(void)
4148 {
4149         BcParse *p = &G.prs;
4150         BcStatus s;
4151         BcLexType t;
4152
4153         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4154         s = zbc_lex_next();
4155         if (s) RETURN_STATUS(s);
4156
4157         t = p->l.lex;
4158         if (t == XC_LEX_NLINE || t == BC_LEX_SCOLON)
4159                 bc_parse_push(BC_INST_RET0);
4160         else {
4161                 bool paren = (t == BC_LEX_LPAREN);
4162                 s = bc_parse_expr_empty_ok(0);
4163                 if (s == BC_STATUS_PARSE_EMPTY_EXP) {
4164                         bc_parse_push(BC_INST_RET0);
4165                         s = zbc_lex_next();
4166                 }
4167                 if (s) RETURN_STATUS(s);
4168
4169                 if (!paren || p->l.lex_last != BC_LEX_RPAREN) {
4170                         s = zbc_POSIX_requires("parentheses around return expressions");
4171                         if (s) RETURN_STATUS(s);
4172                 }
4173
4174                 bc_parse_push(XC_INST_RET);
4175         }
4176
4177         dbg_lex_done("%s:%d done", __func__, __LINE__);
4178         RETURN_STATUS(s);
4179 }
4180 #define zbc_parse_return(...) (zbc_parse_return(__VA_ARGS__) COMMA_SUCCESS)
4181
4182 static void rewrite_label_to_current(size_t idx)
4183 {
4184         BcParse *p = &G.prs;
4185         size_t *label = bc_vec_item(&p->func->labels, idx);
4186         *label = p->func->code.len;
4187 }
4188
4189 static BC_STATUS zbc_parse_if(void)
4190 {
4191         BcParse *p = &G.prs;
4192         BcStatus s;
4193         size_t ip_idx;
4194
4195         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4196         s = zbc_lex_next();
4197         if (s) RETURN_STATUS(s);
4198         if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
4199
4200         s = zbc_lex_next();
4201         if (s) RETURN_STATUS(s);
4202         s = zbc_parse_expr(BC_PARSE_REL);
4203         if (s) RETURN_STATUS(s);
4204         if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
4205
4206         // Encode "if zero, jump to ..."
4207         // Pushed value (destination of the jump) is uninitialized,
4208         // will be rewritten to be address of "end of if()" or of "else".
4209         ip_idx = bc_vec_push(&p->func->labels, &ip_idx);
4210         bc_parse_pushJUMP_ZERO(ip_idx);
4211
4212         s = zbc_parse_stmt_allow_NLINE_before(STRING_if);
4213         if (s) RETURN_STATUS(s);
4214
4215         dbg_lex("%s:%d in if after stmt: p->l.lex:%d", __func__, __LINE__, p->l.lex);
4216         if (p->l.lex == BC_LEX_KEY_ELSE) {
4217                 size_t ip2_idx;
4218
4219                 // Encode "after then_stmt, jump to end of if()"
4220                 ip2_idx = bc_vec_push(&p->func->labels, &ip2_idx);
4221                 dbg_lex("%s:%d after if() then_stmt: BC_INST_JUMP to %zd", __func__, __LINE__, ip2_idx);
4222                 bc_parse_pushJUMP(ip2_idx);
4223
4224                 dbg_lex("%s:%d rewriting 'if_zero' label to jump to 'else'-> %zd", __func__, __LINE__, p->func->code.len);
4225                 rewrite_label_to_current(ip_idx);
4226
4227                 ip_idx = ip2_idx;
4228
4229                 s = zbc_parse_stmt_allow_NLINE_before(STRING_else);
4230                 if (s) RETURN_STATUS(s);
4231         }
4232
4233         dbg_lex("%s:%d rewriting label to jump after 'if' body-> %zd", __func__, __LINE__, p->func->code.len);
4234         rewrite_label_to_current(ip_idx);
4235
4236         dbg_lex_done("%s:%d done", __func__, __LINE__);
4237         RETURN_STATUS(s);
4238 }
4239 #define zbc_parse_if(...) (zbc_parse_if(__VA_ARGS__) COMMA_SUCCESS)
4240
4241 static BC_STATUS zbc_parse_while(void)
4242 {
4243         BcParse *p = &G.prs;
4244         BcStatus s;
4245         size_t cond_idx;
4246         size_t ip_idx;
4247
4248         s = zbc_lex_next();
4249         if (s) RETURN_STATUS(s);
4250         if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
4251         s = zbc_lex_next();
4252         if (s) RETURN_STATUS(s);
4253
4254         cond_idx = bc_vec_push(&p->func->labels, &p->func->code.len);
4255         ip_idx = cond_idx + 1;
4256         bc_vec_push(&p->conds, &cond_idx);
4257
4258         bc_vec_push(&p->exits, &ip_idx);
4259         bc_vec_push(&p->func->labels, &ip_idx);
4260
4261         s = zbc_parse_expr(BC_PARSE_REL);
4262         if (s) RETURN_STATUS(s);
4263         if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
4264
4265         bc_parse_pushJUMP_ZERO(ip_idx);
4266
4267         s = zbc_parse_stmt_allow_NLINE_before(STRING_while);
4268         if (s) RETURN_STATUS(s);
4269
4270         dbg_lex("%s:%d BC_INST_JUMP to %zd", __func__, __LINE__, cond_idx);
4271         bc_parse_pushJUMP(cond_idx);
4272
4273         dbg_lex("%s:%d rewriting label-> %zd", __func__, __LINE__, p->func->code.len);
4274         rewrite_label_to_current(ip_idx);
4275
4276         bc_vec_pop(&p->exits);
4277         bc_vec_pop(&p->conds);
4278
4279         RETURN_STATUS(s);
4280 }
4281 #define zbc_parse_while(...) (zbc_parse_while(__VA_ARGS__) COMMA_SUCCESS)
4282
4283 static BC_STATUS zbc_parse_for(void)
4284 {
4285         BcParse *p = &G.prs;
4286         BcStatus s;
4287         size_t cond_idx, exit_idx, body_idx, update_idx;
4288
4289         dbg_lex("%s:%d p->l.lex:%d", __func__, __LINE__, p->l.lex);
4290         s = zbc_lex_next();
4291         if (s) RETURN_STATUS(s);
4292         if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
4293         s = zbc_lex_next();
4294         if (s) RETURN_STATUS(s);
4295
4296         if (p->l.lex != BC_LEX_SCOLON) {
4297                 s = zbc_parse_expr(0);
4298                 bc_parse_push(XC_INST_POP);
4299                 if (s) RETURN_STATUS(s);
4300         } else {
4301                 s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("init");
4302                 if (s) RETURN_STATUS(s);
4303         }
4304
4305         if (p->l.lex != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
4306         s = zbc_lex_next();
4307         if (s) RETURN_STATUS(s);
4308
4309         cond_idx = bc_vec_push(&p->func->labels, &p->func->code.len);
4310         update_idx = cond_idx + 1;
4311         body_idx = update_idx + 1;
4312         exit_idx = body_idx + 1;
4313
4314         if (p->l.lex != BC_LEX_SCOLON)
4315                 s = zbc_parse_expr(BC_PARSE_REL);
4316         else {
4317                 // Set this for the next call to bc_parse_pushNUM().
4318                 // This is safe to set because the current token is a semicolon,
4319                 // which has no string requirement.
4320                 bc_vec_string(&p->l.lex_buf, 1, "1");
4321                 bc_parse_pushNUM();
4322                 s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("condition");
4323         }
4324         if (s) RETURN_STATUS(s);
4325
4326         if (p->l.lex != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
4327
4328         s = zbc_lex_next();
4329         if (s) RETURN_STATUS(s);
4330
4331         bc_parse_pushJUMP_ZERO(exit_idx);
4332         bc_parse_pushJUMP(body_idx);
4333
4334         bc_vec_push(&p->conds, &update_idx);
4335         bc_vec_push(&p->func->labels, &p->func->code.len);
4336
4337         if (p->l.lex != BC_LEX_RPAREN) {
4338                 s = zbc_parse_expr(0);
4339                 if (s) RETURN_STATUS(s);
4340                 if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
4341                 bc_parse_push(XC_INST_POP);
4342         } else {
4343                 s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("update");
4344                 if (s) RETURN_STATUS(s);
4345         }
4346
4347         bc_parse_pushJUMP(cond_idx);
4348         bc_vec_push(&p->func->labels, &p->func->code.len);
4349
4350         bc_vec_push(&p->exits, &exit_idx);
4351         bc_vec_push(&p->func->labels, &exit_idx);
4352
4353         s = zbc_parse_stmt_allow_NLINE_before(STRING_for);
4354         if (s) RETURN_STATUS(s);
4355
4356         dbg_lex("%s:%d BC_INST_JUMP to %zd", __func__, __LINE__, update_idx);
4357         bc_parse_pushJUMP(update_idx);
4358
4359         dbg_lex("%s:%d rewriting label-> %zd", __func__, __LINE__, p->func->code.len);
4360         rewrite_label_to_current(exit_idx);
4361
4362         bc_vec_pop(&p->exits);
4363         bc_vec_pop(&p->conds);
4364
4365         RETURN_STATUS(BC_STATUS_SUCCESS);
4366 }
4367 #define zbc_parse_for(...) (zbc_parse_for(__VA_ARGS__) COMMA_SUCCESS)
4368
4369 static BC_STATUS zbc_parse_break_or_continue(BcLexType type)
4370 {
4371         BcParse *p = &G.prs;
4372         size_t i;
4373
4374         if (type == BC_LEX_KEY_BREAK) {
4375                 if (p->exits.len == 0) // none of the enclosing blocks is a loop
4376                         RETURN_STATUS(bc_error_bad_token());
4377                 i = *(size_t*)bc_vec_top(&p->exits);
4378         } else {
4379                 i = *(size_t*)bc_vec_top(&p->conds);
4380         }
4381         bc_parse_pushJUMP(i);
4382
4383         RETURN_STATUS(zbc_lex_next());
4384 }
4385 #define zbc_parse_break_or_continue(...) (zbc_parse_break_or_continue(__VA_ARGS__) COMMA_SUCCESS)
4386
4387 static BC_STATUS zbc_func_insert(BcFunc *f, char *name, bool var)
4388 {
4389         BcId *autoid;
4390         BcId a;
4391         size_t i;
4392
4393         autoid = (void*)f->autos.v;
4394         for (i = 0; i < f->autos.len; i++, autoid++) {
4395                 if (strcmp(name, autoid->name) == 0)
4396                         RETURN_STATUS(bc_error("duplicate function parameter or auto name"));
4397         }
4398
4399         a.idx = var;
4400         a.name = name;
4401
4402         bc_vec_push(&f->autos, &a);
4403
4404         RETURN_STATUS(BC_STATUS_SUCCESS);
4405 }
4406 #define zbc_func_insert(...) (zbc_func_insert(__VA_ARGS__) COMMA_SUCCESS)
4407
4408 static BC_STATUS zbc_parse_funcdef(void)
4409 {
4410         BcParse *p = &G.prs;
4411         BcStatus s;
4412         bool var, comma = false;
4413         char *name;
4414
4415         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4416         s = zbc_lex_next();
4417         if (s) RETURN_STATUS(s);
4418         if (p->l.lex != XC_LEX_NAME)
4419                 RETURN_STATUS(bc_error("bad function definition"));
4420
4421         name = xstrdup(p->l.lex_buf.v);
4422         p->fidx = bc_program_addFunc(name);
4423         p->func = bc_program_func(p->fidx);
4424
4425         s = zbc_lex_next();
4426         if (s) RETURN_STATUS(s);
4427         if (p->l.lex != BC_LEX_LPAREN)
4428                 RETURN_STATUS(bc_error("bad function definition"));
4429         s = zbc_lex_next();
4430         if (s) RETURN_STATUS(s);
4431
4432         while (p->l.lex != BC_LEX_RPAREN) {
4433                 if (p->l.lex != XC_LEX_NAME)
4434                         RETURN_STATUS(bc_error("bad function definition"));
4435
4436                 ++p->func->nparams;
4437
4438                 name = xstrdup(p->l.lex_buf.v);
4439                 s = zbc_lex_next();
4440                 if (s) goto err;
4441
4442                 var = p->l.lex != BC_LEX_LBRACKET;
4443
4444                 if (!var) {
4445                         s = zbc_lex_next();
4446                         if (s) goto err;
4447
4448                         if (p->l.lex != BC_LEX_RBRACKET) {
4449                                 s = bc_error("bad function definition");
4450                                 goto err;
4451                         }
4452
4453                         s = zbc_lex_next();
4454                         if (s) goto err;
4455                 }
4456
4457                 comma = p->l.lex == BC_LEX_COMMA;
4458                 if (comma) {
4459                         s = zbc_lex_next();
4460                         if (s) goto err;
4461                 }
4462
4463                 s = zbc_func_insert(p->func, name, var);
4464                 if (s) goto err;
4465         }
4466
4467         if (comma) RETURN_STATUS(bc_error("bad function definition"));
4468
4469         s = zbc_lex_next();
4470         if (s) RETURN_STATUS(s);
4471
4472         if (p->l.lex != BC_LEX_LBRACE) {
4473                 s = zbc_POSIX_requires("the left brace be on the same line as the function header");
4474                 if (s) RETURN_STATUS(s);
4475         }
4476
4477         // Prevent "define z()<newline>" from being interpreted as function with empty stmt as body
4478         s = zbc_lex_skip_if_at_NLINE();
4479         if (s) RETURN_STATUS(s);
4480         //GNU bc requires a {} block even if function body has single stmt, enforce this?
4481         if (p->l.lex != BC_LEX_LBRACE)
4482                 RETURN_STATUS(bc_error("function { body } expected"));
4483
4484         p->in_funcdef++; // to determine whether "return" stmt is allowed, and such
4485         s = zbc_parse_stmt_possibly_auto(true);
4486         p->in_funcdef--;
4487         if (s) RETURN_STATUS(s);
4488
4489         bc_parse_push(BC_INST_RET0);
4490
4491         // Subsequent code generation is into main program
4492         p->fidx = BC_PROG_MAIN;
4493         p->func = bc_program_func_BC_PROG_MAIN();
4494
4495         dbg_lex_done("%s:%d done", __func__, __LINE__);
4496         RETURN_STATUS(s);
4497  err:
4498         dbg_lex_done("%s:%d done (error)", __func__, __LINE__);
4499         free(name);
4500         RETURN_STATUS(s);
4501 }
4502 #define zbc_parse_funcdef(...) (zbc_parse_funcdef(__VA_ARGS__) COMMA_SUCCESS)
4503
4504 static BC_STATUS zbc_parse_auto(void)
4505 {
4506         BcParse *p = &G.prs;
4507         BcStatus s;
4508         char *name;
4509
4510         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4511         s = zbc_lex_next();
4512         if (s) RETURN_STATUS(s);
4513
4514         for (;;) {
4515                 bool var;
4516
4517                 if (p->l.lex != XC_LEX_NAME)
4518                         RETURN_STATUS(bc_error("bad 'auto' syntax"));
4519
4520                 name = xstrdup(p->l.lex_buf.v);
4521                 s = zbc_lex_next();
4522                 if (s) goto err;
4523
4524                 var = (p->l.lex != BC_LEX_LBRACKET);
4525                 if (!var) {
4526                         s = zbc_lex_next();
4527                         if (s) goto err;
4528
4529                         if (p->l.lex != BC_LEX_RBRACKET) {
4530                                 s = bc_error("bad 'auto' syntax");
4531                                 goto err;
4532                         }
4533                         s = zbc_lex_next();
4534                         if (s) goto err;
4535                 }
4536
4537                 s = zbc_func_insert(p->func, name, var);
4538                 if (s) goto err;
4539
4540                 if (p->l.lex == XC_LEX_NLINE
4541                  || p->l.lex == BC_LEX_SCOLON
4542                 //|| p->l.lex == BC_LEX_RBRACE // allow "define f() {auto a}"
4543                 ) {
4544                         break;
4545                 }
4546                 if (p->l.lex != BC_LEX_COMMA)
4547                         RETURN_STATUS(bc_error("bad 'auto' syntax"));
4548                 s = zbc_lex_next(); // skip comma
4549                 if (s) RETURN_STATUS(s);
4550         }
4551
4552         dbg_lex_done("%s:%d done", __func__, __LINE__);
4553         RETURN_STATUS(BC_STATUS_SUCCESS);
4554  err:
4555         free(name);
4556         dbg_lex_done("%s:%d done (ERROR)", __func__, __LINE__);
4557         RETURN_STATUS(s);
4558 }
4559 #define zbc_parse_auto(...) (zbc_parse_auto(__VA_ARGS__) COMMA_SUCCESS)
4560
4561 #undef zbc_parse_stmt_possibly_auto
4562 static BC_STATUS zbc_parse_stmt_possibly_auto(bool auto_allowed)
4563 {
4564         BcParse *p = &G.prs;
4565         BcStatus s = BC_STATUS_SUCCESS;
4566
4567         dbg_lex_enter("%s:%d entered, p->l.lex:%d", __func__, __LINE__, p->l.lex);
4568
4569         if (p->l.lex == XC_LEX_NLINE) {
4570                 dbg_lex_done("%s:%d done (seen XC_LEX_NLINE)", __func__, __LINE__);
4571                 RETURN_STATUS(zbc_lex_next());
4572         }
4573         if (p->l.lex == BC_LEX_SCOLON) {
4574                 dbg_lex_done("%s:%d done (seen BC_LEX_SCOLON)", __func__, __LINE__);
4575                 RETURN_STATUS(zbc_lex_next());
4576         }
4577
4578         if (p->l.lex == BC_LEX_LBRACE) {
4579                 dbg_lex("%s:%d BC_LEX_LBRACE: (auto_allowed:%d)", __func__, __LINE__, auto_allowed);
4580                 do {
4581                         s = zbc_lex_next();
4582                         if (s) RETURN_STATUS(s);
4583                 } while (p->l.lex == XC_LEX_NLINE);
4584                 if (auto_allowed && p->l.lex == BC_LEX_KEY_AUTO) {
4585                         dbg_lex("%s:%d calling zbc_parse_auto()", __func__, __LINE__);
4586                         s = zbc_parse_auto();
4587                         if (s) RETURN_STATUS(s);
4588                 }
4589                 while (p->l.lex != BC_LEX_RBRACE) {
4590                         dbg_lex("%s:%d block parsing loop", __func__, __LINE__);
4591                         s = zbc_parse_stmt();
4592                         if (s) RETURN_STATUS(s);
4593                 }
4594                 s = zbc_lex_next();
4595                 dbg_lex_done("%s:%d done (seen BC_LEX_RBRACE)", __func__, __LINE__);
4596                 RETURN_STATUS(s);
4597         }
4598
4599         dbg_lex("%s:%d p->l.lex:%d", __func__, __LINE__, p->l.lex);
4600         switch (p->l.lex) {
4601                 case XC_LEX_OP_MINUS:
4602                 case BC_LEX_OP_INC:
4603                 case BC_LEX_OP_DEC:
4604                 case BC_LEX_OP_BOOL_NOT:
4605                 case BC_LEX_LPAREN:
4606                 case XC_LEX_NAME:
4607                 case XC_LEX_NUMBER:
4608                 case BC_LEX_KEY_IBASE:
4609                 case BC_LEX_KEY_LAST:
4610                 case BC_LEX_KEY_LENGTH:
4611                 case BC_LEX_KEY_OBASE:
4612                 case BC_LEX_KEY_READ:
4613                 case BC_LEX_KEY_SCALE:
4614                 case BC_LEX_KEY_SQRT:
4615                         s = zbc_parse_expr(BC_PARSE_PRINT);
4616                         break;
4617                 case XC_LEX_STR:
4618                         s = zbc_parse_pushSTR();
4619                         bc_parse_push(XC_INST_PRINT_STR);
4620                         break;
4621                 case BC_LEX_KEY_BREAK:
4622                 case BC_LEX_KEY_CONTINUE:
4623                         s = zbc_parse_break_or_continue(p->l.lex);
4624                         break;
4625                 case BC_LEX_KEY_FOR:
4626                         s = zbc_parse_for();
4627                         break;
4628                 case BC_LEX_KEY_HALT:
4629                         bc_parse_push(BC_INST_HALT);
4630                         s = zbc_lex_next();
4631                         break;
4632                 case BC_LEX_KEY_IF:
4633                         s = zbc_parse_if();
4634                         break;
4635                 case BC_LEX_KEY_LIMITS:
4636                         // "limits" is a compile-time command,
4637                         // the output is produced at _parse time_.
4638                         printf(
4639                                 "BC_BASE_MAX     = "BC_MAX_OBASE_STR "\n"
4640                                 "BC_DIM_MAX      = "BC_MAX_DIM_STR   "\n"
4641                                 "BC_SCALE_MAX    = "BC_MAX_SCALE_STR "\n"
4642                                 "BC_STRING_MAX   = "BC_MAX_STRING_STR"\n"
4643                                 "BC_NAME_MAX     = "BC_MAX_NAME_STR  "\n"
4644                                 "BC_NUM_MAX      = "BC_MAX_NUM_STR   "\n"
4645                                 "MAX Exponent    = "BC_MAX_EXP_STR   "\n"
4646                                 "Number of vars  = "BC_MAX_VARS_STR  "\n"
4647                         );
4648                         s = zbc_lex_next();
4649                         break;
4650                 case BC_LEX_KEY_PRINT:
4651                         s = zbc_parse_print();
4652                         break;
4653                 case BC_LEX_KEY_QUIT:
4654                         // "quit" is a compile-time command. For example,
4655                         // "if (0 == 1) quit" terminates when parsing the statement,
4656                         // not when it is executed
4657                         QUIT_OR_RETURN_TO_MAIN;
4658                 case BC_LEX_KEY_RETURN:
4659                         if (!p->in_funcdef)
4660                                 RETURN_STATUS(bc_error("'return' not in a function"));
4661                         s = zbc_parse_return();
4662                         break;
4663                 case BC_LEX_KEY_WHILE:
4664                         s = zbc_parse_while();
4665                         break;
4666                 default:
4667                         s = bc_error_bad_token();
4668                         break;
4669         }
4670
4671         dbg_lex_done("%s:%d done", __func__, __LINE__);
4672         RETURN_STATUS(s);
4673 }
4674 #define zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__) COMMA_SUCCESS)
4675
4676 static BC_STATUS zbc_parse_stmt_or_funcdef(void)
4677 {
4678         BcParse *p = &G.prs;
4679         BcStatus s;
4680
4681         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4682         if (p->l.lex == XC_LEX_EOF)
4683                 s = bc_error("end of file");
4684         else if (p->l.lex == BC_LEX_KEY_DEFINE) {
4685                 dbg_lex("%s:%d p->l.lex:BC_LEX_KEY_DEFINE", __func__, __LINE__);
4686                 s = zbc_parse_funcdef();
4687         } else {
4688                 dbg_lex("%s:%d p->l.lex:%d (not BC_LEX_KEY_DEFINE)", __func__, __LINE__, p->l.lex);
4689                 s = zbc_parse_stmt();
4690         }
4691
4692         dbg_lex_done("%s:%d done", __func__, __LINE__);
4693         RETURN_STATUS(s);
4694 }
4695 #define zbc_parse_stmt_or_funcdef(...) (zbc_parse_stmt_or_funcdef(__VA_ARGS__) COMMA_SUCCESS)
4696
4697 // This is not a "z" function: can also return BC_STATUS_PARSE_EMPTY_EXP
4698 static BcStatus bc_parse_expr_empty_ok(uint8_t flags)
4699 {
4700         BcParse *p = &G.prs;
4701         BcInst prev = XC_INST_PRINT;
4702         size_t nexprs = 0, ops_bgn = p->ops.len;
4703         unsigned nparens, nrelops;
4704         bool paren_first, paren_expr, rprn, assign, bin_last;
4705
4706         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4707         paren_first = (p->l.lex == BC_LEX_LPAREN);
4708         nparens = nrelops = 0;
4709         paren_expr = rprn = assign = false;
4710         bin_last = true;
4711
4712         for (;;) {
4713                 bool get_token;
4714                 BcStatus s;
4715                 BcLexType t = p->l.lex;
4716
4717                 if (!lex_allowed_in_bc_expr(t))
4718                         break;
4719
4720                 dbg_lex("%s:%d t:%d", __func__, __LINE__, t);
4721                 get_token = false;
4722                 s = BC_STATUS_SUCCESS;
4723                 switch (t) {
4724                         case BC_LEX_OP_INC:
4725                         case BC_LEX_OP_DEC:
4726                                 s = zbc_parse_incdec(&prev, &paren_expr, &nexprs, flags);
4727                                 rprn = bin_last = false;
4728                                 //get_token = false; - already is
4729                                 break;
4730                         case XC_LEX_OP_MINUS:
4731                                 s = zbc_parse_minus(&prev, ops_bgn, rprn, &nexprs);
4732                                 rprn = false;
4733                                 //get_token = false; - already is
4734                                 bin_last = (prev == XC_INST_MINUS);
4735                                 break;
4736                         case BC_LEX_OP_ASSIGN_POWER:
4737                         case BC_LEX_OP_ASSIGN_MULTIPLY:
4738                         case BC_LEX_OP_ASSIGN_DIVIDE:
4739                         case BC_LEX_OP_ASSIGN_MODULUS:
4740                         case BC_LEX_OP_ASSIGN_PLUS:
4741                         case BC_LEX_OP_ASSIGN_MINUS:
4742                         case BC_LEX_OP_ASSIGN:
4743                                 if (prev != XC_INST_VAR && prev != XC_INST_ARRAY_ELEM
4744                                  && prev != XC_INST_SCALE && prev != XC_INST_IBASE
4745                                  && prev != XC_INST_OBASE && prev != BC_INST_LAST
4746                                 ) {
4747                                         return bc_error("bad assignment:"
4748                                                 " left side must be variable"
4749                                                 " or array element"
4750                                         ); // note: shared string
4751                                 }
4752                         // Fallthrough.
4753                         case XC_LEX_OP_POWER:
4754                         case XC_LEX_OP_MULTIPLY:
4755                         case XC_LEX_OP_DIVIDE:
4756                         case XC_LEX_OP_MODULUS:
4757                         case XC_LEX_OP_PLUS:
4758                         case XC_LEX_OP_REL_EQ:
4759                         case XC_LEX_OP_REL_LE:
4760                         case XC_LEX_OP_REL_GE:
4761                         case XC_LEX_OP_REL_NE:
4762                         case XC_LEX_OP_REL_LT:
4763                         case XC_LEX_OP_REL_GT:
4764                         case BC_LEX_OP_BOOL_NOT:
4765                         case BC_LEX_OP_BOOL_OR:
4766                         case BC_LEX_OP_BOOL_AND:
4767                                 if (((t == BC_LEX_OP_BOOL_NOT) != bin_last)
4768                                  || (t != BC_LEX_OP_BOOL_NOT && prev == XC_INST_BOOL_NOT)
4769                                 ) {
4770                                         return bc_error_bad_expression();
4771                                 }
4772                                 nrelops += (t >= XC_LEX_OP_REL_EQ && t <= XC_LEX_OP_REL_GT);
4773                                 prev = BC_TOKEN_2_INST(t);
4774                                 bc_parse_operator(t, ops_bgn, &nexprs);
4775                                 s = zbc_lex_next();
4776                                 rprn = false;
4777                                 //get_token = false; - already is
4778                                 bin_last = (t != BC_LEX_OP_BOOL_NOT);
4779                                 break;
4780                         case BC_LEX_LPAREN:
4781                                 if (BC_PARSE_LEAF(prev, rprn))
4782                                         return bc_error_bad_expression();
4783                                 bc_vec_push(&p->ops, &t);
4784                                 nparens++;
4785                                 get_token = true;
4786                                 paren_expr = false;
4787                                 rprn = bin_last = false;
4788                                 break;
4789                         case BC_LEX_RPAREN:
4790                                 if (bin_last || prev == XC_INST_BOOL_NOT)
4791                                         return bc_error_bad_expression();
4792                                 if (nparens == 0) {
4793                                         goto exit_loop;
4794                                 }
4795                                 if (!paren_expr) {
4796                                         dbg_lex_done("%s:%d done (returning EMPTY_EXP)", __func__, __LINE__);
4797                                         return BC_STATUS_PARSE_EMPTY_EXP;
4798                                 }
4799                                 s = zbc_parse_rightParen(ops_bgn, &nexprs);
4800                                 nparens--;
4801                                 get_token = true;
4802                                 paren_expr = rprn = true;
4803                                 bin_last = false;
4804                                 break;
4805                         case XC_LEX_NAME:
4806                                 if (BC_PARSE_LEAF(prev, rprn))
4807                                         return bc_error_bad_expression();
4808                                 s = zbc_parse_name(&prev, flags & ~BC_PARSE_NOCALL);
4809                                 paren_expr = true;
4810                                 rprn = bin_last = false;
4811                                 //get_token = false; - already is
4812                                 nexprs++;
4813                                 break;
4814                         case XC_LEX_NUMBER:
4815                                 if (BC_PARSE_LEAF(prev, rprn))
4816                                         return bc_error_bad_expression();
4817                                 bc_parse_pushNUM();
4818                                 prev = XC_INST_NUM;
4819                                 get_token = true;
4820                                 paren_expr = true;
4821                                 rprn = bin_last = false;
4822                                 nexprs++;
4823                                 break;
4824                         case BC_LEX_KEY_IBASE:
4825                         case BC_LEX_KEY_LAST:
4826                         case BC_LEX_KEY_OBASE:
4827                                 if (BC_PARSE_LEAF(prev, rprn))
4828                                         return bc_error_bad_expression();
4829                                 prev = (char) (t - BC_LEX_KEY_IBASE + XC_INST_IBASE);
4830                                 bc_parse_push((char) prev);
4831                                 get_token = true;
4832                                 paren_expr = true;
4833                                 rprn = bin_last = false;
4834                                 nexprs++;
4835                                 break;
4836                         case BC_LEX_KEY_LENGTH:
4837                         case BC_LEX_KEY_SQRT:
4838                                 if (BC_PARSE_LEAF(prev, rprn))
4839                                         return bc_error_bad_expression();
4840                                 s = zbc_parse_builtin(t, flags, &prev);
4841                                 get_token = true;
4842                                 paren_expr = true;
4843                                 rprn = bin_last = false;
4844                                 nexprs++;
4845                                 break;
4846                         case BC_LEX_KEY_READ:
4847                                 if (BC_PARSE_LEAF(prev, rprn))
4848                                         return bc_error_bad_expression();
4849                                 s = zbc_parse_read();
4850                                 prev = XC_INST_READ;
4851                                 get_token = true;
4852                                 paren_expr = true;
4853                                 rprn = bin_last = false;
4854                                 nexprs++;
4855                                 break;
4856                         case BC_LEX_KEY_SCALE:
4857                                 if (BC_PARSE_LEAF(prev, rprn))
4858                                         return bc_error_bad_expression();
4859                                 s = zbc_parse_scale(&prev, flags);
4860                                 prev = XC_INST_SCALE;
4861                                 //get_token = false; - already is
4862                                 paren_expr = true;
4863                                 rprn = bin_last = false;
4864                                 nexprs++;
4865                                 break;
4866                         default:
4867                                 return bc_error_bad_token();
4868                 }
4869
4870                 if (s || G_interrupt) // error, or ^C: stop parsing
4871                         return BC_STATUS_FAILURE;
4872                 if (get_token) {
4873                         s = zbc_lex_next();
4874                         if (s) return s;
4875                 }
4876         }
4877  exit_loop:
4878
4879         while (p->ops.len > ops_bgn) {
4880                 BcLexType top = BC_PARSE_TOP_OP(p);
4881                 assign = (top >= BC_LEX_OP_ASSIGN_POWER && top <= BC_LEX_OP_ASSIGN);
4882
4883                 if (top == BC_LEX_LPAREN || top == BC_LEX_RPAREN)
4884                         return bc_error_bad_expression();
4885
4886                 bc_parse_push(BC_TOKEN_2_INST(top));
4887
4888                 nexprs -= (top != BC_LEX_OP_BOOL_NOT && top != XC_LEX_NEG);
4889                 bc_vec_pop(&p->ops);
4890         }
4891
4892         if (prev == XC_INST_BOOL_NOT || nexprs != 1)
4893                 return bc_error_bad_expression();
4894
4895         if (!(flags & BC_PARSE_REL) && nrelops) {
4896                 BcStatus s;
4897                 s = zbc_POSIX_does_not_allow("comparison operators outside if or loops");
4898                 if (s) return s;
4899         } else if ((flags & BC_PARSE_REL) && nrelops > 1) {
4900                 BcStatus s;
4901                 s = zbc_POSIX_requires("exactly one comparison operator per condition");
4902                 if (s) return s;
4903         }
4904
4905         if (flags & BC_PARSE_PRINT) {
4906                 if (paren_first || !assign)
4907                         bc_parse_push(XC_INST_PRINT);
4908                 bc_parse_push(XC_INST_POP);
4909         }
4910
4911         dbg_lex_done("%s:%d done", __func__, __LINE__);
4912         return BC_STATUS_SUCCESS;
4913 }
4914
4915 #endif // ENABLE_BC
4916
4917 #if ENABLE_DC
4918
4919 static BC_STATUS zdc_parse_register(void)
4920 {
4921         BcParse *p = &G.prs;
4922         BcStatus s;
4923
4924         s = zbc_lex_next();
4925         if (s) RETURN_STATUS(s);
4926         if (p->l.lex != XC_LEX_NAME) RETURN_STATUS(bc_error_bad_token());
4927
4928         bc_parse_pushName(p->l.lex_buf.v);
4929
4930         RETURN_STATUS(s);
4931 }
4932 #define zdc_parse_register(...) (zdc_parse_register(__VA_ARGS__) COMMA_SUCCESS)
4933
4934 static void dc_parse_string(void)
4935 {
4936         BcParse *p = &G.prs;
4937         char *str;
4938         size_t len = G.prog.strs.len;
4939
4940         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4941
4942         str = xstrdup(p->l.lex_buf.v);
4943         bc_parse_push(XC_INST_STR);
4944         bc_parse_pushIndex(len);
4945         bc_vec_push(&G.prog.strs, &str);
4946
4947         // Explanation needed here
4948         bc_program_add_fn();
4949         p->func = bc_program_func(p->fidx);
4950
4951         dbg_lex_done("%s:%d done", __func__, __LINE__);
4952 }
4953
4954 static BC_STATUS zdc_parse_mem(uint8_t inst, bool name, bool store)
4955 {
4956         BcStatus s;
4957
4958         bc_parse_push(inst);
4959         if (name) {
4960                 s = zdc_parse_register();
4961                 if (s) RETURN_STATUS(s);
4962         }
4963
4964         if (store) {
4965                 bc_parse_push(DC_INST_SWAP);
4966                 bc_parse_push(XC_INST_ASSIGN);
4967                 bc_parse_push(XC_INST_POP);
4968         }
4969
4970         RETURN_STATUS(BC_STATUS_SUCCESS);
4971 }
4972 #define zdc_parse_mem(...) (zdc_parse_mem(__VA_ARGS__) COMMA_SUCCESS)
4973
4974 static BC_STATUS zdc_parse_cond(uint8_t inst)
4975 {
4976         BcParse *p = &G.prs;
4977         BcStatus s;
4978
4979         bc_parse_push(inst);
4980         bc_parse_push(DC_INST_EXEC_COND);
4981
4982         s = zdc_parse_register();
4983         if (s) RETURN_STATUS(s);
4984
4985         s = zbc_lex_next();
4986         if (s) RETURN_STATUS(s);
4987
4988         // Note that 'else' part can not be on the next line:
4989         // echo -e '[1p]sa [2p]sb 2 1>a eb' | dc - OK, prints "2"
4990         // echo -e '[1p]sa [2p]sb 2 1>a\neb' | dc - parse error
4991         if (p->l.lex == DC_LEX_ELSE) {
4992                 s = zdc_parse_register();
4993                 if (s) RETURN_STATUS(s);
4994                 s = zbc_lex_next();
4995         } else {
4996                 bc_parse_push(BC_PARSE_STREND);
4997         }
4998
4999         RETURN_STATUS(s);
5000 }
5001 #define zdc_parse_cond(...) (zdc_parse_cond(__VA_ARGS__) COMMA_SUCCESS)
5002
5003 static BC_STATUS zdc_parse_token(BcLexType t)
5004 {
5005         BcStatus s;
5006         uint8_t inst;
5007         bool assign, get_token;
5008
5009         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
5010         s = BC_STATUS_SUCCESS;
5011         get_token = true;
5012         switch (t) {
5013                 case XC_LEX_OP_REL_EQ:
5014                 case XC_LEX_OP_REL_LE:
5015                 case XC_LEX_OP_REL_GE:
5016                 case XC_LEX_OP_REL_NE:
5017                 case XC_LEX_OP_REL_LT:
5018                 case XC_LEX_OP_REL_GT:
5019                         dbg_lex("%s:%d LEX_OP_REL_xyz", __func__, __LINE__);
5020                         s = zdc_parse_cond(t - XC_LEX_OP_REL_EQ + XC_INST_REL_EQ);
5021                         get_token = false;
5022                         break;
5023                 case DC_LEX_SCOLON:
5024                 case DC_LEX_COLON:
5025                         dbg_lex("%s:%d LEX_[S]COLON", __func__, __LINE__);
5026                         s = zdc_parse_mem(XC_INST_ARRAY_ELEM, true, t == DC_LEX_COLON);
5027                         break;
5028                 case XC_LEX_STR:
5029                         dbg_lex("%s:%d LEX_STR", __func__, __LINE__);
5030                         dc_parse_string();
5031                         break;
5032                 case XC_LEX_NEG:
5033                         dbg_lex("%s:%d LEX_NEG", __func__, __LINE__);
5034                         s = zbc_lex_next();
5035                         if (s) RETURN_STATUS(s);
5036                         if (G.prs.l.lex != XC_LEX_NUMBER)
5037                                 RETURN_STATUS(bc_error_bad_token());
5038                         bc_parse_pushNUM();
5039                         bc_parse_push(XC_INST_NEG);
5040                         break;
5041                 case XC_LEX_NUMBER:
5042                         dbg_lex("%s:%d LEX_NUMBER", __func__, __LINE__);
5043                         bc_parse_pushNUM();
5044                         break;
5045                 case DC_LEX_READ:
5046                         dbg_lex("%s:%d LEX_KEY_READ", __func__, __LINE__);
5047                         bc_parse_push(XC_INST_READ);
5048                         break;
5049                 case DC_LEX_OP_ASSIGN:
5050                 case DC_LEX_STORE_PUSH:
5051                         dbg_lex("%s:%d LEX_OP_ASSIGN/STORE_PUSH", __func__, __LINE__);
5052                         assign = (t == DC_LEX_OP_ASSIGN);
5053                         inst = assign ? XC_INST_VAR : DC_INST_PUSH_TO_VAR;
5054                         s = zdc_parse_mem(inst, true, assign);
5055                         break;
5056                 case DC_LEX_LOAD:
5057                 case DC_LEX_LOAD_POP:
5058                         dbg_lex("%s:%d LEX_OP_LOAD[_POP]", __func__, __LINE__);
5059                         inst = t == DC_LEX_LOAD_POP ? DC_INST_PUSH_VAR : DC_INST_LOAD;
5060                         s = zdc_parse_mem(inst, true, false);
5061                         break;
5062                 case DC_LEX_STORE_IBASE:
5063                 case DC_LEX_STORE_SCALE:
5064                 case DC_LEX_STORE_OBASE:
5065                         dbg_lex("%s:%d LEX_OP_STORE_I/OBASE/SCALE", __func__, __LINE__);
5066                         inst = t - DC_LEX_STORE_IBASE + XC_INST_IBASE;
5067                         s = zdc_parse_mem(inst, false, true);
5068                         break;
5069                 default:
5070                         dbg_lex_done("%s:%d done (bad token)", __func__, __LINE__);
5071                         RETURN_STATUS(bc_error_bad_token());
5072         }
5073
5074         if (!s && get_token) s = zbc_lex_next();
5075
5076         dbg_lex_done("%s:%d done", __func__, __LINE__);
5077         RETURN_STATUS(s);
5078 }
5079 #define zdc_parse_token(...) (zdc_parse_token(__VA_ARGS__) COMMA_SUCCESS)
5080
5081 static BC_STATUS zdc_parse_expr(void)
5082 {
5083         BcParse *p = &G.prs;
5084         int i;
5085
5086         i = (int)p->l.lex - (int)XC_LEX_OP_POWER;
5087         if (i >= 0) {
5088                 BcInst inst = dc_LEX_to_INST[i];
5089                 if (inst != DC_INST_INVALID) {
5090                         bc_parse_push(inst);
5091                         RETURN_STATUS(zbc_lex_next());
5092                 }
5093         }
5094         RETURN_STATUS(zdc_parse_token(p->l.lex));
5095 }
5096 #define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__) COMMA_SUCCESS)
5097
5098 static BC_STATUS zdc_parse_exprs_until_eof(void)
5099 {
5100         BcParse *p = &G.prs;
5101         dbg_lex_enter("%s:%d entered, p->l.lex:%d", __func__, __LINE__, p->l.lex);
5102         while (p->l.lex != XC_LEX_EOF) {
5103                 BcStatus s = zdc_parse_expr();
5104                 if (s) RETURN_STATUS(s);
5105         }
5106
5107         dbg_lex_done("%s:%d done", __func__, __LINE__);
5108         RETURN_STATUS(BC_STATUS_SUCCESS);
5109 }
5110 #define zdc_parse_exprs_until_eof(...) (zdc_parse_exprs_until_eof(__VA_ARGS__) COMMA_SUCCESS)
5111
5112 #endif // ENABLE_DC
5113
5114 //
5115 // Execution engine
5116 //
5117
5118 #define STACK_HAS_MORE_THAN(s, n)          ((s)->len > ((size_t)(n)))
5119 #define STACK_HAS_EQUAL_OR_MORE_THAN(s, n) ((s)->len >= ((size_t)(n)))
5120
5121 static BcVec* bc_program_search(char *id, bool var)
5122 {
5123         BcId e, *ptr;
5124         BcVec *v, *map;
5125         size_t i;
5126         int new;
5127
5128         v = var ? &G.prog.vars : &G.prog.arrs;
5129         map = var ? &G.prog.var_map : &G.prog.arr_map;
5130
5131         e.name = id;
5132         e.idx = v->len;
5133         new = bc_map_insert(map, &e, &i); // 1 if insertion was successful
5134
5135         if (new) {
5136                 BcVec v2;
5137                 bc_array_init(&v2, var);
5138                 bc_vec_push(v, &v2);
5139         }
5140
5141         ptr = bc_vec_item(map, i);
5142         if (new) ptr->name = xstrdup(e.name);
5143         return bc_vec_item(v, ptr->idx);
5144 }
5145
5146 // 'num' need not be initialized on entry
5147 static BC_STATUS zbc_program_num(BcResult *r, BcNum **num, bool hex)
5148 {
5149         switch (r->t) {
5150                 case XC_RESULT_STR:
5151                 case XC_RESULT_TEMP:
5152                 case XC_RESULT_IBASE:
5153                 case XC_RESULT_SCALE:
5154                 case XC_RESULT_OBASE:
5155                         *num = &r->d.n;
5156                         break;
5157                 case XC_RESULT_CONSTANT: {
5158                         BcStatus s;
5159                         char *str;
5160                         unsigned base_t;
5161                         size_t len;
5162
5163                         str = *bc_program_const(r->d.id.idx);
5164                         len = strlen(str);
5165
5166                         bc_num_init(&r->d.n, len);
5167
5168                         hex = hex && len == 1;
5169                         base_t = hex ? 16 : G.prog.ib_t;
5170                         s = zbc_num_parse(&r->d.n, str, base_t);
5171                         if (s) {
5172                                 bc_num_free(&r->d.n);
5173                                 RETURN_STATUS(s);
5174                         }
5175                         *num = &r->d.n;
5176                         r->t = XC_RESULT_TEMP;
5177                         break;
5178                 }
5179                 case XC_RESULT_VAR:
5180                 case XC_RESULT_ARRAY:
5181                 case XC_RESULT_ARRAY_ELEM: {
5182                         BcVec *v;
5183
5184                         v = bc_program_search(r->d.id.name, r->t == XC_RESULT_VAR);
5185
5186                         if (r->t == XC_RESULT_ARRAY_ELEM) {
5187                                 v = bc_vec_top(v);
5188                                 if (v->len <= r->d.id.idx) bc_array_expand(v, r->d.id.idx + 1);
5189                                 *num = bc_vec_item(v, r->d.id.idx);
5190                         } else
5191                                 *num = bc_vec_top(v);
5192                         break;
5193                 }
5194 #if ENABLE_BC
5195                 case BC_RESULT_LAST:
5196                         *num = &G.prog.last;
5197                         break;
5198                 case BC_RESULT_ONE:
5199                         *num = &G.prog.one;
5200                         break;
5201 #endif
5202 #if SANITY_CHECKS
5203                 default:
5204                         // Testing the theory that dc does not reach LAST/ONE
5205                         bb_error_msg_and_die("BUG:%d", r->t);
5206 #endif
5207         }
5208
5209         RETURN_STATUS(BC_STATUS_SUCCESS);
5210 }
5211 #define zbc_program_num(...) (zbc_program_num(__VA_ARGS__) COMMA_SUCCESS)
5212
5213 static BC_STATUS zbc_program_binOpPrep(BcResult **l, BcNum **ln,
5214                                      BcResult **r, BcNum **rn, bool assign)
5215 {
5216         BcStatus s;
5217         bool hex;
5218         BcResultType lt, rt;
5219
5220         if (!STACK_HAS_MORE_THAN(&G.prog.results, 1))
5221                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
5222
5223         *r = bc_vec_item_rev(&G.prog.results, 0);
5224         *l = bc_vec_item_rev(&G.prog.results, 1);
5225
5226         lt = (*l)->t;
5227         rt = (*r)->t;
5228         hex = assign && (lt == XC_RESULT_IBASE || lt == XC_RESULT_OBASE);
5229
5230         s = zbc_program_num(*l, ln, false);
5231         if (s) RETURN_STATUS(s);
5232         s = zbc_program_num(*r, rn, hex);
5233         if (s) RETURN_STATUS(s);
5234
5235         // We run this again under these conditions in case any vector has been
5236         // reallocated out from under the BcNums or arrays we had.
5237         if (lt == rt && (lt == XC_RESULT_VAR || lt == XC_RESULT_ARRAY_ELEM)) {
5238                 s = zbc_program_num(*l, ln, false);
5239                 if (s) RETURN_STATUS(s);
5240         }
5241
5242         if (!BC_PROG_NUM((*l), (*ln)) && (!assign || (*l)->t != XC_RESULT_VAR))
5243                 RETURN_STATUS(bc_error_variable_is_wrong_type());
5244         if (!assign && !BC_PROG_NUM((*r), (*ln)))
5245                 RETURN_STATUS(bc_error_variable_is_wrong_type());
5246
5247         RETURN_STATUS(s);
5248 }
5249 #define zbc_program_binOpPrep(...) (zbc_program_binOpPrep(__VA_ARGS__) COMMA_SUCCESS)
5250
5251 static void bc_program_binOpRetire(BcResult *r)
5252 {
5253         r->t = XC_RESULT_TEMP;
5254         bc_vec_pop(&G.prog.results);
5255         bc_result_pop_and_push(r);
5256 }
5257
5258 // Note: *r and *n need not be initialized by caller
5259 static BC_STATUS zbc_program_prep(BcResult **r, BcNum **n)
5260 {
5261         BcStatus s;
5262
5263         if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
5264                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
5265         *r = bc_vec_top(&G.prog.results);
5266
5267         s = zbc_program_num(*r, n, false);
5268         if (s) RETURN_STATUS(s);
5269
5270         if (!BC_PROG_NUM((*r), (*n)))
5271                 RETURN_STATUS(bc_error_variable_is_wrong_type());
5272
5273         RETURN_STATUS(s);
5274 }
5275 #define zbc_program_prep(...) (zbc_program_prep(__VA_ARGS__) COMMA_SUCCESS)
5276
5277 static void bc_program_retire(BcResult *r, BcResultType t)
5278 {
5279         r->t = t;
5280         bc_result_pop_and_push(r);
5281 }
5282
5283 static BC_STATUS zbc_program_op(char inst)
5284 {
5285         BcStatus s;
5286         BcResult *opd1, *opd2, res;
5287         BcNum *n1, *n2;
5288
5289         s = zbc_program_binOpPrep(&opd1, &n1, &opd2, &n2, false);
5290         if (s) RETURN_STATUS(s);
5291         bc_num_init_DEF_SIZE(&res.d.n);
5292
5293         s = BC_STATUS_SUCCESS;
5294         IF_ERROR_RETURN_POSSIBLE(s =) zbc_program_ops[inst - XC_INST_POWER](n1, n2, &res.d.n, G.prog.scale);
5295         if (s) goto err;
5296         bc_program_binOpRetire(&res);
5297
5298         RETURN_STATUS(s);
5299  err:
5300         bc_num_free(&res.d.n);
5301         RETURN_STATUS(s);
5302 }
5303 #define zbc_program_op(...) (zbc_program_op(__VA_ARGS__) COMMA_SUCCESS)
5304
5305 static BC_STATUS zbc_program_read(void)
5306 {
5307         BcStatus s;
5308         BcParse sv_parse;
5309         BcVec buf;
5310         BcInstPtr ip;
5311         BcFunc *f;
5312
5313         bc_char_vec_init(&buf);
5314         bc_read_line(&buf, stdin);
5315
5316         f = bc_program_func(BC_PROG_READ);
5317         bc_vec_pop_all(&f->code);
5318
5319         sv_parse = G.prs; // struct copy
5320         bc_parse_create(BC_PROG_READ);
5321         //bc_lex_file(&G.prs.l); - not needed, error line info is not printed for read()
5322
5323         s = zbc_parse_text_init(buf.v);
5324         if (s) goto exec_err;
5325         if (IS_BC) {
5326                 IF_BC(s = zbc_parse_expr(0));
5327         } else {
5328                 IF_DC(s = zdc_parse_exprs_until_eof());
5329         }
5330         if (s) goto exec_err;
5331
5332         if (G.prs.l.lex != XC_LEX_NLINE && G.prs.l.lex != XC_LEX_EOF) {
5333                 s = bc_error("bad read() expression");
5334                 goto exec_err;
5335         }
5336
5337         ip.func = BC_PROG_READ;
5338         ip.inst_idx = 0;
5339         IF_BC(ip.results_len_before_call = G.prog.results.len;)
5340
5341         bc_parse_push(XC_INST_RET);
5342         bc_vec_push(&G.prog.exestack, &ip);
5343
5344  exec_err:
5345         bc_parse_free();
5346         G.prs = sv_parse; // struct copy
5347         bc_vec_free(&buf);
5348         RETURN_STATUS(s);
5349 }
5350 #define zbc_program_read(...) (zbc_program_read(__VA_ARGS__) COMMA_SUCCESS)
5351
5352 static size_t bc_program_index(char *code, size_t *bgn)
5353 {
5354         unsigned char *bytes = (void*)(code + *bgn);
5355         unsigned amt;
5356         unsigned i;
5357         size_t res;
5358
5359         amt = *bytes++;
5360         *bgn += amt + 1;
5361
5362         amt *= 8;
5363         res = 0;
5364         for (i = 0; i < amt; i += 8)
5365                 res |= (size_t)(*bytes++) << i;
5366
5367         return res;
5368 }
5369
5370 static char *bc_program_name(char *code, size_t *bgn)
5371 {
5372         size_t i;
5373         char *s;
5374
5375         code += *bgn;
5376         s = xmalloc(strchr(code, BC_PARSE_STREND) - code + 1);
5377         i = 0;
5378         for (;;) {
5379                 char c = *code++;
5380                 if (c == BC_PARSE_STREND)
5381                         break;
5382                 s[i++] = c;
5383         }
5384         s[i] = '\0';
5385         *bgn += i + 1;
5386
5387         return s;
5388 }
5389
5390 static void bc_program_printString(const char *str)
5391 {
5392 #if ENABLE_DC
5393         if (!str[0]) {
5394                 // Example: echo '[]ap' | dc
5395                 // should print two bytes: 0x00, 0x0A
5396                 bb_putchar('\0');
5397                 return;
5398         }
5399 #endif
5400         while (*str) {
5401                 int c = *str++;
5402                 if (c != '\\' || !*str)
5403                         bb_putchar(c);
5404                 else {
5405                         c = *str++;
5406                         switch (c) {
5407                         case 'a':
5408                                 bb_putchar('\a');
5409                                 break;
5410                         case 'b':
5411                                 bb_putchar('\b');
5412                                 break;
5413                         case '\\':
5414                         case 'e':
5415                                 bb_putchar('\\');
5416                                 break;
5417                         case 'f':
5418                                 bb_putchar('\f');
5419                                 break;
5420                         case 'n':
5421                                 bb_putchar('\n');
5422                                 G.prog.nchars = SIZE_MAX;
5423                                 break;
5424                         case 'r':
5425                                 bb_putchar('\r');
5426                                 break;
5427                         case 'q':
5428                                 bb_putchar('"');
5429                                 break;
5430                         case 't':
5431                                 bb_putchar('\t');
5432                                 break;
5433                         default:
5434                                 // Just print the backslash and following character.
5435                                 bb_putchar('\\');
5436                                 ++G.prog.nchars;
5437                                 bb_putchar(c);
5438                                 break;
5439                         }
5440                 }
5441                 ++G.prog.nchars;
5442         }
5443 }
5444
5445 static void bc_num_printNewline(void)
5446 {
5447         if (G.prog.nchars == G.prog.len - 1) {
5448                 bb_putchar('\\');
5449                 bb_putchar('\n');
5450                 G.prog.nchars = 0;
5451         }
5452 }
5453
5454 #if ENABLE_DC
5455 static FAST_FUNC void dc_num_printChar(size_t num, size_t width, bool radix)
5456 {
5457         (void) radix;
5458         bb_putchar((char) num);
5459         G.prog.nchars += width;
5460 }
5461 #endif
5462
5463 static FAST_FUNC void bc_num_printDigits(size_t num, size_t width, bool radix)
5464 {
5465         size_t exp, pow;
5466
5467         bc_num_printNewline();
5468         bb_putchar(radix ? '.' : ' ');
5469         ++G.prog.nchars;
5470
5471         bc_num_printNewline();
5472         for (exp = 0, pow = 1; exp < width - 1; ++exp, pow *= 10)
5473                 continue;
5474
5475         for (exp = 0; exp < width; pow /= 10, ++G.prog.nchars, ++exp) {
5476                 size_t dig;
5477                 bc_num_printNewline();
5478                 dig = num / pow;
5479                 num -= dig * pow;
5480                 bb_putchar(((char) dig) + '0');
5481         }
5482 }
5483
5484 static FAST_FUNC void bc_num_printHex(size_t num, size_t width, bool radix)
5485 {
5486         if (radix) {
5487                 bc_num_printNewline();
5488                 bb_putchar('.');
5489                 G.prog.nchars++;
5490         }
5491
5492         bc_num_printNewline();
5493         bb_putchar(bb_hexdigits_upcase[num]);
5494         G.prog.nchars += width;
5495 }
5496
5497 static void bc_num_printDecimal(BcNum *n)
5498 {
5499         size_t i, rdx = n->rdx - 1;
5500
5501         if (n->neg) {
5502                 bb_putchar('-');
5503                 G.prog.nchars++;
5504         }
5505
5506         for (i = n->len - 1; i < n->len; --i)
5507                 bc_num_printHex((size_t) n->num[i], 1, i == rdx);
5508 }
5509
5510 typedef void (*BcNumDigitOp)(size_t, size_t, bool) FAST_FUNC;
5511
5512 static BC_STATUS zbc_num_printNum(BcNum *n, unsigned base_t, size_t width, BcNumDigitOp print)
5513 {
5514         BcStatus s;
5515         BcVec stack;
5516         BcNum base;
5517         BcDig base_digs[ULONG_NUM_BUFSIZE];
5518         BcNum intp, fracp, digit, frac_len;
5519         unsigned long dig, *ptr;
5520         size_t i;
5521         bool radix;
5522
5523         if (n->len == 0) {
5524                 print(0, width, false);
5525                 RETURN_STATUS(BC_STATUS_SUCCESS);
5526         }
5527
5528         bc_vec_init(&stack, sizeof(long), NULL);
5529         bc_num_init(&intp, n->len);
5530         bc_num_init(&fracp, n->rdx);
5531         bc_num_init(&digit, width);
5532         bc_num_init(&frac_len, BC_NUM_INT(n));
5533         bc_num_copy(&intp, n);
5534         bc_num_one(&frac_len);
5535         base.cap = ARRAY_SIZE(base_digs);
5536         base.num = base_digs;
5537         bc_num_ulong2num(&base, base_t);
5538
5539         bc_num_truncate(&intp, intp.rdx);
5540         s = zbc_num_sub(n, &intp, &fracp, 0);
5541         if (s) goto err;
5542
5543         while (intp.len != 0) {
5544                 s = zbc_num_divmod(&intp, &base, &intp, &digit, 0);
5545                 if (s) goto err;
5546                 s = zbc_num_ulong(&digit, &dig);
5547                 if (s) goto err;
5548                 bc_vec_push(&stack, &dig);
5549         }
5550
5551         for (i = 0; i < stack.len; ++i) {
5552                 ptr = bc_vec_item_rev(&stack, i);
5553                 print(*ptr, width, false);
5554         }
5555
5556         if (!n->rdx) goto err;
5557
5558         for (radix = true; frac_len.len <= n->rdx; radix = false) {
5559                 s = zbc_num_mul(&fracp, &base, &fracp, n->rdx);
5560                 if (s) goto err;
5561                 s = zbc_num_ulong(&fracp, &dig);
5562                 if (s) goto err;
5563                 bc_num_ulong2num(&intp, dig);
5564                 s = zbc_num_sub(&fracp, &intp, &fracp, 0);
5565                 if (s) goto err;
5566                 print(dig, width, radix);
5567                 s = zbc_num_mul(&frac_len, &base, &frac_len, 0);
5568                 if (s) goto err;
5569         }
5570  err:
5571         bc_num_free(&frac_len);
5572         bc_num_free(&digit);
5573         bc_num_free(&fracp);
5574         bc_num_free(&intp);
5575         bc_vec_free(&stack);
5576         RETURN_STATUS(s);
5577 }
5578 #define zbc_num_printNum(...) (zbc_num_printNum(__VA_ARGS__) COMMA_SUCCESS)
5579
5580 static BC_STATUS zbc_num_printBase(BcNum *n)
5581 {
5582         BcStatus s;
5583         size_t width;
5584         BcNumDigitOp print;
5585         bool neg = n->neg;
5586
5587         if (neg) {
5588                 bb_putchar('-');
5589                 G.prog.nchars++;
5590         }
5591
5592         n->neg = false;
5593
5594         if (G.prog.ob_t <= BC_NUM_MAX_IBASE) {
5595                 width = 1;
5596                 print = bc_num_printHex;
5597         } else {
5598                 unsigned i = G.prog.ob_t - 1;
5599                 width = 0;
5600                 for (;;) {
5601                         width++;
5602                         i /= 10;
5603                         if (i == 0)
5604                                 break;
5605                 }
5606                 print = bc_num_printDigits;
5607         }
5608
5609         s = zbc_num_printNum(n, G.prog.ob_t, width, print);
5610         n->neg = neg;
5611
5612         RETURN_STATUS(s);
5613 }
5614 #define zbc_num_printBase(...) (zbc_num_printBase(__VA_ARGS__) COMMA_SUCCESS)
5615
5616 static BC_STATUS zbc_num_print(BcNum *n, bool newline)
5617 {
5618         BcStatus s = BC_STATUS_SUCCESS;
5619
5620         bc_num_printNewline();
5621
5622         if (n->len == 0) {
5623                 bb_putchar('0');
5624                 ++G.prog.nchars;
5625         } else if (G.prog.ob_t == 10)
5626                 bc_num_printDecimal(n);
5627         else
5628                 s = zbc_num_printBase(n);
5629
5630         if (newline) {
5631                 bb_putchar('\n');
5632                 G.prog.nchars = 0;
5633         }
5634
5635         RETURN_STATUS(s);
5636 }
5637 #define zbc_num_print(...) (zbc_num_print(__VA_ARGS__) COMMA_SUCCESS)
5638
5639 static BC_STATUS zbc_program_print(char inst, size_t idx)
5640 {
5641         BcStatus s;
5642         BcResult *r;
5643         BcNum *num;
5644         bool pop = (inst != XC_INST_PRINT);
5645
5646         if (!STACK_HAS_MORE_THAN(&G.prog.results, idx))
5647                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
5648
5649         r = bc_vec_item_rev(&G.prog.results, idx);
5650         s = zbc_program_num(r, &num, false);
5651         if (s) RETURN_STATUS(s);
5652
5653         if (BC_PROG_NUM(r, num)) {
5654                 s = zbc_num_print(num, !pop);
5655 #if ENABLE_BC
5656                 if (!s && IS_BC) bc_num_copy(&G.prog.last, num);
5657 #endif
5658         } else {
5659                 char *str;
5660
5661                 idx = (r->t == XC_RESULT_STR) ? r->d.id.idx : num->rdx;
5662                 str = *bc_program_str(idx);
5663
5664                 if (inst == XC_INST_PRINT_STR) {
5665                         for (;;) {
5666                                 char c = *str++;
5667                                 if (c == '\0') break;
5668                                 bb_putchar(c);
5669                                 ++G.prog.nchars;
5670                                 if (c == '\n') G.prog.nchars = 0;
5671                         }
5672                 } else {
5673                         bc_program_printString(str);
5674                         if (inst == XC_INST_PRINT) bb_putchar('\n');
5675                 }
5676         }
5677
5678         if (!s && pop) bc_vec_pop(&G.prog.results);
5679
5680         RETURN_STATUS(s);
5681 }
5682 #define zbc_program_print(...) (zbc_program_print(__VA_ARGS__) COMMA_SUCCESS)
5683
5684 static BC_STATUS zbc_program_negate(void)
5685 {
5686         BcStatus s;
5687         BcResult res, *ptr;
5688         BcNum *num;
5689
5690         s = zbc_program_prep(&ptr, &num);
5691         if (s) RETURN_STATUS(s);
5692
5693         bc_num_init(&res.d.n, num->len);
5694         bc_num_copy(&res.d.n, num);
5695         if (res.d.n.len) res.d.n.neg = !res.d.n.neg;
5696
5697         bc_program_retire(&res, XC_RESULT_TEMP);
5698
5699         RETURN_STATUS(s);
5700 }
5701 #define zbc_program_negate(...) (zbc_program_negate(__VA_ARGS__) COMMA_SUCCESS)
5702
5703 static BC_STATUS zbc_program_logical(char inst)
5704 {
5705         BcStatus s;
5706         BcResult *opd1, *opd2, res;
5707         BcNum *n1, *n2;
5708         ssize_t cond;
5709
5710         s = zbc_program_binOpPrep(&opd1, &n1, &opd2, &n2, false);
5711         if (s) RETURN_STATUS(s);
5712
5713         bc_num_init_DEF_SIZE(&res.d.n);
5714
5715         if (inst == XC_INST_BOOL_AND)
5716                 cond = bc_num_cmp(n1, &G.prog.zero) && bc_num_cmp(n2, &G.prog.zero);
5717         else if (inst == XC_INST_BOOL_OR)
5718                 cond = bc_num_cmp(n1, &G.prog.zero) || bc_num_cmp(n2, &G.prog.zero);
5719         else {
5720                 cond = bc_num_cmp(n1, n2);
5721                 switch (inst) {
5722                 case XC_INST_REL_EQ:
5723                         cond = (cond == 0);
5724                         break;
5725                 case XC_INST_REL_LE:
5726                         cond = (cond <= 0);
5727                         break;
5728                 case XC_INST_REL_GE:
5729                         cond = (cond >= 0);
5730                         break;
5731                 case XC_INST_REL_LT:
5732                         cond = (cond < 0);
5733                         break;
5734                 case XC_INST_REL_GT:
5735                         cond = (cond > 0);
5736                         break;
5737                 default: // = case XC_INST_REL_NE:
5738                         //cond = (cond != 0); - not needed
5739                         break;
5740                 }
5741         }
5742
5743         if (cond) bc_num_one(&res.d.n);
5744         //else bc_num_zero(&res.d.n); - already is
5745
5746         bc_program_binOpRetire(&res);
5747
5748         RETURN_STATUS(s);
5749 }
5750 #define zbc_program_logical(...) (zbc_program_logical(__VA_ARGS__) COMMA_SUCCESS)
5751
5752 #if ENABLE_DC
5753 static BC_STATUS zdc_program_assignStr(BcResult *r, BcVec *v, bool push)
5754 {
5755         BcNum n2;
5756         BcResult res;
5757
5758         memset(&n2, 0, sizeof(BcNum));
5759         n2.rdx = res.d.id.idx = r->d.id.idx;
5760         res.t = XC_RESULT_STR;
5761
5762         if (!push) {
5763                 if (!STACK_HAS_MORE_THAN(&G.prog.results, 1))
5764                         RETURN_STATUS(bc_error_stack_has_too_few_elements());
5765                 bc_vec_pop(v);
5766                 bc_vec_pop(&G.prog.results);
5767         }
5768
5769         bc_result_pop_and_push(&res);
5770         bc_vec_push(v, &n2);
5771
5772         RETURN_STATUS(BC_STATUS_SUCCESS);
5773 }
5774 #define zdc_program_assignStr(...) (zdc_program_assignStr(__VA_ARGS__) COMMA_SUCCESS)
5775 #endif // ENABLE_DC
5776
5777 static BC_STATUS zbc_program_copyToVar(char *name, bool var)
5778 {
5779         BcStatus s;
5780         BcResult *ptr, r;
5781         BcVec *v;
5782         BcNum *n;
5783
5784         if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
5785                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
5786
5787         ptr = bc_vec_top(&G.prog.results);
5788         if ((ptr->t == XC_RESULT_ARRAY) != !var)
5789                 RETURN_STATUS(bc_error_variable_is_wrong_type());
5790         v = bc_program_search(name, var);
5791
5792 #if ENABLE_DC
5793         if (ptr->t == XC_RESULT_STR && !var)
5794                 RETURN_STATUS(bc_error_variable_is_wrong_type());
5795         if (ptr->t == XC_RESULT_STR)
5796                 RETURN_STATUS(zdc_program_assignStr(ptr, v, true));
5797 #endif
5798
5799         s = zbc_program_num(ptr, &n, false);
5800         if (s) RETURN_STATUS(s);
5801
5802         // Do this once more to make sure that pointers were not invalidated.
5803         v = bc_program_search(name, var);
5804
5805         if (var) {
5806                 bc_num_init_DEF_SIZE(&r.d.n);
5807                 bc_num_copy(&r.d.n, n);
5808         } else {
5809                 bc_array_init(&r.d.v, true);
5810                 bc_array_copy(&r.d.v, (BcVec *) n);
5811         }
5812
5813         bc_vec_push(v, &r.d);
5814         bc_vec_pop(&G.prog.results);
5815
5816         RETURN_STATUS(s);
5817 }
5818 #define zbc_program_copyToVar(...) (zbc_program_copyToVar(__VA_ARGS__) COMMA_SUCCESS)
5819
5820 static BC_STATUS zbc_program_assign(char inst)
5821 {
5822         BcStatus s;
5823         BcResult *left, *right, res;
5824         BcNum *l, *r;
5825         bool assign = (inst == XC_INST_ASSIGN);
5826         bool ib, sc;
5827
5828         s = zbc_program_binOpPrep(&left, &l, &right, &r, assign);
5829         if (s) RETURN_STATUS(s);
5830
5831         ib = left->t == XC_RESULT_IBASE;
5832         sc = left->t == XC_RESULT_SCALE;
5833
5834 #if ENABLE_DC
5835         if (right->t == XC_RESULT_STR) {
5836                 BcVec *v;
5837
5838                 if (left->t != XC_RESULT_VAR)
5839                         RETURN_STATUS(bc_error_variable_is_wrong_type());
5840                 v = bc_program_search(left->d.id.name, true);
5841
5842                 RETURN_STATUS(zdc_program_assignStr(right, v, false));
5843         }
5844 #endif
5845
5846         if (left->t == XC_RESULT_CONSTANT || left->t == XC_RESULT_TEMP)
5847                 RETURN_STATUS(bc_error("bad assignment:"
5848                                 " left side must be variable"
5849                                 " or array element"
5850                 )); // note: shared string
5851
5852 #if ENABLE_BC
5853         if (inst == BC_INST_ASSIGN_DIVIDE && !bc_num_cmp(r, &G.prog.zero))
5854                 RETURN_STATUS(bc_error("divide by zero"));
5855
5856         if (assign)
5857                 bc_num_copy(l, r);
5858         else {
5859                 s = BC_STATUS_SUCCESS;
5860                 IF_ERROR_RETURN_POSSIBLE(s =) zbc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, G.prog.scale);
5861         }
5862         if (s) RETURN_STATUS(s);
5863 #else
5864         bc_num_copy(l, r);
5865 #endif
5866
5867         if (ib || sc || left->t == XC_RESULT_OBASE) {
5868                 static const char *const msg[] = {
5869                         "bad ibase; must be [2,16]",                 //XC_RESULT_IBASE
5870                         "bad obase; must be [2,"BC_MAX_OBASE_STR"]", //XC_RESULT_OBASE
5871                         "bad scale; must be [0,"BC_MAX_SCALE_STR"]", //XC_RESULT_SCALE
5872                 };
5873                 size_t *ptr;
5874                 size_t max;
5875                 unsigned long val;
5876
5877                 s = zbc_num_ulong(l, &val);
5878                 if (s) RETURN_STATUS(s);
5879                 s = left->t - XC_RESULT_IBASE;
5880                 if (sc) {
5881                         max = BC_MAX_SCALE;
5882                         ptr = &G.prog.scale;
5883                 } else {
5884                         if (val < 2)
5885                                 RETURN_STATUS(bc_error(msg[s]));
5886                         max = ib ? BC_NUM_MAX_IBASE : BC_MAX_OBASE;
5887                         ptr = ib ? &G.prog.ib_t : &G.prog.ob_t;
5888                 }
5889
5890                 if (val > max)
5891                         RETURN_STATUS(bc_error(msg[s]));
5892
5893                 *ptr = (size_t) val;
5894                 s = BC_STATUS_SUCCESS;
5895         }
5896
5897         bc_num_init(&res.d.n, l->len);
5898         bc_num_copy(&res.d.n, l);
5899         bc_program_binOpRetire(&res);
5900
5901         RETURN_STATUS(s);
5902 }
5903 #define zbc_program_assign(...) (zbc_program_assign(__VA_ARGS__) COMMA_SUCCESS)
5904
5905 #if !ENABLE_DC
5906 #define bc_program_pushVar(code, bgn, pop, copy) \
5907         bc_program_pushVar(code, bgn)
5908 // for bc, 'pop' and 'copy' are always false
5909 #endif
5910 static BC_STATUS bc_program_pushVar(char *code, size_t *bgn,
5911                                    bool pop, bool copy)
5912 {
5913         BcResult r;
5914         char *name = bc_program_name(code, bgn);
5915
5916         r.t = XC_RESULT_VAR;
5917         r.d.id.name = name;
5918
5919 #if ENABLE_DC
5920         if (pop || copy) {
5921                 BcVec *v = bc_program_search(name, true);
5922                 BcNum *num = bc_vec_top(v);
5923
5924                 free(name);
5925                 if (!STACK_HAS_MORE_THAN(v, 1 - copy)) {
5926                         RETURN_STATUS(bc_error_stack_has_too_few_elements());
5927                 }
5928
5929                 if (!BC_PROG_STR(num)) {
5930                         r.t = XC_RESULT_TEMP;
5931                         bc_num_init_DEF_SIZE(&r.d.n);
5932                         bc_num_copy(&r.d.n, num);
5933                 } else {
5934                         r.t = XC_RESULT_STR;
5935                         r.d.id.idx = num->rdx;
5936                 }
5937
5938                 if (!copy) bc_vec_pop(v);
5939         }
5940 #endif // ENABLE_DC
5941
5942         bc_vec_push(&G.prog.results, &r);
5943
5944         RETURN_STATUS(BC_STATUS_SUCCESS);
5945 }
5946 #define zbc_program_pushVar(...) (bc_program_pushVar(__VA_ARGS__) COMMA_SUCCESS)
5947
5948 static BC_STATUS zbc_program_pushArray(char *code, size_t *bgn, char inst)
5949 {
5950         BcStatus s = BC_STATUS_SUCCESS;
5951         BcResult r;
5952         BcNum *num;
5953
5954         r.d.id.name = bc_program_name(code, bgn);
5955
5956         if (inst == XC_INST_ARRAY) {
5957                 r.t = XC_RESULT_ARRAY;
5958                 bc_vec_push(&G.prog.results, &r);
5959         } else {
5960                 BcResult *operand;
5961                 unsigned long temp;
5962
5963                 s = zbc_program_prep(&operand, &num);
5964                 if (s) goto err;
5965                 s = zbc_num_ulong(num, &temp);
5966                 if (s) goto err;
5967
5968                 if (temp > BC_MAX_DIM) {
5969                         s = bc_error("array too long; must be [1,"BC_MAX_DIM_STR"]");
5970                         goto err;
5971                 }
5972
5973                 r.d.id.idx = (size_t) temp;
5974                 bc_program_retire(&r, XC_RESULT_ARRAY_ELEM);
5975         }
5976  err:
5977         if (s) free(r.d.id.name);
5978         RETURN_STATUS(s);
5979 }
5980 #define zbc_program_pushArray(...) (zbc_program_pushArray(__VA_ARGS__) COMMA_SUCCESS)
5981
5982 #if ENABLE_BC
5983 static BC_STATUS zbc_program_incdec(char inst)
5984 {
5985         BcStatus s;
5986         BcResult *ptr, res, copy;
5987         BcNum *num;
5988         char inst2 = inst;
5989
5990         s = zbc_program_prep(&ptr, &num);
5991         if (s) RETURN_STATUS(s);
5992
5993         if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) {
5994                 copy.t = XC_RESULT_TEMP;
5995                 bc_num_init(&copy.d.n, num->len);
5996                 bc_num_copy(&copy.d.n, num);
5997         }
5998
5999         res.t = BC_RESULT_ONE;
6000         inst = (inst == BC_INST_INC_PRE || inst == BC_INST_INC_POST)
6001                         ? BC_INST_ASSIGN_PLUS
6002                         : BC_INST_ASSIGN_MINUS;
6003
6004         bc_vec_push(&G.prog.results, &res);
6005         s = zbc_program_assign(inst);
6006         if (s) RETURN_STATUS(s);
6007
6008         if (inst2 == BC_INST_INC_POST || inst2 == BC_INST_DEC_POST) {
6009                 bc_result_pop_and_push(&copy);
6010         }
6011
6012         RETURN_STATUS(s);
6013 }
6014 #define zbc_program_incdec(...) (zbc_program_incdec(__VA_ARGS__) COMMA_SUCCESS)
6015
6016 static BC_STATUS zbc_program_call(char *code, size_t *idx)
6017 {
6018         BcInstPtr ip;
6019         size_t i, nparams;
6020         BcFunc *func;
6021         BcId *a;
6022         BcResult *arg;
6023
6024         nparams = bc_program_index(code, idx);
6025         ip.inst_idx = 0;
6026         ip.func = bc_program_index(code, idx);
6027         func = bc_program_func(ip.func);
6028
6029         if (func->code.len == 0) {
6030                 RETURN_STATUS(bc_error("undefined function"));
6031         }
6032         if (nparams != func->nparams) {
6033                 RETURN_STATUS(bc_error_fmt("function has %u parameters, but called with %u", func->nparams, nparams));
6034         }
6035         ip.results_len_before_call = G.prog.results.len - nparams;
6036
6037         for (i = 0; i < nparams; ++i) {
6038                 BcStatus s;
6039
6040                 a = bc_vec_item(&func->autos, nparams - 1 - i);
6041                 arg = bc_vec_top(&G.prog.results);
6042
6043                 if ((!a->idx) != (arg->t == XC_RESULT_ARRAY) || arg->t == XC_RESULT_STR)
6044                         RETURN_STATUS(bc_error_variable_is_wrong_type());
6045
6046                 s = zbc_program_copyToVar(a->name, a->idx);
6047                 if (s) RETURN_STATUS(s);
6048         }
6049
6050         a = bc_vec_item(&func->autos, i);
6051         for (; i < func->autos.len; i++, a++) {
6052                 BcVec *v;
6053
6054                 v = bc_program_search(a->name, a->idx);
6055                 if (a->idx) {
6056                         BcNum n2;
6057                         bc_num_init_DEF_SIZE(&n2);
6058                         bc_vec_push(v, &n2);
6059                 } else {
6060                         BcVec v2;
6061                         bc_array_init(&v2, true);
6062                         bc_vec_push(v, &v2);
6063                 }
6064         }
6065
6066         bc_vec_push(&G.prog.exestack, &ip);
6067
6068         RETURN_STATUS(BC_STATUS_SUCCESS);
6069 }
6070 #define zbc_program_call(...) (zbc_program_call(__VA_ARGS__) COMMA_SUCCESS)
6071
6072 static BC_STATUS zbc_program_return(char inst)
6073 {
6074         BcResult res;
6075         BcFunc *f;
6076         BcId *a;
6077         size_t i;
6078         BcInstPtr *ip = bc_vec_top(&G.prog.exestack);
6079
6080         if (!STACK_HAS_EQUAL_OR_MORE_THAN(&G.prog.results, ip->results_len_before_call + (inst == XC_INST_RET)))
6081                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
6082
6083         f = bc_program_func(ip->func);
6084         res.t = XC_RESULT_TEMP;
6085
6086         if (inst == XC_INST_RET) {
6087                 BcStatus s;
6088                 BcNum *num;
6089                 BcResult *operand = bc_vec_top(&G.prog.results);
6090
6091                 s = zbc_program_num(operand, &num, false);
6092                 if (s) RETURN_STATUS(s);
6093                 bc_num_init(&res.d.n, num->len);
6094                 bc_num_copy(&res.d.n, num);
6095         } else {
6096                 bc_num_init_DEF_SIZE(&res.d.n);
6097                 //bc_num_zero(&res.d.n); - already is
6098         }
6099
6100         // We need to pop arguments as well, so this takes that into account.
6101         a = (void*)f->autos.v;
6102         for (i = 0; i < f->autos.len; i++, a++) {
6103                 BcVec *v;
6104                 v = bc_program_search(a->name, a->idx);
6105                 bc_vec_pop(v);
6106         }
6107
6108         bc_vec_npop(&G.prog.results, G.prog.results.len - ip->results_len_before_call);
6109         bc_vec_push(&G.prog.results, &res);
6110         bc_vec_pop(&G.prog.exestack);
6111
6112         RETURN_STATUS(BC_STATUS_SUCCESS);
6113 }
6114 #define zbc_program_return(...) (zbc_program_return(__VA_ARGS__) COMMA_SUCCESS)
6115 #endif // ENABLE_BC
6116
6117 static unsigned long bc_program_scale(BcNum *n)
6118 {
6119         return (unsigned long) n->rdx;
6120 }
6121
6122 static unsigned long bc_program_len(BcNum *n)
6123 {
6124         size_t len = n->len;
6125
6126         if (n->rdx != len) return len;
6127         for (;;) {
6128                 if (len == 0) break;
6129                 len--;
6130                 if (n->num[len] != 0) break;
6131         }
6132         return len;
6133 }
6134
6135 static BC_STATUS zbc_program_builtin(char inst)
6136 {
6137         BcStatus s;
6138         BcResult *opnd;
6139         BcNum *num;
6140         BcResult res;
6141         bool len = (inst == XC_INST_LENGTH);
6142
6143         if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
6144                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
6145         opnd = bc_vec_top(&G.prog.results);
6146
6147         s = zbc_program_num(opnd, &num, false);
6148         if (s) RETURN_STATUS(s);
6149
6150 #if ENABLE_DC
6151         if (!BC_PROG_NUM(opnd, num) && !len)
6152                 RETURN_STATUS(bc_error_variable_is_wrong_type());
6153 #endif
6154
6155         bc_num_init_DEF_SIZE(&res.d.n);
6156
6157         if (inst == XC_INST_SQRT)
6158                 s = zbc_num_sqrt(num, &res.d.n, G.prog.scale);
6159 #if ENABLE_BC
6160         else if (len != 0 && opnd->t == XC_RESULT_ARRAY) {
6161                 bc_num_ulong2num(&res.d.n, (unsigned long) ((BcVec *) num)->len);
6162         }
6163 #endif
6164 #if ENABLE_DC
6165         else if (len != 0 && !BC_PROG_NUM(opnd, num)) {
6166                 char **str;
6167                 size_t idx = opnd->t == XC_RESULT_STR ? opnd->d.id.idx : num->rdx;
6168
6169                 str = bc_program_str(idx);
6170                 bc_num_ulong2num(&res.d.n, strlen(*str));
6171         }
6172 #endif
6173         else {
6174                 bc_num_ulong2num(&res.d.n, len ? bc_program_len(num) : bc_program_scale(num));
6175         }
6176
6177         bc_program_retire(&res, XC_RESULT_TEMP);
6178
6179         RETURN_STATUS(s);
6180 }
6181 #define zbc_program_builtin(...) (zbc_program_builtin(__VA_ARGS__) COMMA_SUCCESS)
6182
6183 #if ENABLE_DC
6184 static BC_STATUS zdc_program_divmod(void)
6185 {
6186         BcStatus s;
6187         BcResult *opd1, *opd2, res, res2;
6188         BcNum *n1, *n2;
6189
6190         s = zbc_program_binOpPrep(&opd1, &n1, &opd2, &n2, false);
6191         if (s) RETURN_STATUS(s);
6192
6193         bc_num_init_DEF_SIZE(&res.d.n);
6194         bc_num_init(&res2.d.n, n2->len);
6195
6196         s = zbc_num_divmod(n1, n2, &res2.d.n, &res.d.n, G.prog.scale);
6197         if (s) goto err;
6198
6199         bc_program_binOpRetire(&res2);
6200         res.t = XC_RESULT_TEMP;
6201         bc_vec_push(&G.prog.results, &res);
6202
6203         RETURN_STATUS(s);
6204  err:
6205         bc_num_free(&res2.d.n);
6206         bc_num_free(&res.d.n);
6207         RETURN_STATUS(s);
6208 }
6209 #define zdc_program_divmod(...) (zdc_program_divmod(__VA_ARGS__) COMMA_SUCCESS)
6210
6211 static BC_STATUS zdc_program_modexp(void)
6212 {
6213         BcStatus s;
6214         BcResult *r1, *r2, *r3, res;
6215         BcNum *n1, *n2, *n3;
6216
6217         if (!STACK_HAS_MORE_THAN(&G.prog.results, 2))
6218                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
6219         s = zbc_program_binOpPrep(&r2, &n2, &r3, &n3, false);
6220         if (s) RETURN_STATUS(s);
6221
6222         r1 = bc_vec_item_rev(&G.prog.results, 2);
6223         s = zbc_program_num(r1, &n1, false);
6224         if (s) RETURN_STATUS(s);
6225         if (!BC_PROG_NUM(r1, n1))
6226                 RETURN_STATUS(bc_error_variable_is_wrong_type());
6227
6228         // Make sure that the values have their pointers updated, if necessary.
6229         if (r1->t == XC_RESULT_VAR || r1->t == XC_RESULT_ARRAY_ELEM) {
6230                 if (r1->t == r2->t) {
6231                         s = zbc_program_num(r2, &n2, false);
6232                         if (s) RETURN_STATUS(s);
6233                 }
6234                 if (r1->t == r3->t) {
6235                         s = zbc_program_num(r3, &n3, false);
6236                         if (s) RETURN_STATUS(s);
6237                 }
6238         }
6239
6240         bc_num_init(&res.d.n, n3->len);
6241         s = zdc_num_modexp(n1, n2, n3, &res.d.n);
6242         if (s) goto err;
6243
6244         bc_vec_pop(&G.prog.results);
6245         bc_program_binOpRetire(&res);
6246
6247         RETURN_STATUS(s);
6248  err:
6249         bc_num_free(&res.d.n);
6250         RETURN_STATUS(s);
6251 }
6252 #define zdc_program_modexp(...) (zdc_program_modexp(__VA_ARGS__) COMMA_SUCCESS)
6253
6254 static void dc_program_stackLen(void)
6255 {
6256         BcResult res;
6257         size_t len = G.prog.results.len;
6258
6259         res.t = XC_RESULT_TEMP;
6260
6261         bc_num_init_DEF_SIZE(&res.d.n);
6262         bc_num_ulong2num(&res.d.n, len);
6263         bc_vec_push(&G.prog.results, &res);
6264 }
6265
6266 static BC_STATUS zdc_program_asciify(void)
6267 {
6268         BcStatus s;
6269         BcResult *r, res;
6270         BcNum *num, n;
6271         char **strs;
6272         char *str;
6273         char c;
6274         size_t idx;
6275
6276         if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
6277                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
6278         r = bc_vec_top(&G.prog.results);
6279
6280         s = zbc_program_num(r, &num, false);
6281         if (s) RETURN_STATUS(s);
6282
6283         if (BC_PROG_NUM(r, num)) {
6284                 unsigned long val;
6285                 BcNum strmb;
6286                 BcDig strmb_digs[ULONG_NUM_BUFSIZE];
6287
6288                 bc_num_init_DEF_SIZE(&n);
6289                 bc_num_copy(&n, num);
6290                 bc_num_truncate(&n, n.rdx);
6291
6292                 strmb.cap = ARRAY_SIZE(strmb_digs);
6293                 strmb.num = strmb_digs;
6294                 bc_num_ulong2num(&strmb, 0x100);
6295                 s = zbc_num_mod(&n, &strmb, &n, 0);
6296
6297                 if (s) goto num_err;
6298                 s = zbc_num_ulong(&n, &val);
6299                 if (s) goto num_err;
6300
6301                 c = (char) val;
6302
6303                 bc_num_free(&n);
6304         } else {
6305                 char *sp;
6306                 idx = (r->t == XC_RESULT_STR) ? r->d.id.idx : num->rdx;
6307                 sp = *bc_program_str(idx);
6308                 c = sp[0];
6309         }
6310
6311         strs = (void*)G.prog.strs.v;
6312         for (idx = 0; idx < G.prog.strs.len; idx++) {
6313                 if (strs[idx][0] == c && strs[idx][1] == '\0') {
6314                         goto dup;
6315                 }
6316         }
6317         str = xzalloc(2);
6318         str[0] = c;
6319         //str[1] = '\0'; - already is
6320         bc_vec_push(&G.prog.strs, &str);
6321  dup:
6322         res.t = XC_RESULT_STR;
6323         res.d.id.idx = idx;
6324         bc_result_pop_and_push(&res);
6325
6326         RETURN_STATUS(BC_STATUS_SUCCESS);
6327  num_err:
6328         bc_num_free(&n);
6329         RETURN_STATUS(s);
6330 }
6331 #define zdc_program_asciify(...) (zdc_program_asciify(__VA_ARGS__) COMMA_SUCCESS)
6332
6333 static BC_STATUS zdc_program_printStream(void)
6334 {
6335         BcStatus s;
6336         BcResult *r;
6337         BcNum *n;
6338         size_t idx;
6339
6340         if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
6341                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
6342         r = bc_vec_top(&G.prog.results);
6343
6344         s = zbc_program_num(r, &n, false);
6345         if (s) RETURN_STATUS(s);
6346
6347         if (BC_PROG_NUM(r, n)) {
6348                 s = zbc_num_printNum(n, 0x100, 1, dc_num_printChar);
6349         } else {
6350                 char *str;
6351                 idx = (r->t == XC_RESULT_STR) ? r->d.id.idx : n->rdx;
6352                 str = *bc_program_str(idx);
6353                 fputs(str, stdout);
6354         }
6355
6356         RETURN_STATUS(s);
6357 }
6358 #define zdc_program_printStream(...) (zdc_program_printStream(__VA_ARGS__) COMMA_SUCCESS)
6359
6360 static BC_STATUS zdc_program_nquit(void)
6361 {
6362         BcStatus s;
6363         BcResult *opnd;
6364         BcNum *num;
6365         unsigned long val;
6366
6367         s = zbc_program_prep(&opnd, &num);
6368         if (s) RETURN_STATUS(s);
6369         s = zbc_num_ulong(num, &val);
6370         if (s) RETURN_STATUS(s);
6371
6372         bc_vec_pop(&G.prog.results);
6373
6374         if (G.prog.exestack.len < val)
6375                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
6376         if (G.prog.exestack.len == val) {
6377                 QUIT_OR_RETURN_TO_MAIN;
6378         }
6379
6380         bc_vec_npop(&G.prog.exestack, val);
6381
6382         RETURN_STATUS(s);
6383 }
6384 #define zdc_program_nquit(...) (zdc_program_nquit(__VA_ARGS__) COMMA_SUCCESS)
6385
6386 static BC_STATUS zdc_program_execStr(char *code, size_t *bgn, bool cond)
6387 {
6388         BcStatus s = BC_STATUS_SUCCESS;
6389         BcResult *r;
6390         BcFunc *f;
6391         BcInstPtr ip;
6392         size_t fidx, sidx;
6393
6394         if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
6395                 RETURN_STATUS(bc_error_stack_has_too_few_elements());
6396
6397         r = bc_vec_top(&G.prog.results);
6398
6399         if (cond) {
6400                 BcNum *n = n; // for compiler
6401                 bool exec;
6402                 char *name;
6403                 char *then_name = bc_program_name(code, bgn);
6404                 char *else_name = NULL;
6405
6406                 if (code[*bgn] == BC_PARSE_STREND)
6407                         (*bgn) += 1;
6408                 else
6409                         else_name = bc_program_name(code, bgn);
6410
6411                 exec = r->d.n.len != 0;
6412                 name = then_name;
6413                 if (!exec && else_name != NULL) {
6414                         exec = true;
6415                         name = else_name;
6416                 }
6417
6418                 if (exec) {
6419                         BcVec *v;
6420                         v = bc_program_search(name, true);
6421                         n = bc_vec_top(v);
6422                 }
6423
6424                 free(then_name);
6425                 free(else_name);
6426
6427                 if (!exec) goto exit;
6428                 if (!BC_PROG_STR(n)) {
6429                         s = bc_error_variable_is_wrong_type();
6430                         goto exit;
6431                 }
6432
6433                 sidx = n->rdx;
6434         } else {
6435                 if (r->t == XC_RESULT_STR) {
6436                         sidx = r->d.id.idx;
6437                 } else if (r->t == XC_RESULT_VAR) {
6438                         BcNum *n;
6439                         s = zbc_program_num(r, &n, false);
6440                         if (s || !BC_PROG_STR(n)) goto exit;
6441                         sidx = n->rdx;
6442                 } else
6443                         goto exit;
6444         }
6445
6446         fidx = sidx + BC_PROG_REQ_FUNCS;
6447
6448         f = bc_program_func(fidx);
6449
6450         if (f->code.len == 0) {
6451                 BcParse sv_parse;
6452                 char *str;
6453
6454                 sv_parse = G.prs; // struct copy
6455                 bc_parse_create(fidx);
6456                 str = *bc_program_str(sidx);
6457                 s = zbc_parse_text_init(str);
6458                 if (s) goto err;
6459
6460                 s = zdc_parse_exprs_until_eof();
6461                 if (s) goto err;
6462                 bc_parse_push(DC_INST_POP_EXEC);
6463                 if (G.prs.l.lex != XC_LEX_EOF)
6464                         s = bc_error_bad_expression();
6465                 bc_parse_free();
6466                 G.prs = sv_parse; // struct copy
6467                 if (s) {
6468  err:
6469                         bc_vec_pop_all(&f->code);
6470                         goto exit;
6471                 }
6472         }
6473
6474         ip.inst_idx = 0;
6475         ip.func = fidx;
6476
6477         bc_vec_pop(&G.prog.results);
6478         bc_vec_push(&G.prog.exestack, &ip);
6479
6480         RETURN_STATUS(BC_STATUS_SUCCESS);
6481  exit:
6482         bc_vec_pop(&G.prog.results);
6483         RETURN_STATUS(s);
6484 }
6485 #define zdc_program_execStr(...) (zdc_program_execStr(__VA_ARGS__) COMMA_SUCCESS)
6486 #endif // ENABLE_DC
6487
6488 static void bc_program_pushGlobal(char inst)
6489 {
6490         BcResult res;
6491         unsigned long val;
6492
6493         res.t = inst - XC_INST_IBASE + XC_RESULT_IBASE;
6494         if (inst == XC_INST_IBASE)
6495                 val = (unsigned long) G.prog.ib_t;
6496         else if (inst == XC_INST_SCALE)
6497                 val = (unsigned long) G.prog.scale;
6498         else
6499                 val = (unsigned long) G.prog.ob_t;
6500
6501         bc_num_init_DEF_SIZE(&res.d.n);
6502         bc_num_ulong2num(&res.d.n, val);
6503         bc_vec_push(&G.prog.results, &res);
6504 }
6505
6506 static BC_STATUS zbc_program_exec(void)
6507 {
6508         BcResult r, *ptr;
6509         BcInstPtr *ip = bc_vec_top(&G.prog.exestack);
6510         BcFunc *func = bc_program_func(ip->func);
6511         char *code = func->code.v;
6512
6513         dbg_exec("func:%zd bytes:%zd ip:%zd results.len:%d",
6514                         ip->func, func->code.len, ip->inst_idx, G.prog.results.len);
6515         while (ip->inst_idx < func->code.len) {
6516                 BcStatus s = BC_STATUS_SUCCESS;
6517                 char inst = code[ip->inst_idx++];
6518
6519                 dbg_exec("inst at %zd:%d results.len:%d", ip->inst_idx - 1, inst, G.prog.results.len);
6520                 switch (inst) {
6521 #if ENABLE_BC
6522                         case BC_INST_JUMP_ZERO: {
6523                                 BcNum *num;
6524                                 bool zero;
6525                                 dbg_exec("BC_INST_JUMP_ZERO:");
6526                                 s = zbc_program_prep(&ptr, &num);
6527                                 if (s) RETURN_STATUS(s);
6528                                 zero = (bc_num_cmp(num, &G.prog.zero) == 0);
6529                                 bc_vec_pop(&G.prog.results);
6530                                 if (!zero) {
6531                                         bc_program_index(code, &ip->inst_idx);
6532                                         break;
6533                                 }
6534                                 // else: fall through
6535                         }
6536                         case BC_INST_JUMP: {
6537                                 size_t idx = bc_program_index(code, &ip->inst_idx);
6538                                 size_t *addr = bc_vec_item(&func->labels, idx);
6539                                 dbg_exec("BC_INST_JUMP: to %ld", (long)*addr);
6540                                 ip->inst_idx = *addr;
6541                                 break;
6542                         }
6543                         case BC_INST_CALL:
6544                                 dbg_exec("BC_INST_CALL:");
6545                                 s = zbc_program_call(code, &ip->inst_idx);
6546                                 goto read_updated_ip;
6547                         case BC_INST_INC_PRE:
6548                         case BC_INST_DEC_PRE:
6549                         case BC_INST_INC_POST:
6550                         case BC_INST_DEC_POST:
6551                                 dbg_exec("BC_INST_INCDEC:");
6552                                 s = zbc_program_incdec(inst);
6553                                 break;
6554                         case BC_INST_HALT:
6555                                 dbg_exec("BC_INST_HALT:");
6556                                 QUIT_OR_RETURN_TO_MAIN;
6557                                 break;
6558                         case XC_INST_RET:
6559                         case BC_INST_RET0:
6560                                 dbg_exec("BC_INST_RET[0]:");
6561                                 s = zbc_program_return(inst);
6562                                 goto read_updated_ip;
6563                         case XC_INST_BOOL_OR:
6564                         case XC_INST_BOOL_AND:
6565 #endif // ENABLE_BC
6566                         case XC_INST_REL_EQ:
6567                         case XC_INST_REL_LE:
6568                         case XC_INST_REL_GE:
6569                         case XC_INST_REL_NE:
6570                         case XC_INST_REL_LT:
6571                         case XC_INST_REL_GT:
6572                                 dbg_exec("BC_INST_BOOL:");
6573                                 s = zbc_program_logical(inst);
6574                                 break;
6575                         case XC_INST_READ:
6576                                 dbg_exec("XC_INST_READ:");
6577                                 s = zbc_program_read();
6578                                 goto read_updated_ip;
6579                         case XC_INST_VAR:
6580                                 dbg_exec("XC_INST_VAR:");
6581                                 s = zbc_program_pushVar(code, &ip->inst_idx, false, false);
6582                                 break;
6583                         case XC_INST_ARRAY_ELEM:
6584                         case XC_INST_ARRAY:
6585                                 dbg_exec("XC_INST_ARRAY[_ELEM]:");
6586                                 s = zbc_program_pushArray(code, &ip->inst_idx, inst);
6587                                 break;
6588 #if ENABLE_BC
6589                         case BC_INST_LAST:
6590                                 dbg_exec("BC_INST_LAST:");
6591                                 r.t = BC_RESULT_LAST;
6592                                 bc_vec_push(&G.prog.results, &r);
6593                                 break;
6594 #endif
6595                         case XC_INST_IBASE:
6596                         case XC_INST_OBASE:
6597                         case XC_INST_SCALE:
6598                                 dbg_exec("XC_INST_internalvar(%d):", inst - XC_INST_IBASE);
6599                                 bc_program_pushGlobal(inst);
6600                                 break;
6601                         case XC_INST_SCALE_FUNC:
6602                         case XC_INST_LENGTH:
6603                         case XC_INST_SQRT:
6604                                 dbg_exec("BC_INST_builtin:");
6605                                 s = zbc_program_builtin(inst);
6606                                 break;
6607                         case XC_INST_NUM:
6608                                 dbg_exec("XC_INST_NUM:");
6609                                 r.t = XC_RESULT_CONSTANT;
6610                                 r.d.id.idx = bc_program_index(code, &ip->inst_idx);
6611                                 bc_vec_push(&G.prog.results, &r);
6612                                 break;
6613                         case XC_INST_POP:
6614                                 dbg_exec("XC_INST_POP:");
6615                                 if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
6616                                         s = bc_error_stack_has_too_few_elements();
6617                                 else
6618                                         bc_vec_pop(&G.prog.results);
6619                                 break;
6620                         case XC_INST_PRINT:
6621                         case XC_INST_PRINT_POP:
6622                         case XC_INST_PRINT_STR:
6623                                 dbg_exec("XC_INST_PRINTxyz:");
6624                                 s = zbc_program_print(inst, 0);
6625                                 break;
6626                         case XC_INST_STR:
6627                                 dbg_exec("XC_INST_STR:");
6628                                 r.t = XC_RESULT_STR;
6629                                 r.d.id.idx = bc_program_index(code, &ip->inst_idx);
6630                                 bc_vec_push(&G.prog.results, &r);
6631                                 break;
6632                         case XC_INST_POWER:
6633                         case XC_INST_MULTIPLY:
6634                         case XC_INST_DIVIDE:
6635                         case XC_INST_MODULUS:
6636                         case XC_INST_PLUS:
6637                         case XC_INST_MINUS:
6638                                 dbg_exec("BC_INST_binaryop:");
6639                                 s = zbc_program_op(inst);
6640                                 break;
6641                         case XC_INST_BOOL_NOT: {
6642                                 BcNum *num;
6643                                 dbg_exec("XC_INST_BOOL_NOT:");
6644                                 s = zbc_program_prep(&ptr, &num);
6645                                 if (s) RETURN_STATUS(s);
6646                                 bc_num_init_DEF_SIZE(&r.d.n);
6647                                 if (bc_num_cmp(num, &G.prog.zero) == 0)
6648                                         bc_num_one(&r.d.n);
6649                                 //else bc_num_zero(&r.d.n); - already is
6650                                 bc_program_retire(&r, XC_RESULT_TEMP);
6651                                 break;
6652                         }
6653                         case XC_INST_NEG:
6654                                 dbg_exec("XC_INST_NEG:");
6655                                 s = zbc_program_negate();
6656                                 break;
6657 #if ENABLE_BC
6658                         case BC_INST_ASSIGN_POWER:
6659                         case BC_INST_ASSIGN_MULTIPLY:
6660                         case BC_INST_ASSIGN_DIVIDE:
6661                         case BC_INST_ASSIGN_MODULUS:
6662                         case BC_INST_ASSIGN_PLUS:
6663                         case BC_INST_ASSIGN_MINUS:
6664 #endif
6665                         case XC_INST_ASSIGN:
6666                                 dbg_exec("BC_INST_ASSIGNxyz:");
6667                                 s = zbc_program_assign(inst);
6668                                 break;
6669 #if ENABLE_DC
6670                         case DC_INST_POP_EXEC:
6671                                 dbg_exec("DC_INST_POP_EXEC:");
6672                                 bc_vec_pop(&G.prog.exestack);
6673                                 goto read_updated_ip;
6674                         case DC_INST_MODEXP:
6675                                 dbg_exec("DC_INST_MODEXP:");
6676                                 s = zdc_program_modexp();
6677                                 break;
6678                         case DC_INST_DIVMOD:
6679                                 dbg_exec("DC_INST_DIVMOD:");
6680                                 s = zdc_program_divmod();
6681                                 break;
6682                         case DC_INST_EXECUTE:
6683                         case DC_INST_EXEC_COND:
6684                                 dbg_exec("DC_INST_EXEC[_COND]:");
6685                                 s = zdc_program_execStr(code, &ip->inst_idx, inst == DC_INST_EXEC_COND);
6686                                 goto read_updated_ip;
6687                         case DC_INST_PRINT_STACK: {
6688                                 size_t idx;
6689                                 dbg_exec("DC_INST_PRINT_STACK:");
6690                                 for (idx = 0; idx < G.prog.results.len; ++idx) {
6691                                         s = zbc_program_print(XC_INST_PRINT, idx);
6692                                         if (s) break;
6693                                 }
6694                                 break;
6695                         }
6696                         case DC_INST_CLEAR_STACK:
6697                                 dbg_exec("DC_INST_CLEAR_STACK:");
6698                                 bc_vec_pop_all(&G.prog.results);
6699                                 break;
6700                         case DC_INST_STACK_LEN:
6701                                 dbg_exec("DC_INST_STACK_LEN:");
6702                                 dc_program_stackLen();
6703                                 break;
6704                         case DC_INST_DUPLICATE:
6705                                 dbg_exec("DC_INST_DUPLICATE:");
6706                                 if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
6707                                         RETURN_STATUS(bc_error_stack_has_too_few_elements());
6708                                 ptr = bc_vec_top(&G.prog.results);
6709                                 dc_result_copy(&r, ptr);
6710                                 bc_vec_push(&G.prog.results, &r);
6711                                 break;
6712                         case DC_INST_SWAP: {
6713                                 BcResult *ptr2;
6714                                 dbg_exec("DC_INST_SWAP:");
6715                                 if (!STACK_HAS_MORE_THAN(&G.prog.results, 1))
6716                                         RETURN_STATUS(bc_error_stack_has_too_few_elements());
6717                                 ptr = bc_vec_item_rev(&G.prog.results, 0);
6718                                 ptr2 = bc_vec_item_rev(&G.prog.results, 1);
6719                                 memcpy(&r, ptr, sizeof(BcResult));
6720                                 memcpy(ptr, ptr2, sizeof(BcResult));
6721                                 memcpy(ptr2, &r, sizeof(BcResult));
6722                                 break;
6723                         }
6724                         case DC_INST_ASCIIFY:
6725                                 dbg_exec("DC_INST_ASCIIFY:");
6726                                 s = zdc_program_asciify();
6727                                 break;
6728                         case DC_INST_PRINT_STREAM:
6729                                 dbg_exec("DC_INST_PRINT_STREAM:");
6730                                 s = zdc_program_printStream();
6731                                 break;
6732                         case DC_INST_LOAD:
6733                         case DC_INST_PUSH_VAR: {
6734                                 bool copy = inst == DC_INST_LOAD;
6735                                 s = zbc_program_pushVar(code, &ip->inst_idx, true, copy);
6736                                 break;
6737                         }
6738                         case DC_INST_PUSH_TO_VAR: {
6739                                 char *name = bc_program_name(code, &ip->inst_idx);
6740                                 s = zbc_program_copyToVar(name, true);
6741                                 free(name);
6742                                 break;
6743                         }
6744                         case DC_INST_QUIT:
6745                                 dbg_exec("DC_INST_QUIT:");
6746                                 if (G.prog.exestack.len <= 2)
6747                                         QUIT_OR_RETURN_TO_MAIN;
6748                                 bc_vec_npop(&G.prog.exestack, 2);
6749                                 goto read_updated_ip;
6750                         case DC_INST_NQUIT:
6751                                 dbg_exec("DC_INST_NQUIT:");
6752                                 s = zdc_program_nquit();
6753                                 //goto read_updated_ip; - just fall through to it
6754 #endif // ENABLE_DC
6755  read_updated_ip:
6756                                 // Instruction stack has changed, read new pointers
6757                                 ip = bc_vec_top(&G.prog.exestack);
6758                                 func = bc_program_func(ip->func);
6759                                 code = func->code.v;
6760                                 dbg_exec("func:%zd bytes:%zd ip:%zd", ip->func, func->code.len, ip->inst_idx);
6761                 }
6762
6763                 if (s || G_interrupt) {
6764                         bc_program_reset();
6765                         RETURN_STATUS(s);
6766                 }
6767
6768                 fflush_and_check();
6769         }
6770
6771         RETURN_STATUS(BC_STATUS_SUCCESS);
6772 }
6773 #define zbc_program_exec(...) (zbc_program_exec(__VA_ARGS__) COMMA_SUCCESS)
6774
6775 static unsigned bc_vm_envLen(const char *var)
6776 {
6777         char *lenv;
6778         unsigned len;
6779
6780         lenv = getenv(var);
6781         len = BC_NUM_PRINT_WIDTH;
6782         if (!lenv) return len;
6783
6784         len = bb_strtou(lenv, NULL, 10) - 1;
6785         if (errno || len < 2 || len >= INT_MAX)
6786                 len = BC_NUM_PRINT_WIDTH;
6787
6788         return len;
6789 }
6790
6791 static BC_STATUS zbc_vm_process(const char *text)
6792 {
6793         BcStatus s;
6794
6795         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
6796         s = zbc_parse_text_init(text); // does the first zbc_lex_next()
6797         if (s) RETURN_STATUS(s);
6798
6799  IF_BC(check_eof:)
6800         while (G.prs.l.lex != XC_LEX_EOF) {
6801                 BcInstPtr *ip;
6802                 BcFunc *f;
6803
6804                 dbg_lex("%s:%d G.prs.l.lex:%d, parsing...", __func__, __LINE__, G.prs.l.lex);
6805                 if (IS_BC) {
6806 #if ENABLE_BC
6807                         if (G.prs.l.lex == BC_LEX_SCOLON
6808                          || G.prs.l.lex == XC_LEX_NLINE
6809                         ) {
6810                                 s = zbc_lex_next();
6811                                 if (s) goto err;
6812                                 goto check_eof;
6813                         }
6814
6815                         s = zbc_parse_stmt_or_funcdef();
6816                         if (s) goto err;
6817
6818                         // Check that next token is a correct stmt delimiter -
6819                         // disallows "print 1 print 2" and such.
6820                         if (G.prs.l.lex != BC_LEX_SCOLON
6821                          && G.prs.l.lex != XC_LEX_NLINE
6822                          && G.prs.l.lex != XC_LEX_EOF
6823                         ) {
6824                                 const char *err_at;
6825 //TODO: commonalize for other parse errors:
6826                                 err_at = G.prs.l.lex_next_at ? G.prs.l.lex_next_at : "UNKNOWN";
6827                                 bc_error_fmt("bad statement terminator at '%.*s'",
6828                                         (int)(strchrnul(err_at, '\n') - err_at),
6829                                         err_at
6830                                 );
6831                                 goto err;
6832                         }
6833                         // The above logic is fragile. Check these examples:
6834                         // - interative read() still works
6835 #endif
6836                 } else {
6837 #if ENABLE_DC
6838                         // Most of dc parsing assumes all whitespace,
6839                         // including '\n', is eaten.
6840                         while (G.prs.l.lex == XC_LEX_NLINE) {
6841                                 s = zbc_lex_next();
6842                                 if (s) goto err;
6843                                 if (G.prs.l.lex == XC_LEX_EOF)
6844                                         goto done;
6845                         }
6846                         s = zdc_parse_expr();
6847 #endif
6848                 }
6849                 if (s || G_interrupt) {
6850  err:
6851                         bc_parse_reset(); // includes bc_program_reset()
6852                         RETURN_STATUS(BC_STATUS_FAILURE);
6853                 }
6854
6855                 dbg_lex("%s:%d executing...", __func__, __LINE__);
6856                 s = zbc_program_exec();
6857                 if (s) {
6858                         bc_program_reset();
6859                         break;
6860                 }
6861
6862                 ip = (void*)G.prog.exestack.v;
6863 #if SANITY_CHECKS
6864                 if (G.prog.exestack.len != 1) // should have only main's IP
6865                         bb_error_msg_and_die("BUG:call stack");
6866                 if (ip->func != BC_PROG_MAIN)
6867                         bb_error_msg_and_die("BUG:not MAIN");
6868 #endif
6869                 f = bc_program_func_BC_PROG_MAIN();
6870                 // bc discards strings, constants and code after each
6871                 // top-level statement in the "main program".
6872                 // This prevents "yes 1 | bc" from growing its memory
6873                 // without bound. This can be done because data stack
6874                 // is empty and thus can't hold any references to
6875                 // strings or constants, there is no generated code
6876                 // which can hold references (after we discard one
6877                 // we just executed). Code of functions can have references,
6878                 // but bc stores function strings/constants in per-function
6879                 // storage.
6880                 if (IS_BC) {
6881 #if SANITY_CHECKS
6882                         if (G.prog.results.len != 0) // should be empty
6883                                 bb_error_msg_and_die("BUG:data stack");
6884 #endif
6885                         IF_BC(bc_vec_pop_all(&f->strs);)
6886                         IF_BC(bc_vec_pop_all(&f->consts);)
6887                 } else {
6888                         if (G.prog.results.len == 0
6889                          && G.prog.vars.len == 0
6890                         ) {
6891                                 // If stack is empty and no registers exist (TODO: or they are all empty),
6892                                 // we can get rid of accumulated strings and constants.
6893                                 // In this example dc process should not grow
6894                                 // its memory consumption with time:
6895                                 // yes 1pc | dc
6896                                 IF_DC(bc_vec_pop_all(&G.prog.strs);)
6897                                 IF_DC(bc_vec_pop_all(&G.prog.consts);)
6898                         }
6899                         // The code is discarded always (below), thus this example
6900                         // should also not grow its memory consumption with time,
6901                         // even though its data stack is not empty:
6902                         // { echo 1; yes dk; } | dc
6903                 }
6904                 // We drop generated and executed code for both bc and dc:
6905                 bc_vec_pop_all(&f->code);
6906                 ip->inst_idx = 0;
6907         }
6908  done:
6909         dbg_lex_done("%s:%d done", __func__, __LINE__);
6910         RETURN_STATUS(s);
6911 }
6912 #define zbc_vm_process(...) (zbc_vm_process(__VA_ARGS__) COMMA_SUCCESS)
6913
6914 static BC_STATUS zbc_vm_execute_FILE(FILE *fp, const char *filename)
6915 {
6916         // So far bc/dc have no way to include a file from another file,
6917         // therefore we know G.prs.filename == NULL on entry
6918         //const char *sv_file;
6919         BcStatus s;
6920
6921         G.prs.filename = filename;
6922         G.prs.input_fp = fp;
6923         bc_lex_file();
6924
6925         do {
6926                 s = zbc_vm_process("");
6927                 // We do not stop looping on errors here if reading stdin.
6928                 // Example: start interactive bc and enter "return".
6929                 // It should say "'return' not in a function"
6930                 // but should not exit.
6931         } while (G.prs.input_fp == stdin);
6932         G.prs.filename = NULL;
6933         RETURN_STATUS(s);
6934 }
6935 #define zbc_vm_execute_FILE(...) (zbc_vm_execute_FILE(__VA_ARGS__) COMMA_SUCCESS)
6936
6937 static BC_STATUS zbc_vm_file(const char *file)
6938 {
6939         BcStatus s;
6940         FILE *fp;
6941
6942         fp = xfopen_for_read(file);
6943         s = zbc_vm_execute_FILE(fp, file);
6944         fclose(fp);
6945
6946         RETURN_STATUS(s);
6947 }
6948 #define zbc_vm_file(...) (zbc_vm_file(__VA_ARGS__) COMMA_SUCCESS)
6949
6950 #if ENABLE_BC
6951 static void bc_vm_info(void)
6952 {
6953         printf("%s "BB_VER"\n"
6954                 "Adapted from https://github.com/gavinhoward/bc\n"
6955                 "Original code (c) 2018 Gavin D. Howard and contributors\n"
6956         , applet_name);
6957 }
6958
6959 static void bc_args(char **argv)
6960 {
6961         unsigned opts;
6962         int i;
6963
6964         GETOPT_RESET();
6965 #if ENABLE_FEATURE_BC_LONG_OPTIONS
6966         opts = option_mask32 |= getopt32long(argv, "wvsqli",
6967                 "warn\0"              No_argument "w"
6968                 "version\0"           No_argument "v"
6969                 "standard\0"          No_argument "s"
6970                 "quiet\0"             No_argument "q"
6971                 "mathlib\0"           No_argument "l"
6972                 "interactive\0"       No_argument "i"
6973         );
6974 #else
6975         opts = option_mask32 |= getopt32(argv, "wvsqli");
6976 #endif
6977         if (getenv("POSIXLY_CORRECT"))
6978                 option_mask32 |= BC_FLAG_S;
6979
6980         if (opts & BC_FLAG_V) {
6981                 bc_vm_info();
6982                 exit(0);
6983         }
6984
6985         for (i = optind; argv[i]; ++i)
6986                 bc_vec_push(&G.files, argv + i);
6987 }
6988
6989 static void bc_vm_envArgs(void)
6990 {
6991         BcVec v;
6992         char *buf;
6993         char *env_args = getenv("BC_ENV_ARGS");
6994
6995         if (!env_args) return;
6996
6997         G.env_args = xstrdup(env_args);
6998         buf = G.env_args;
6999
7000         bc_vec_init(&v, sizeof(char *), NULL);
7001
7002         while (*(buf = skip_whitespace(buf)) != '\0') {
7003                 bc_vec_push(&v, &buf);
7004                 buf = skip_non_whitespace(buf);
7005                 if (!*buf)
7006                         break;
7007                 *buf++ = '\0';
7008         }
7009
7010         // NULL terminate, and pass argv[] so that first arg is argv[1]
7011         if (sizeof(int) == sizeof(char*)) {
7012                 bc_vec_push(&v, &const_int_0);
7013         } else {
7014                 static char *const nullptr = NULL;
7015                 bc_vec_push(&v, &nullptr);
7016         }
7017         bc_args(((char **)v.v) - 1);
7018
7019         bc_vec_free(&v);
7020 }
7021
7022 static const char bc_lib[] ALIGN1 = {
7023         "scale=20"
7024 "\n"    "define e(x){"
7025 "\n"            "auto b,s,n,r,d,i,p,f,v"
7026 ////////////////"if(x<0)return(1/e(-x))" // and drop 'n' and x<0 logic below
7027 //^^^^^^^^^^^^^^^^ this would work, and is even more precise than GNU bc:
7028 //e(-.998896): GNU:.36828580434569428695
7029 //      above code:.36828580434569428696
7030 //    actual value:.3682858043456942869594...
7031 // but for now let's be "GNU compatible"
7032 "\n"            "b=ibase"
7033 "\n"            "ibase=A"
7034 "\n"            "if(x<0){"
7035 "\n"                    "n=1"
7036 "\n"                    "x=-x"
7037 "\n"            "}"
7038 "\n"            "s=scale"
7039 "\n"            "r=6+s+.44*x"
7040 "\n"            "scale=scale(x)+1"
7041 "\n"            "while(x>1){"
7042 "\n"                    "d+=1"
7043 "\n"                    "x/=2"
7044 "\n"                    "scale+=1"
7045 "\n"            "}"
7046 "\n"            "scale=r"
7047 "\n"            "r=x+1"
7048 "\n"            "p=x"
7049 "\n"            "f=v=1"
7050 "\n"            "for(i=2;v;++i){"
7051 "\n"                    "p*=x"
7052 "\n"                    "f*=i"
7053 "\n"                    "v=p/f"
7054 "\n"                    "r+=v"
7055 "\n"            "}"
7056 "\n"            "while(d--)r*=r"
7057 "\n"            "scale=s"
7058 "\n"            "ibase=b"
7059 "\n"            "if(n)return(1/r)"
7060 "\n"            "return(r/1)"
7061 "\n"    "}"
7062 "\n"    "define l(x){"
7063 "\n"            "auto b,s,r,p,a,q,i,v"
7064 "\n"            "b=ibase"
7065 "\n"            "ibase=A"
7066 "\n"            "if(x<=0){"
7067 "\n"                    "r=(1-10^scale)/1"
7068 "\n"                    "ibase=b"
7069 "\n"                    "return(r)"
7070 "\n"            "}"
7071 "\n"            "s=scale"
7072 "\n"            "scale+=6"
7073 "\n"            "p=2"
7074 "\n"            "while(x>=2){"
7075 "\n"                    "p*=2"
7076 "\n"                    "x=sqrt(x)"
7077 "\n"            "}"
7078 "\n"            "while(x<=.5){"
7079 "\n"                    "p*=2"
7080 "\n"                    "x=sqrt(x)"
7081 "\n"            "}"
7082 "\n"            "r=a=(x-1)/(x+1)"
7083 "\n"            "q=a*a"
7084 "\n"            "v=1"
7085 "\n"            "for(i=3;v;i+=2){"
7086 "\n"                    "a*=q"
7087 "\n"                    "v=a/i"
7088 "\n"                    "r+=v"
7089 "\n"            "}"
7090 "\n"            "r*=p"
7091 "\n"            "scale=s"
7092 "\n"            "ibase=b"
7093 "\n"            "return(r/1)"
7094 "\n"    "}"
7095 "\n"    "define s(x){"
7096 "\n"            "auto b,s,r,a,q,i"
7097 "\n"            "if(x<0)return(-s(-x))"
7098 "\n"            "b=ibase"
7099 "\n"            "ibase=A"
7100 "\n"            "s=scale"
7101 "\n"            "scale=1.1*s+2"
7102 "\n"            "a=a(1)"
7103 "\n"            "scale=0"
7104 "\n"            "q=(x/a+2)/4"
7105 "\n"            "x-=4*q*a"
7106 "\n"            "if(q%2)x=-x"
7107 "\n"            "scale=s+2"
7108 "\n"            "r=a=x"
7109 "\n"            "q=-x*x"
7110 "\n"            "for(i=3;a;i+=2){"
7111 "\n"                    "a*=q/(i*(i-1))"
7112 "\n"                    "r+=a"
7113 "\n"            "}"
7114 "\n"            "scale=s"
7115 "\n"            "ibase=b"
7116 "\n"            "return(r/1)"
7117 "\n"    "}"
7118 "\n"    "define c(x){"
7119 "\n"            "auto b,s"
7120 "\n"            "b=ibase"
7121 "\n"            "ibase=A"
7122 "\n"            "s=scale"
7123 "\n"            "scale*=1.2"
7124 "\n"            "x=s(2*a(1)+x)"
7125 "\n"            "scale=s"
7126 "\n"            "ibase=b"
7127 "\n"            "return(x/1)"
7128 "\n"    "}"
7129 "\n"    "define a(x){"
7130 "\n"            "auto b,s,r,n,a,m,t,f,i,u"
7131 "\n"            "b=ibase"
7132 "\n"            "ibase=A"
7133 "\n"            "n=1"
7134 "\n"            "if(x<0){"
7135 "\n"                    "n=-1"
7136 "\n"                    "x=-x"
7137 "\n"            "}"
7138 "\n"            "if(scale<65){"
7139 "\n"                    "if(x==1)return(.7853981633974483096156608458198757210492923498437764552437361480/n)"
7140 "\n"                    "if(x==.2)return(.1973955598498807583700497651947902934475851037878521015176889402/n)"
7141 "\n"            "}"
7142 "\n"            "s=scale"
7143 "\n"            "if(x>.2){"
7144 "\n"                    "scale+=5"
7145 "\n"                    "a=a(.2)"
7146 "\n"            "}"
7147 "\n"            "scale=s+3"
7148 "\n"            "while(x>.2){"
7149 "\n"                    "m+=1"
7150 "\n"                    "x=(x-.2)/(1+.2*x)"
7151 "\n"            "}"
7152 "\n"            "r=u=x"
7153 "\n"            "f=-x*x"
7154 "\n"            "t=1"
7155 "\n"            "for(i=3;t;i+=2){"
7156 "\n"                    "u*=f"
7157 "\n"                    "t=u/i"
7158 "\n"                    "r+=t"
7159 "\n"            "}"
7160 "\n"            "scale=s"
7161 "\n"            "ibase=b"
7162 "\n"            "return((m*a+r)/n)"
7163 "\n"    "}"
7164 "\n"    "define j(n,x){"
7165 "\n"            "auto b,s,o,a,i,v,f"
7166 "\n"            "b=ibase"
7167 "\n"            "ibase=A"
7168 "\n"            "s=scale"
7169 "\n"            "scale=0"
7170 "\n"            "n/=1"
7171 "\n"            "if(n<0){"
7172 "\n"                    "n=-n"
7173 "\n"                    "o=n%2"
7174 "\n"            "}"
7175 "\n"            "a=1"
7176 "\n"            "for(i=2;i<=n;++i)a*=i"
7177 "\n"            "scale=1.5*s"
7178 "\n"            "a=(x^n)/2^n/a"
7179 "\n"            "r=v=1"
7180 "\n"            "f=-x*x/4"
7181 "\n"            "scale+=length(a)-scale(a)"
7182 "\n"            "for(i=1;v;++i){"
7183 "\n"                    "v=v*f/i/(n+i)"
7184 "\n"                    "r+=v"
7185 "\n"            "}"
7186 "\n"            "scale=s"
7187 "\n"            "ibase=b"
7188 "\n"            "if(o)a=-a"
7189 "\n"            "return(a*r/1)"
7190 "\n"    "}"
7191 };
7192 #endif // ENABLE_BC
7193
7194 static BC_STATUS zbc_vm_exec(void)
7195 {
7196         char **fname;
7197         BcStatus s;
7198         size_t i;
7199
7200 #if ENABLE_BC
7201         if (option_mask32 & BC_FLAG_L) {
7202                 // We know that internal library is not buggy,
7203                 // thus error checking is normally disabled.
7204 # define DEBUG_LIB 0
7205                 bc_lex_file();
7206                 s = zbc_vm_process(bc_lib);
7207                 if (DEBUG_LIB && s) RETURN_STATUS(s);
7208         }
7209 #endif
7210
7211         s = BC_STATUS_SUCCESS;
7212         fname = (void*)G.files.v;
7213         for (i = 0; i < G.files.len; i++) {
7214                 s = zbc_vm_file(*fname++);
7215                 if (ENABLE_FEATURE_CLEAN_UP && !G_ttyin && s) {
7216                         // Debug config, non-interactive mode:
7217                         // return all the way back to main.
7218                         // Non-debug builds do not come here
7219                         // in non-interactive mode, they exit.
7220                         RETURN_STATUS(s);
7221                 }
7222         }
7223
7224         if (IS_BC || (option_mask32 & BC_FLAG_I))
7225                 s = zbc_vm_execute_FILE(stdin, /*filename:*/ NULL);
7226
7227         RETURN_STATUS(s);
7228 }
7229 #define zbc_vm_exec(...) (zbc_vm_exec(__VA_ARGS__) COMMA_SUCCESS)
7230
7231 #if ENABLE_FEATURE_CLEAN_UP
7232 static void bc_program_free(void)
7233 {
7234         bc_vec_free(&G.prog.fns);
7235         IF_BC(bc_vec_free(&G.prog.fn_map);)
7236         bc_vec_free(&G.prog.vars);
7237         bc_vec_free(&G.prog.var_map);
7238         bc_vec_free(&G.prog.arrs);
7239         bc_vec_free(&G.prog.arr_map);
7240         IF_DC(bc_vec_free(&G.prog.strs);)
7241         IF_DC(bc_vec_free(&G.prog.consts);)
7242         bc_vec_free(&G.prog.results);
7243         bc_vec_free(&G.prog.exestack);
7244         IF_BC(bc_num_free(&G.prog.last);)
7245         IF_BC(bc_num_free(&G.prog.zero);)
7246         IF_BC(bc_num_free(&G.prog.one);)
7247         bc_vec_free(&G.input_buffer);
7248 }
7249
7250 static void bc_vm_free(void)
7251 {
7252         bc_vec_free(&G.files);
7253         bc_program_free();
7254         bc_parse_free();
7255         free(G.env_args);
7256 }
7257 #endif
7258
7259 static void bc_program_init(void)
7260 {
7261         BcInstPtr ip;
7262
7263         // memset(&G.prog, 0, sizeof(G.prog)); - already is
7264         memset(&ip, 0, sizeof(BcInstPtr));
7265
7266         // G.prog.nchars = G.prog.scale = 0; - already is
7267         G.prog.ib_t = 10;
7268         G.prog.ob_t = 10;
7269
7270         IF_BC(bc_num_init_DEF_SIZE(&G.prog.last);)
7271         //IF_BC(bc_num_zero(&G.prog.last);) - already is
7272
7273         bc_num_init_DEF_SIZE(&G.prog.zero);
7274         //bc_num_zero(&G.prog.zero); - already is
7275
7276         IF_BC(bc_num_init_DEF_SIZE(&G.prog.one);)
7277         IF_BC(bc_num_one(&G.prog.one);)
7278
7279         bc_vec_init(&G.prog.fns, sizeof(BcFunc), bc_func_free);
7280         IF_BC(bc_vec_init(&G.prog.fn_map, sizeof(BcId), bc_id_free);)
7281
7282         if (IS_BC) {
7283                 // Names are chosen simply to be distinct and never match
7284                 // a valid function name (and be short)
7285                 IF_BC(bc_program_addFunc(xstrdup(""))); // func #0: main
7286                 IF_BC(bc_program_addFunc(xstrdup("1"))); // func #1: for read()
7287         } else {
7288                 // in dc, functions have no names
7289                 bc_program_add_fn();
7290                 bc_program_add_fn();
7291         }
7292
7293         bc_vec_init(&G.prog.vars, sizeof(BcVec), bc_vec_free);
7294         bc_vec_init(&G.prog.var_map, sizeof(BcId), bc_id_free);
7295
7296         bc_vec_init(&G.prog.arrs, sizeof(BcVec), bc_vec_free);
7297         bc_vec_init(&G.prog.arr_map, sizeof(BcId), bc_id_free);
7298
7299         IF_DC(bc_vec_init(&G.prog.strs, sizeof(char *), bc_string_free);)
7300         IF_DC(bc_vec_init(&G.prog.consts, sizeof(char *), bc_string_free);)
7301         bc_vec_init(&G.prog.results, sizeof(BcResult), bc_result_free);
7302         bc_vec_init(&G.prog.exestack, sizeof(BcInstPtr), NULL);
7303         bc_vec_push(&G.prog.exestack, &ip);
7304
7305         bc_char_vec_init(&G.input_buffer);
7306 }
7307
7308 static int bc_vm_init(const char *env_len)
7309 {
7310 #if ENABLE_FEATURE_EDITING
7311         G.line_input_state = new_line_input_t(DO_HISTORY);
7312 #endif
7313         G.prog.len = bc_vm_envLen(env_len);
7314
7315         bc_vec_init(&G.files, sizeof(char *), NULL);
7316         IF_BC(if (IS_BC) bc_vm_envArgs();)
7317         bc_program_init();
7318         bc_parse_create(BC_PROG_MAIN);
7319
7320 //TODO: in GNU bc, the check is (isatty(0) && isatty(1)),
7321 //-i option unconditionally enables this regardless of isatty():
7322         if (isatty(0)) {
7323 #if ENABLE_FEATURE_BC_SIGNALS
7324                 G_ttyin = 1;
7325                 // With SA_RESTART, most system calls will restart
7326                 // (IOW: they won't fail with EINTR).
7327                 // In particular, this means ^C won't cause
7328                 // stdout to get into "error state" if SIGINT hits
7329                 // within write() syscall.
7330                 //
7331                 // The downside is that ^C while tty input is taken
7332                 // will only be handled after [Enter] since read()
7333                 // from stdin is not interrupted by ^C either,
7334                 // it restarts, thus fgetc() does not return on ^C.
7335                 // (This problem manifests only if line editing is disabled)
7336                 signal_SA_RESTART_empty_mask(SIGINT, record_signo);
7337
7338                 // Without SA_RESTART, this exhibits a bug:
7339                 // "while (1) print 1" and try ^C-ing it.
7340                 // Intermittently, instead of returning to input line,
7341                 // you'll get "output error: Interrupted system call"
7342                 // and exit.
7343                 //signal_no_SA_RESTART_empty_mask(SIGINT, record_signo);
7344 #endif
7345                 return 1; // "tty"
7346         }
7347         return 0; // "not a tty"
7348 }
7349
7350 static BcStatus bc_vm_run(void)
7351 {
7352         BcStatus st = zbc_vm_exec();
7353 #if ENABLE_FEATURE_CLEAN_UP
7354         if (G_exiting) // it was actually "halt" or "quit"
7355                 st = EXIT_SUCCESS;
7356         bc_vm_free();
7357 # if ENABLE_FEATURE_EDITING
7358         free_line_input_t(G.line_input_state);
7359 # endif
7360         FREE_G();
7361 #endif
7362         dbg_exec("exiting with exitcode %d", st);
7363         return st;
7364 }
7365
7366 #if ENABLE_BC
7367 int bc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
7368 int bc_main(int argc UNUSED_PARAM, char **argv)
7369 {
7370         int is_tty;
7371
7372         INIT_G();
7373
7374         is_tty = bc_vm_init("BC_LINE_LENGTH");
7375
7376         bc_args(argv);
7377
7378         if (is_tty && !(option_mask32 & BC_FLAG_Q))
7379                 bc_vm_info();
7380
7381         return bc_vm_run();
7382 }
7383 #endif
7384
7385 #if ENABLE_DC
7386 int dc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
7387 int dc_main(int argc UNUSED_PARAM, char **argv)
7388 {
7389         int noscript;
7390
7391         INIT_G();
7392
7393         // TODO: dc (GNU bc 1.07.1) 1.4.1 seems to use width
7394         // 1 char wider than bc from the same package.
7395         // Both default width, and xC_LINE_LENGTH=N are wider:
7396         // "DC_LINE_LENGTH=5 dc -e'123456 p'" prints:
7397         //      |1234\   |
7398         //      |56      |
7399         // "echo '123456' | BC_LINE_LENGTH=5 bc" prints:
7400         //      |123\    |
7401         //      |456     |
7402         // Do the same, or it's a bug?
7403         bc_vm_init("DC_LINE_LENGTH");
7404
7405         // Run -e'SCRIPT' and -fFILE in order of appearance, then handle FILEs
7406         noscript = BC_FLAG_I;
7407         for (;;) {
7408                 int n = getopt(argc, argv, "e:f:x");
7409                 if (n <= 0)
7410                         break;
7411                 switch (n) {
7412                 case 'e':
7413                         noscript = 0;
7414                         n = zbc_vm_process(optarg);
7415                         if (n) return n;
7416                         break;
7417                 case 'f':
7418                         noscript = 0;
7419                         n = zbc_vm_file(optarg);
7420                         if (n) return n;
7421                         break;
7422                 case 'x':
7423                         option_mask32 |= DC_FLAG_X;
7424                         break;
7425                 default:
7426                         bb_show_usage();
7427                 }
7428         }
7429         argv += optind;
7430
7431         while (*argv) {
7432                 noscript = 0;
7433                 bc_vec_push(&G.files, argv++);
7434         }
7435
7436         option_mask32 |= noscript; // set BC_FLAG_I if we need to interpret stdin
7437
7438         return bc_vm_run();
7439 }
7440 #endif
7441
7442 #endif // not DC_SMALL