You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5867 lines
133 KiB
5867 lines
133 KiB
/* bc.c - An implementation of POSIX bc.
|
|
*
|
|
* Copyright 2018 Gavin D. Howard <yzena.tech@gmail.com>
|
|
*
|
|
* See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/bc.html
|
|
|
|
USE_BC(NEWTOY(bc, "i(interactive)l(mathlib)q(quiet)s(standard)w(warn)", TOYFLAG_USR|TOYFLAG_BIN|TOYFLAG_LOCALE))
|
|
|
|
config BC
|
|
bool "bc"
|
|
default n
|
|
help
|
|
usage: bc [-ilqsw] [file ...]
|
|
|
|
bc is a command-line calculator with a Turing-complete language.
|
|
|
|
options:
|
|
|
|
-i --interactive force interactive mode
|
|
-l --mathlib use predefined math routines:
|
|
|
|
s(expr) = sine of expr in radians
|
|
c(expr) = cosine of expr in radians
|
|
a(expr) = arctangent of expr, returning radians
|
|
l(expr) = natural log of expr
|
|
e(expr) = raises e to the power of expr
|
|
j(n, x) = Bessel function of integer order n of x
|
|
|
|
-q --quiet don't print version and copyright
|
|
-s --standard error if any non-POSIX extensions are used
|
|
-w --warn warn if any non-POSIX extensions are used
|
|
|
|
*/
|
|
|
|
#define FOR_bc
|
|
#include "toys.h"
|
|
|
|
GLOBALS(
|
|
// This actually needs to be a BcVm*, but the toybox build
|
|
// system complains if I make it so. Instead, we'll just cast.
|
|
char *vm;
|
|
|
|
size_t nchars;
|
|
char *file, sig, max_ibase;
|
|
uint16_t line_len;
|
|
)
|
|
|
|
#define BC_VM ((BcVm*) TT.vm)
|
|
|
|
typedef enum BcStatus {
|
|
|
|
BC_STATUS_SUCCESS = 0,
|
|
BC_STATUS_ERROR,
|
|
BC_STATUS_EOF,
|
|
BC_STATUS_EMPTY_EXPR,
|
|
BC_STATUS_SIGNAL,
|
|
BC_STATUS_QUIT,
|
|
|
|
} BcStatus;
|
|
|
|
typedef enum BcError {
|
|
|
|
BC_ERROR_VM_ALLOC_ERR,
|
|
BC_ERROR_VM_IO_ERR,
|
|
BC_ERROR_VM_BIN_FILE,
|
|
BC_ERROR_VM_PATH_DIR,
|
|
|
|
BC_ERROR_PARSE_EOF,
|
|
BC_ERROR_PARSE_CHAR,
|
|
BC_ERROR_PARSE_STRING,
|
|
BC_ERROR_PARSE_COMMENT,
|
|
BC_ERROR_PARSE_TOKEN,
|
|
BC_ERROR_EXEC_NUM_LEN,
|
|
BC_ERROR_EXEC_NAME_LEN,
|
|
BC_ERROR_EXEC_STRING_LEN,
|
|
BC_ERROR_PARSE_EXPR,
|
|
BC_ERROR_PARSE_EMPTY_EXPR,
|
|
BC_ERROR_PARSE_PRINT,
|
|
BC_ERROR_PARSE_FUNC,
|
|
BC_ERROR_PARSE_ASSIGN,
|
|
BC_ERROR_PARSE_NO_AUTO,
|
|
BC_ERROR_PARSE_DUP_LOCAL,
|
|
BC_ERROR_PARSE_BLOCK,
|
|
BC_ERROR_PARSE_RET_VOID,
|
|
|
|
BC_ERROR_MATH_NEGATIVE,
|
|
BC_ERROR_MATH_NON_INTEGER,
|
|
BC_ERROR_MATH_OVERFLOW,
|
|
BC_ERROR_MATH_DIVIDE_BY_ZERO,
|
|
|
|
BC_ERROR_EXEC_FILE_ERR,
|
|
BC_ERROR_EXEC_ARRAY_LEN,
|
|
BC_ERROR_EXEC_IBASE,
|
|
BC_ERROR_EXEC_OBASE,
|
|
BC_ERROR_EXEC_SCALE,
|
|
BC_ERROR_EXEC_READ_EXPR,
|
|
BC_ERROR_EXEC_REC_READ,
|
|
BC_ERROR_EXEC_TYPE,
|
|
BC_ERROR_EXEC_PARAMS,
|
|
BC_ERROR_EXEC_UNDEF_FUNC,
|
|
BC_ERROR_EXEC_VOID_VAL,
|
|
|
|
BC_ERROR_POSIX_START,
|
|
|
|
BC_ERROR_POSIX_NAME_LEN = BC_ERROR_POSIX_START,
|
|
BC_ERROR_POSIX_COMMENT,
|
|
BC_ERROR_POSIX_KW,
|
|
BC_ERROR_POSIX_DOT,
|
|
BC_ERROR_POSIX_RET,
|
|
BC_ERROR_POSIX_BOOL,
|
|
BC_ERROR_POSIX_REL_POS,
|
|
BC_ERROR_POSIX_MULTIREL,
|
|
BC_ERROR_POSIX_FOR1,
|
|
BC_ERROR_POSIX_FOR2,
|
|
BC_ERROR_POSIX_FOR3,
|
|
BC_ERROR_POSIX_BRACE,
|
|
BC_ERROR_POSIX_REF,
|
|
|
|
} BcError;
|
|
|
|
#define BC_ERR_IDX_VM (0)
|
|
#define BC_ERR_IDX_PARSE (1)
|
|
#define BC_ERR_IDX_MATH (2)
|
|
#define BC_ERR_IDX_EXEC (3)
|
|
#define BC_ERR_IDX_POSIX (4)
|
|
|
|
#define BC_VEC_START_CAP (1<<5)
|
|
|
|
typedef unsigned char uchar;
|
|
|
|
typedef void (*BcVecFree)(void*);
|
|
|
|
typedef struct BcVec {
|
|
char *v;
|
|
size_t len, cap, size;
|
|
BcVecFree dtor;
|
|
} BcVec;
|
|
|
|
#define bc_vec_pop(v) (bc_vec_npop((v), 1))
|
|
#define bc_vec_top(v) (bc_vec_item_rev((v), 0))
|
|
|
|
typedef signed char BcDig;
|
|
|
|
typedef struct BcNum {
|
|
signed char *num;
|
|
unsigned long rdx, len, cap;
|
|
int neg;
|
|
} BcNum;
|
|
|
|
#define BC_NUM_DEF_SIZE (16)
|
|
|
|
// A crude, but always big enough, calculation of
|
|
// the size required for ibase and obase BcNum's.
|
|
#define BC_NUM_LONG_LOG10 ((CHAR_BIT * sizeof(unsigned long) + 1) / 2 + 1)
|
|
|
|
#define BC_NUM_NEG(n, neg) ((((ssize_t) (n)) ^ -((ssize_t) (neg))) + (neg))
|
|
|
|
#define BC_NUM_ONE(n) ((n)->len == 1 && (n)->rdx == 0 && (n)->num[0] == 1)
|
|
#define BC_NUM_INT(n) ((n)->len - (n)->rdx)
|
|
#define BC_NUM_CMP_ZERO(a) (BC_NUM_NEG((a)->len != 0, (a)->neg))
|
|
|
|
typedef BcStatus (*BcNumBinaryOp)(BcNum*, BcNum*, BcNum*, size_t);
|
|
typedef size_t (*BcNumBinaryOpReq)(BcNum*, BcNum*, size_t);
|
|
typedef void (*BcNumDigitOp)(size_t, size_t, int);
|
|
|
|
void bc_num_init(BcNum *n, size_t req);
|
|
void bc_num_expand(BcNum *n, size_t req);
|
|
void bc_num_copy(BcNum *d, BcNum *s);
|
|
void bc_num_createCopy(BcNum *d, BcNum *s);
|
|
void bc_num_createFromUlong(BcNum *n, unsigned long val);
|
|
void bc_num_free(void *num);
|
|
|
|
BcStatus bc_num_ulong(BcNum *n, unsigned long *result);
|
|
void bc_num_ulong2num(BcNum *n, unsigned long val);
|
|
|
|
BcStatus bc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale);
|
|
BcStatus bc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale);
|
|
BcStatus bc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale);
|
|
BcStatus bc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale);
|
|
BcStatus bc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale);
|
|
BcStatus bc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale);
|
|
BcStatus bc_num_sqrt(BcNum *a, BcNum *b, size_t scale);
|
|
BcStatus bc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d, size_t scale);
|
|
|
|
size_t bc_num_addReq(BcNum *a, BcNum *b, size_t scale);
|
|
|
|
size_t bc_num_mulReq(BcNum *a, BcNum *b, size_t scale);
|
|
size_t bc_num_powReq(BcNum *a, BcNum *b, size_t scale);
|
|
|
|
typedef enum BcInst {
|
|
|
|
BC_INST_INC_POST = 0,
|
|
BC_INST_DEC_POST,
|
|
BC_INST_INC_PRE,
|
|
BC_INST_DEC_PRE,
|
|
|
|
BC_INST_NEG,
|
|
BC_INST_BOOL_NOT,
|
|
|
|
BC_INST_POWER,
|
|
BC_INST_MULTIPLY,
|
|
BC_INST_DIVIDE,
|
|
BC_INST_MODULUS,
|
|
BC_INST_PLUS,
|
|
BC_INST_MINUS,
|
|
|
|
BC_INST_REL_EQ,
|
|
BC_INST_REL_LE,
|
|
BC_INST_REL_GE,
|
|
BC_INST_REL_NE,
|
|
BC_INST_REL_LT,
|
|
BC_INST_REL_GT,
|
|
|
|
BC_INST_BOOL_OR,
|
|
BC_INST_BOOL_AND,
|
|
|
|
BC_INST_ASSIGN_POWER,
|
|
BC_INST_ASSIGN_MULTIPLY,
|
|
BC_INST_ASSIGN_DIVIDE,
|
|
BC_INST_ASSIGN_MODULUS,
|
|
BC_INST_ASSIGN_PLUS,
|
|
BC_INST_ASSIGN_MINUS,
|
|
BC_INST_ASSIGN,
|
|
|
|
BC_INST_NUM,
|
|
BC_INST_VAR,
|
|
BC_INST_ARRAY_ELEM,
|
|
BC_INST_ARRAY,
|
|
|
|
BC_INST_LAST,
|
|
BC_INST_IBASE,
|
|
BC_INST_OBASE,
|
|
BC_INST_SCALE,
|
|
BC_INST_LENGTH,
|
|
BC_INST_SCALE_FUNC,
|
|
BC_INST_SQRT,
|
|
BC_INST_ABS,
|
|
BC_INST_READ,
|
|
|
|
BC_INST_PRINT,
|
|
BC_INST_PRINT_POP,
|
|
BC_INST_STR,
|
|
BC_INST_PRINT_STR,
|
|
|
|
BC_INST_JUMP,
|
|
BC_INST_JUMP_ZERO,
|
|
|
|
BC_INST_CALL,
|
|
|
|
BC_INST_RET,
|
|
BC_INST_RET0,
|
|
BC_INST_RET_VOID,
|
|
|
|
BC_INST_HALT,
|
|
|
|
BC_INST_POP,
|
|
BC_INST_POP_EXEC,
|
|
|
|
} BcInst;
|
|
|
|
typedef struct BcFunc {
|
|
|
|
BcVec code;
|
|
BcVec labels;
|
|
BcVec autos;
|
|
size_t nparams;
|
|
|
|
BcVec strs;
|
|
BcVec consts;
|
|
|
|
char *name;
|
|
int voidfn;
|
|
|
|
} BcFunc;
|
|
|
|
typedef enum BcResultType {
|
|
|
|
BC_RESULT_VAR,
|
|
BC_RESULT_ARRAY_ELEM,
|
|
BC_RESULT_ARRAY,
|
|
|
|
BC_RESULT_STR,
|
|
|
|
BC_RESULT_CONSTANT,
|
|
BC_RESULT_TEMP,
|
|
|
|
BC_RESULT_VOID,
|
|
BC_RESULT_ONE,
|
|
BC_RESULT_LAST,
|
|
BC_RESULT_IBASE,
|
|
BC_RESULT_OBASE,
|
|
BC_RESULT_SCALE,
|
|
|
|
} BcResultType;
|
|
|
|
typedef union BcResultData {
|
|
BcNum n;
|
|
BcVec v;
|
|
struct str_len id;
|
|
} BcResultData;
|
|
|
|
typedef struct BcResult {
|
|
BcResultType t;
|
|
BcResultData d;
|
|
} BcResult;
|
|
|
|
typedef struct BcInstPtr {
|
|
size_t func;
|
|
size_t idx;
|
|
size_t len;
|
|
} BcInstPtr;
|
|
|
|
typedef enum BcType {
|
|
BC_TYPE_VAR,
|
|
BC_TYPE_ARRAY,
|
|
} BcType;
|
|
|
|
void bc_array_expand(BcVec *a, size_t len);
|
|
int bc_id_cmp(struct str_len *e1, struct str_len *e2);
|
|
|
|
#define bc_lex_err(l, e) (bc_vm_error((e), (l)->line))
|
|
#define bc_lex_verr(l, e, ...) (bc_vm_error((e), (l)->line, __VA_ARGS__))
|
|
|
|
#define BC_LEX_NUM_CHAR(c, l, pt) \
|
|
(isdigit(c) || ((c) >= 'A' && (c) <= (l)) || ((c) == '.' && !(pt)))
|
|
|
|
// BC_LEX_NEG is not used in lexing; it is only for parsing.
|
|
typedef enum BcLexType {
|
|
|
|
BC_LEX_EOF,
|
|
BC_LEX_INVALID,
|
|
|
|
BC_LEX_OP_INC,
|
|
BC_LEX_OP_DEC,
|
|
|
|
BC_LEX_NEG,
|
|
BC_LEX_OP_BOOL_NOT,
|
|
|
|
BC_LEX_OP_POWER,
|
|
BC_LEX_OP_MULTIPLY,
|
|
BC_LEX_OP_DIVIDE,
|
|
BC_LEX_OP_MODULUS,
|
|
BC_LEX_OP_PLUS,
|
|
BC_LEX_OP_MINUS,
|
|
|
|
BC_LEX_OP_REL_EQ,
|
|
BC_LEX_OP_REL_LE,
|
|
BC_LEX_OP_REL_GE,
|
|
BC_LEX_OP_REL_NE,
|
|
BC_LEX_OP_REL_LT,
|
|
BC_LEX_OP_REL_GT,
|
|
|
|
BC_LEX_OP_BOOL_OR,
|
|
BC_LEX_OP_BOOL_AND,
|
|
|
|
BC_LEX_OP_ASSIGN_POWER,
|
|
BC_LEX_OP_ASSIGN_MULTIPLY,
|
|
BC_LEX_OP_ASSIGN_DIVIDE,
|
|
BC_LEX_OP_ASSIGN_MODULUS,
|
|
BC_LEX_OP_ASSIGN_PLUS,
|
|
BC_LEX_OP_ASSIGN_MINUS,
|
|
BC_LEX_OP_ASSIGN,
|
|
|
|
BC_LEX_NLINE,
|
|
BC_LEX_WHITESPACE,
|
|
|
|
BC_LEX_LPAREN,
|
|
BC_LEX_RPAREN,
|
|
|
|
BC_LEX_LBRACKET,
|
|
BC_LEX_COMMA,
|
|
BC_LEX_RBRACKET,
|
|
|
|
BC_LEX_LBRACE,
|
|
BC_LEX_SCOLON,
|
|
BC_LEX_RBRACE,
|
|
|
|
BC_LEX_STR,
|
|
BC_LEX_NAME,
|
|
BC_LEX_NUMBER,
|
|
|
|
BC_LEX_KEY_AUTO,
|
|
BC_LEX_KEY_BREAK,
|
|
BC_LEX_KEY_CONTINUE,
|
|
BC_LEX_KEY_DEFINE,
|
|
BC_LEX_KEY_FOR,
|
|
BC_LEX_KEY_IF,
|
|
BC_LEX_KEY_LIMITS,
|
|
BC_LEX_KEY_RETURN,
|
|
BC_LEX_KEY_WHILE,
|
|
BC_LEX_KEY_HALT,
|
|
BC_LEX_KEY_LAST,
|
|
BC_LEX_KEY_IBASE,
|
|
BC_LEX_KEY_OBASE,
|
|
BC_LEX_KEY_SCALE,
|
|
BC_LEX_KEY_LENGTH,
|
|
BC_LEX_KEY_PRINT,
|
|
BC_LEX_KEY_SQRT,
|
|
BC_LEX_KEY_ABS,
|
|
BC_LEX_KEY_QUIT,
|
|
BC_LEX_KEY_READ,
|
|
BC_LEX_KEY_ELSE,
|
|
|
|
} BcLexType;
|
|
|
|
typedef struct BcLex {
|
|
|
|
char *buf;
|
|
size_t i;
|
|
size_t line;
|
|
size_t len;
|
|
|
|
BcLexType t;
|
|
BcLexType last;
|
|
BcVec str;
|
|
|
|
} BcLex;
|
|
|
|
#define BC_PARSE_REL (1<<0)
|
|
#define BC_PARSE_PRINT (1<<1)
|
|
#define BC_PARSE_NOCALL (1<<2)
|
|
#define BC_PARSE_NOREAD (1<<3)
|
|
#define BC_PARSE_ARRAY (1<<4)
|
|
|
|
#define bc_parse_push(p, i) (bc_vec_pushByte(&(p)->func->code, i))
|
|
#define bc_parse_number(p)(bc_parse_addId((p), BC_INST_NUM))
|
|
#define bc_parse_string(p)(bc_parse_addId((p), BC_INST_STR))
|
|
|
|
#define bc_parse_err(p, e) (bc_vm_error((e), (p)->l.line))
|
|
#define bc_parse_verr(p, e, ...) (bc_vm_error((e), (p)->l.line, __VA_ARGS__))
|
|
|
|
typedef struct BcParseNext {
|
|
char len, tokens[4];
|
|
} BcParseNext;
|
|
|
|
#define BC_PARSE_NEXT_TOKENS(...) .tokens = { __VA_ARGS__ }
|
|
#define BC_PARSE_NEXT(a, ...) { .len = a, BC_PARSE_NEXT_TOKENS(__VA_ARGS__) }
|
|
|
|
struct BcProgram;
|
|
|
|
typedef struct BcParse {
|
|
|
|
BcLex l;
|
|
|
|
BcVec flags;
|
|
BcVec exits;
|
|
BcVec conds;
|
|
BcVec ops;
|
|
|
|
struct BcProgram *prog;
|
|
BcFunc *func;
|
|
size_t fidx;
|
|
|
|
int auto_part;
|
|
|
|
} BcParse;
|
|
|
|
typedef struct BcLexKeyword {
|
|
char data, name[9];
|
|
} BcLexKeyword;
|
|
|
|
#define BC_LEX_CHAR_MSB(bit) ((bit) << (CHAR_BIT - 1))
|
|
|
|
#define BC_LEX_KW_POSIX(kw) ((kw)->data & (BC_LEX_CHAR_MSB(1)))
|
|
#define BC_LEX_KW_LEN(kw) ((size_t) ((kw)->data & ~(BC_LEX_CHAR_MSB(1))))
|
|
|
|
#define BC_LEX_KW_ENTRY(a, b, c) \
|
|
{ .data = ((b) & ~(BC_LEX_CHAR_MSB(1))) | BC_LEX_CHAR_MSB(c),.name = a }
|
|
|
|
#define bc_lex_posixErr(l, e) (bc_vm_posixError((e), (l)->line))
|
|
#define bc_lex_vposixErr(l, e, ...) \
|
|
(bc_vm_posixError((e), (l)->line, __VA_ARGS__))
|
|
|
|
BcStatus bc_lex_token(BcLex *l);
|
|
|
|
#define BC_PARSE_TOP_FLAG_PTR(p) ((uint16_t*) bc_vec_top(&(p)->flags))
|
|
#define BC_PARSE_TOP_FLAG(p) (*(BC_PARSE_TOP_FLAG_PTR(p)))
|
|
|
|
#define BC_PARSE_FLAG_BRACE (1<<0)
|
|
#define BC_PARSE_BRACE(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_BRACE)
|
|
|
|
#define BC_PARSE_FLAG_FUNC_INNER (1<<1)
|
|
#define BC_PARSE_FUNC_INNER(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_FUNC_INNER)
|
|
|
|
#define BC_PARSE_FLAG_FUNC (1<<2)
|
|
#define BC_PARSE_FUNC(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_FUNC)
|
|
|
|
#define BC_PARSE_FLAG_BODY (1<<3)
|
|
#define BC_PARSE_BODY(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_BODY)
|
|
|
|
#define BC_PARSE_FLAG_LOOP (1<<4)
|
|
#define BC_PARSE_LOOP(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_LOOP)
|
|
|
|
#define BC_PARSE_FLAG_LOOP_INNER (1<<5)
|
|
#define BC_PARSE_LOOP_INNER(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_LOOP_INNER)
|
|
|
|
#define BC_PARSE_FLAG_IF (1<<6)
|
|
#define BC_PARSE_IF(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_IF)
|
|
|
|
#define BC_PARSE_FLAG_ELSE (1<<7)
|
|
#define BC_PARSE_ELSE(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_ELSE)
|
|
|
|
#define BC_PARSE_FLAG_IF_END (1<<8)
|
|
#define BC_PARSE_IF_END(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_IF_END)
|
|
|
|
#define BC_PARSE_NO_EXEC(p) ((p)->flags.len != 1 || BC_PARSE_TOP_FLAG(p) != 0)
|
|
|
|
#define BC_PARSE_DELIMITER(t) \
|
|
((t) == BC_LEX_SCOLON || (t) == BC_LEX_NLINE || (t) == BC_LEX_EOF)
|
|
|
|
#define BC_PARSE_BLOCK_STMT(f) \
|
|
((f) & (BC_PARSE_FLAG_ELSE | BC_PARSE_FLAG_LOOP_INNER))
|
|
|
|
#define BC_PARSE_OP(p, l) (((p) & ~(BC_LEX_CHAR_MSB(1))) | (BC_LEX_CHAR_MSB(l)))
|
|
|
|
#define BC_PARSE_OP_DATA(t) bc_parse_ops[((t) - BC_LEX_OP_INC)]
|
|
#define BC_PARSE_OP_LEFT(op) (BC_PARSE_OP_DATA(op) & BC_LEX_CHAR_MSB(1))
|
|
#define BC_PARSE_OP_PREC(op) (BC_PARSE_OP_DATA(op) & ~(BC_LEX_CHAR_MSB(1)))
|
|
|
|
#define BC_PARSE_TOP_OP(p) (*((BcLexType*) bc_vec_top(&(p)->ops)))
|
|
#define BC_PARSE_LEAF(prev, bin_last, rparen) \
|
|
(!(bin_last) && ((rparen) || bc_parse_inst_isLeaf(prev)))
|
|
#define BC_PARSE_INST_VAR(t) \
|
|
((t) >= BC_INST_VAR && (t) <= BC_INST_SCALE && (t) != BC_INST_ARRAY)
|
|
|
|
#define BC_PARSE_PREV_PREFIX(p) \
|
|
((p) >= BC_INST_INC_PRE && (p) <= BC_INST_BOOL_NOT)
|
|
#define BC_PARSE_OP_PREFIX(t) ((t) == BC_LEX_OP_BOOL_NOT || (t) == BC_LEX_NEG)
|
|
|
|
// We can calculate the conversion between tokens and exprs by subtracting the
|
|
// position of the first operator in the lex enum and adding the position of
|
|
// the first in the expr enum. Note: This only works for binary operators.
|
|
#define BC_PARSE_TOKEN_INST(t) ((uchar) ((t) - BC_LEX_NEG + BC_INST_NEG))
|
|
|
|
#define bc_parse_posixErr(p, e) (bc_vm_posixError((e), (p)->l.line))
|
|
|
|
BcStatus bc_parse_parse(BcParse *p);
|
|
BcStatus bc_parse_expr_status(BcParse *p, uint8_t flags, BcParseNext next);
|
|
void bc_parse_noElse(BcParse *p);
|
|
|
|
#define BC_PROG_ONE_CAP (1)
|
|
|
|
typedef struct BcProgram {
|
|
|
|
size_t scale;
|
|
|
|
BcNum ib;
|
|
size_t ib_t;
|
|
BcNum ob;
|
|
size_t ob_t;
|
|
|
|
BcVec results;
|
|
BcVec stack;
|
|
|
|
BcVec fns;
|
|
BcVec fn_map;
|
|
|
|
BcVec vars;
|
|
BcVec var_map;
|
|
|
|
BcVec arrs;
|
|
BcVec arr_map;
|
|
|
|
BcNum one;
|
|
BcNum last;
|
|
|
|
signed char ib_num[BC_NUM_LONG_LOG10], ob_num[BC_NUM_LONG_LOG10],
|
|
one_num[BC_PROG_ONE_CAP];
|
|
} BcProgram;
|
|
|
|
#define BC_PROG_STACK(s, n) ((s)->len >= ((size_t) (n)))
|
|
|
|
#define BC_PROG_MAIN (0)
|
|
#define BC_PROG_READ (1)
|
|
|
|
#define BC_PROG_STR(n) (!(n)->num && !(n)->cap)
|
|
#define BC_PROG_NUM(r, n) \
|
|
((r)->t != BC_RESULT_ARRAY && (r)->t != BC_RESULT_STR && !BC_PROG_STR(n))
|
|
|
|
typedef void (*BcProgramUnary)(BcResult*, BcNum*);
|
|
|
|
void bc_program_addFunc(BcProgram *p, BcFunc *f, char *name);
|
|
size_t bc_program_insertFunc(BcProgram *p, char *name);
|
|
BcStatus bc_program_reset(BcProgram *p, BcStatus s);
|
|
BcStatus bc_program_exec(BcProgram *p);
|
|
|
|
unsigned long bc_program_scale(BcNum *n);
|
|
unsigned long bc_program_len(BcNum *n);
|
|
|
|
void bc_program_negate(BcResult *r, BcNum *n);
|
|
void bc_program_not(BcResult *r, BcNum *n);
|
|
|
|
#define BC_FLAG_TTYIN (1<<7)
|
|
#define BC_TTYIN (toys.optflags & BC_FLAG_TTYIN)
|
|
|
|
#define BC_MAX_OBASE ((unsigned long) INT_MAX)
|
|
#define BC_MAX_DIM ((unsigned long) INT_MAX)
|
|
#define BC_MAX_SCALE ((unsigned long) UINT_MAX)
|
|
#define BC_MAX_STRING ((unsigned long) UINT_MAX - 1)
|
|
#define BC_MAX_NAME BC_MAX_STRING
|
|
#define BC_MAX_NUM BC_MAX_STRING
|
|
#define BC_MAX_EXP ((unsigned long) ULONG_MAX)
|
|
#define BC_MAX_VARS ((unsigned long) SIZE_MAX - 1)
|
|
|
|
#define bc_vm_err(e) (bc_vm_error((e), 0))
|
|
#define bc_vm_verr(e, ...) (bc_vm_error((e), 0, __VA_ARGS__))
|
|
|
|
typedef struct BcVm {
|
|
BcParse prs;
|
|
BcProgram prog;
|
|
} BcVm;
|
|
|
|
BcStatus bc_vm_posixError(BcError e, size_t line, ...);
|
|
|
|
BcStatus bc_vm_error(BcError e, size_t line, ...);
|
|
|
|
char bc_sig_msg[] = "\ninterrupt (type \"quit\" to exit)\n";
|
|
|
|
char bc_copyright[] =
|
|
"Copyright (c) 2018 Gavin D. Howard and contributors\n"
|
|
"Report bugs at: https://github.com/gavinhoward/bc\n\n"
|
|
"This is free software with ABSOLUTELY NO WARRANTY.\n";
|
|
|
|
char *bc_err_fmt = "\n%s error: ";
|
|
char *bc_warn_fmt = "\n%s warning: ";
|
|
char *bc_err_line = ":%zu";
|
|
|
|
char *bc_errs[] = {
|
|
"VM",
|
|
"Parse",
|
|
"Math",
|
|
"Runtime",
|
|
"POSIX",
|
|
};
|
|
|
|
char bc_err_ids[] = {
|
|
BC_ERR_IDX_VM, BC_ERR_IDX_VM, BC_ERR_IDX_VM, BC_ERR_IDX_VM,
|
|
BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE,
|
|
BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE,
|
|
BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE,
|
|
BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE,
|
|
BC_ERR_IDX_PARSE,
|
|
BC_ERR_IDX_MATH, BC_ERR_IDX_MATH, BC_ERR_IDX_MATH, BC_ERR_IDX_MATH,
|
|
BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC,
|
|
BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC,
|
|
BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC,
|
|
BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX,
|
|
BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX,
|
|
BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX, BC_ERR_IDX_POSIX,
|
|
BC_ERR_IDX_POSIX,
|
|
};
|
|
|
|
char *bc_err_msgs[] = {
|
|
|
|
"memory allocation error",
|
|
"I/O error",
|
|
"file is not ASCII: %s",
|
|
"path is a directory: %s",
|
|
|
|
"end of file",
|
|
"bad character (%c)",
|
|
"string end could not be found",
|
|
"comment end could not be found",
|
|
"bad token",
|
|
"name too long: must be [1, %lu]",
|
|
"string too long: must be [1, %lu]",
|
|
"array too long; must be [1, %lu]",
|
|
"bad expression",
|
|
"empty expression",
|
|
"bad print statement",
|
|
"bad function definition",
|
|
"bad assignment: left side must be scale, ibase, "
|
|
"obase, last, var, or array element",
|
|
"no auto variable found",
|
|
"function parameter or auto \"%s\" already exists",
|
|
"block end could not be found",
|
|
"cannot return a value from void function: %s()",
|
|
|
|
"negative number",
|
|
"non integer number",
|
|
"overflow",
|
|
"divide by zero",
|
|
|
|
"could not open file: %s",
|
|
"number too long: must be [1, %lu]",
|
|
"bad ibase; must be [%lu, %lu]",
|
|
"bad obase; must be [%lu, %lu]",
|
|
"bad scale; must be [%lu, %lu]",
|
|
"bad read() expression",
|
|
"read() call inside of a read() call",
|
|
"variable is wrong type",
|
|
"mismatched parameters; need %zu, have %zu",
|
|
"undefined function: %s()",
|
|
"cannot use a void value in an expression",
|
|
|
|
"POSIX does not allow names longer than 1 character, like \"%s\"",
|
|
"POSIX does not allow '#' script comments",
|
|
"POSIX does not allow \"%s\" as a keyword",
|
|
"POSIX does not allow a period ('.') as a shortcut for the last result",
|
|
"POSIX requires parentheses around return expressions",
|
|
"POSIX does not allow the \"%s\" operators",
|
|
"POSIX does not allow comparison operators outside if or loops",
|
|
"POSIX requires zero or one comparison operator per condition",
|
|
"POSIX does not allow an empty init expression in a for loop",
|
|
"POSIX does not allow an empty condition expression in a for loop",
|
|
"POSIX does not allow an empty update expression in a for loop",
|
|
"POSIX requires the left brace be on the same line as the function header",
|
|
"POSIX does not allow array references as function parameters",
|
|
|
|
};
|
|
|
|
char bc_func_main[] = "(main)";
|
|
char bc_func_read[] = "(read)";
|
|
|
|
BcLexKeyword bc_lex_kws[] = {
|
|
BC_LEX_KW_ENTRY("auto", 4, 1),
|
|
BC_LEX_KW_ENTRY("break", 5, 1),
|
|
BC_LEX_KW_ENTRY("continue", 8, 0),
|
|
BC_LEX_KW_ENTRY("define", 6, 1),
|
|
BC_LEX_KW_ENTRY("for", 3, 1),
|
|
BC_LEX_KW_ENTRY("if", 2, 1),
|
|
BC_LEX_KW_ENTRY("limits", 6, 0),
|
|
BC_LEX_KW_ENTRY("return", 6, 1),
|
|
BC_LEX_KW_ENTRY("while", 5, 1),
|
|
BC_LEX_KW_ENTRY("halt", 4, 0),
|
|
BC_LEX_KW_ENTRY("last", 4, 0),
|
|
BC_LEX_KW_ENTRY("ibase", 5, 1),
|
|
BC_LEX_KW_ENTRY("obase", 5, 1),
|
|
BC_LEX_KW_ENTRY("scale", 5, 1),
|
|
BC_LEX_KW_ENTRY("length", 6, 1),
|
|
BC_LEX_KW_ENTRY("print", 5, 0),
|
|
BC_LEX_KW_ENTRY("sqrt", 4, 1),
|
|
BC_LEX_KW_ENTRY("abs", 3, 0),
|
|
BC_LEX_KW_ENTRY("quit", 4, 1),
|
|
BC_LEX_KW_ENTRY("read", 4, 0),
|
|
BC_LEX_KW_ENTRY("else", 4, 0),
|
|
};
|
|
|
|
size_t bc_lex_kws_len = sizeof(bc_lex_kws) / sizeof(BcLexKeyword);
|
|
|
|
char *bc_parse_const1 = "1";
|
|
|
|
// This is an array of data for operators that correspond to token types.
|
|
uchar bc_parse_ops[] = {
|
|
BC_PARSE_OP(0, 0), BC_PARSE_OP(0, 0),
|
|
BC_PARSE_OP(1, 0), BC_PARSE_OP(1, 0),
|
|
BC_PARSE_OP(4, 0),
|
|
BC_PARSE_OP(5, 1), BC_PARSE_OP(5, 1), BC_PARSE_OP(5, 1),
|
|
BC_PARSE_OP(6, 1), BC_PARSE_OP(6, 1),
|
|
BC_PARSE_OP(9, 1), BC_PARSE_OP(9, 1), BC_PARSE_OP(9, 1),
|
|
BC_PARSE_OP(9, 1), BC_PARSE_OP(9, 1), BC_PARSE_OP(9, 1),
|
|
BC_PARSE_OP(11, 1), BC_PARSE_OP(10, 1),
|
|
BC_PARSE_OP(8, 0), BC_PARSE_OP(8, 0), BC_PARSE_OP(8, 0),
|
|
BC_PARSE_OP(8, 0), BC_PARSE_OP(8, 0), BC_PARSE_OP(8, 0),
|
|
BC_PARSE_OP(8, 0),
|
|
};
|
|
|
|
// These identify what tokens can come after expressions in certain cases.
|
|
BcParseNext bc_parse_next_expr =
|
|
BC_PARSE_NEXT(4, BC_LEX_NLINE, BC_LEX_SCOLON, BC_LEX_RBRACE, BC_LEX_EOF);
|
|
BcParseNext bc_parse_next_param =
|
|
BC_PARSE_NEXT(2, BC_LEX_RPAREN, BC_LEX_COMMA);
|
|
BcParseNext bc_parse_next_print =
|
|
BC_PARSE_NEXT(4, BC_LEX_COMMA, BC_LEX_NLINE, BC_LEX_SCOLON, BC_LEX_EOF);
|
|
BcParseNext bc_parse_next_rel = BC_PARSE_NEXT(1, BC_LEX_RPAREN);
|
|
BcParseNext bc_parse_next_elem = BC_PARSE_NEXT(1, BC_LEX_RBRACKET);
|
|
BcParseNext bc_parse_next_for = BC_PARSE_NEXT(1, BC_LEX_SCOLON);
|
|
BcParseNext bc_parse_next_read =
|
|
BC_PARSE_NEXT(2, BC_LEX_NLINE, BC_LEX_EOF);
|
|
|
|
char bc_num_hex_digits[] = "0123456789ABCDEF";
|
|
|
|
BcNumBinaryOp bc_program_ops[] = {
|
|
bc_num_pow, bc_num_mul, bc_num_div, bc_num_mod, bc_num_add, bc_num_sub,
|
|
};
|
|
|
|
BcNumBinaryOpReq bc_program_opReqs[] = {
|
|
bc_num_powReq, bc_num_mulReq, bc_num_mulReq, bc_num_mulReq,
|
|
bc_num_addReq, bc_num_addReq,
|
|
};
|
|
|
|
BcProgramUnary bc_program_unarys[] = {
|
|
bc_program_negate, bc_program_not,
|
|
};
|
|
|
|
char bc_program_stdin_name[] = "<stdin>";
|
|
char bc_program_ready_msg[] = "ready for more input\n";
|
|
|
|
char *bc_lib_name = "gen/lib.bc";
|
|
|
|
char bc_lib[] = {
|
|
115,99,97,108,101,61,50,48,10,100,101,102,105,110,101,32,101,40,120,41,123,
|
|
10,97,117,116,111,32,98,44,115,44,110,44,114,44,100,44,105,44,112,44,102,44,
|
|
118,10,98,61,105,98,97,115,101,10,105,98,97,115,101,61,65,10,105,102,40,120,
|
|
60,48,41,123,10,110,61,49,10,120,61,45,120,10,125,10,115,61,115,99,97,108,101,
|
|
10,114,61,54,43,115,43,46,52,52,42,120,10,115,99,97,108,101,61,115,99,97,108,
|
|
101,40,120,41,43,49,10,119,104,105,108,101,40,120,62,49,41,123,10,100,43,61,
|
|
49,10,120,47,61,50,10,115,99,97,108,101,43,61,49,10,125,10,115,99,97,108,101,
|
|
61,114,10,114,61,120,43,49,10,112,61,120,10,102,61,118,61,49,10,102,111,114,
|
|
40,105,61,50,59,118,59,43,43,105,41,123,10,112,42,61,120,10,102,42,61,105,10,
|
|
118,61,112,47,102,10,114,43,61,118,10,125,10,119,104,105,108,101,40,100,45,
|
|
45,41,114,42,61,114,10,115,99,97,108,101,61,115,10,105,98,97,115,101,61,98,
|
|
10,105,102,40,110,41,114,101,116,117,114,110,40,49,47,114,41,10,114,101,116,
|
|
117,114,110,40,114,47,49,41,10,125,10,100,101,102,105,110,101,32,108,40,120,
|
|
41,123,10,97,117,116,111,32,98,44,115,44,114,44,112,44,97,44,113,44,105,44,
|
|
118,10,98,61,105,98,97,115,101,10,105,98,97,115,101,61,65,10,105,102,40,120,
|
|
60,61,48,41,123,10,114,61,40,49,45,49,48,94,115,99,97,108,101,41,47,49,10,105,
|
|
98,97,115,101,61,98,10,114,101,116,117,114,110,40,114,41,10,125,10,115,61,115,
|
|
99,97,108,101,10,115,99,97,108,101,43,61,54,10,112,61,50,10,119,104,105,108,
|
|
101,40,120,62,61,50,41,123,10,112,42,61,50,10,120,61,115,113,114,116,40,120,
|
|
41,10,125,10,119,104,105,108,101,40,120,60,61,46,53,41,123,10,112,42,61,50,
|
|
10,120,61,115,113,114,116,40,120,41,10,125,10,114,61,97,61,40,120,45,49,41,
|
|
47,40,120,43,49,41,10,113,61,97,42,97,10,118,61,49,10,102,111,114,40,105,61,
|
|
51,59,118,59,105,43,61,50,41,123,10,97,42,61,113,10,118,61,97,47,105,10,114,
|
|
43,61,118,10,125,10,114,42,61,112,10,115,99,97,108,101,61,115,10,105,98,97,
|
|
115,101,61,98,10,114,101,116,117,114,110,40,114,47,49,41,10,125,10,100,101,
|
|
102,105,110,101,32,115,40,120,41,123,10,97,117,116,111,32,98,44,115,44,114,
|
|
44,97,44,113,44,105,10,105,102,40,120,60,48,41,114,101,116,117,114,110,40,45,
|
|
115,40,45,120,41,41,10,98,61,105,98,97,115,101,10,105,98,97,115,101,61,65,10,
|
|
115,61,115,99,97,108,101,10,115,99,97,108,101,61,49,46,49,42,115,43,50,10,97,
|
|
61,97,40,49,41,10,115,99,97,108,101,61,48,10,113,61,40,120,47,97,43,50,41,47,
|
|
52,10,120,45,61,52,42,113,42,97,10,105,102,40,113,37,50,41,120,61,45,120,10,
|
|
115,99,97,108,101,61,115,43,50,10,114,61,97,61,120,10,113,61,45,120,42,120,
|
|
10,102,111,114,40,105,61,51,59,97,59,105,43,61,50,41,123,10,97,42,61,113,47,
|
|
40,105,42,40,105,45,49,41,41,10,114,43,61,97,10,125,10,115,99,97,108,101,61,
|
|
115,10,105,98,97,115,101,61,98,10,114,101,116,117,114,110,40,114,47,49,41,10,
|
|
125,10,100,101,102,105,110,101,32,99,40,120,41,123,10,97,117,116,111,32,98,
|
|
44,115,10,98,61,105,98,97,115,101,10,105,98,97,115,101,61,65,10,115,61,115,
|
|
99,97,108,101,10,115,99,97,108,101,42,61,49,46,50,10,120,61,115,40,50,42,97,
|
|
40,49,41,43,120,41,10,115,99,97,108,101,61,115,10,105,98,97,115,101,61,98,10,
|
|
114,101,116,117,114,110,40,120,47,49,41,10,125,10,100,101,102,105,110,101,32,
|
|
97,40,120,41,123,10,97,117,116,111,32,98,44,115,44,114,44,110,44,97,44,109,
|
|
44,116,44,102,44,105,44,117,10,98,61,105,98,97,115,101,10,105,98,97,115,101,
|
|
61,65,10,110,61,49,10,105,102,40,120,60,48,41,123,10,110,61,45,49,10,120,61,
|
|
45,120,10,125,10,105,102,40,115,99,97,108,101,60,54,53,41,123,10,105,102,40,
|
|
120,61,61,49,41,123,10,114,61,46,55,56,53,51,57,56,49,54,51,51,57,55,52,52,
|
|
56,51,48,57,54,49,53,54,54,48,56,52,53,56,49,57,56,55,53,55,50,49,48,52,57,
|
|
50,57,50,51,52,57,56,52,51,55,55,54,52,53,53,50,52,51,55,51,54,49,52,56,48,
|
|
47,110,10,105,98,97,115,101,61,98,10,114,101,116,117,114,110,40,114,41,10,125,
|
|
10,105,102,40,120,61,61,46,50,41,123,10,114,61,46,49,57,55,51,57,53,53,53,57,
|
|
56,52,57,56,56,48,55,53,56,51,55,48,48,52,57,55,54,53,49,57,52,55,57,48,50,
|
|
57,51,52,52,55,53,56,53,49,48,51,55,56,55,56,53,50,49,48,49,53,49,55,54,56,
|
|
56,57,52,48,50,47,110,10,105,98,97,115,101,61,98,10,114,101,116,117,114,110,
|
|
40,114,41,10,125,10,125,10,115,61,115,99,97,108,101,10,105,102,40,120,62,46,
|
|
50,41,123,10,115,99,97,108,101,43,61,53,10,97,61,97,40,46,50,41,10,125,10,115,
|
|
99,97,108,101,61,115,43,51,10,119,104,105,108,101,40,120,62,46,50,41,123,10,
|
|
109,43,61,49,10,120,61,40,120,45,46,50,41,47,40,49,43,46,50,42,120,41,10,125,
|
|
10,114,61,117,61,120,10,102,61,45,120,42,120,10,116,61,49,10,102,111,114,40,
|
|
105,61,51,59,116,59,105,43,61,50,41,123,10,117,42,61,102,10,116,61,117,47,105,
|
|
10,114,43,61,116,10,125,10,115,99,97,108,101,61,115,10,105,98,97,115,101,61,
|
|
98,10,114,101,116,117,114,110,40,40,109,42,97,43,114,41,47,110,41,10,125,10,
|
|
100,101,102,105,110,101,32,106,40,110,44,120,41,123,10,97,117,116,111,32,98,
|
|
44,115,44,111,44,97,44,105,44,118,44,102,10,98,61,105,98,97,115,101,10,105,
|
|
98,97,115,101,61,65,10,115,61,115,99,97,108,101,10,115,99,97,108,101,61,48,
|
|
10,110,47,61,49,10,105,102,40,110,60,48,41,123,10,110,61,45,110,10,111,61,110,
|
|
37,50,10,125,10,97,61,49,10,102,111,114,40,105,61,50,59,105,60,61,110,59,43,
|
|
43,105,41,97,42,61,105,10,115,99,97,108,101,61,49,46,53,42,115,10,97,61,40,
|
|
120,94,110,41,47,50,94,110,47,97,10,114,61,118,61,49,10,102,61,45,120,42,120,
|
|
47,52,10,115,99,97,108,101,43,61,108,101,110,103,116,104,40,97,41,45,115,99,
|
|
97,108,101,40,97,41,10,102,111,114,40,105,61,49,59,118,59,43,43,105,41,123,
|
|
10,118,61,118,42,102,47,105,47,40,110,43,105,41,10,114,43,61,118,10,125,10,
|
|
115,99,97,108,101,61,115,10,105,98,97,115,101,61,98,10,105,102,40,111,41,97,
|
|
61,45,97,10,114,101,116,117,114,110,40,97,42,114,47,49,41,10,125,10,0
|
|
};
|
|
|
|
static void bc_vec_grow(BcVec *v, unsigned long n) {
|
|
unsigned long old = v->cap;
|
|
|
|
while (v->cap < v->len + n) v->cap *= 2;
|
|
if (old != v->cap) v->v = xrealloc(v->v, v->size * v->cap);
|
|
}
|
|
|
|
void bc_vec_init(BcVec *v, size_t esize, BcVecFree dtor) {
|
|
v->size = esize;
|
|
v->cap = BC_VEC_START_CAP;
|
|
v->len = 0;
|
|
v->dtor = dtor;
|
|
v->v = xmalloc(esize * BC_VEC_START_CAP);
|
|
}
|
|
|
|
void bc_vec_expand(BcVec *v, size_t req) {
|
|
if (v->cap < req) {
|
|
v->v = xrealloc(v->v, v->size * req);
|
|
v->cap = req;
|
|
}
|
|
}
|
|
|
|
void bc_vec_npop(BcVec *v, size_t n) {
|
|
if (!v->dtor) v->len -= n;
|
|
else {
|
|
size_t len = v->len - n;
|
|
while (v->len > len) v->dtor(v->v + (v->size * --v->len));
|
|
}
|
|
}
|
|
|
|
void bc_vec_npush(BcVec *v, size_t n, void *data) {
|
|
bc_vec_grow(v, n);
|
|
memcpy(v->v + (v->size * v->len), data, v->size * n);
|
|
v->len += n;
|
|
}
|
|
|
|
void bc_vec_push(BcVec *v, void *data) {
|
|
bc_vec_npush(v, 1, data);
|
|
}
|
|
|
|
void bc_vec_pushByte(BcVec *v, uchar data) {
|
|
bc_vec_push(v, &data);
|
|
}
|
|
|
|
void bc_vec_pushIndex(BcVec *v, size_t idx) {
|
|
|
|
uchar amt, nums[sizeof(size_t)];
|
|
|
|
for (amt = 0; idx; ++amt) {
|
|
nums[amt] = (uchar) idx;
|
|
idx &= ((size_t) ~(UCHAR_MAX));
|
|
idx >>= sizeof(uchar) * CHAR_BIT;
|
|
}
|
|
|
|
bc_vec_push(v, &amt);
|
|
bc_vec_npush(v, amt, nums);
|
|
}
|
|
|
|
static void bc_vec_pushAt(BcVec *v, void *data, size_t idx) {
|
|
|
|
if (idx == v->len) bc_vec_push(v, data);
|
|
else {
|
|
|
|
char *ptr;
|
|
|
|
bc_vec_grow(v, 1);
|
|
|
|
ptr = v->v + v->size * idx;
|
|
|
|
memmove(ptr + v->size, ptr, v->size * (v->len++ - idx));
|
|
memmove(ptr, data, v->size);
|
|
}
|
|
}
|
|
|
|
void bc_vec_string(BcVec *v, size_t len, char *str) {
|
|
|
|
bc_vec_npop(v, v->len);
|
|
bc_vec_expand(v, len + 1);
|
|
memcpy(v->v, str, len);
|
|
v->len = len;
|
|
|
|
bc_vec_pushByte(v, '\0');
|
|
}
|
|
|
|
void bc_vec_concat(BcVec *v, char *str) {
|
|
unsigned long len;
|
|
|
|
if (!v->len) bc_vec_pushByte(v, '\0');
|
|
|
|
len = strlen(str);
|
|
bc_vec_grow(v, len);
|
|
strcpy(v->v+v->len-1, str);
|
|
v->len += len;
|
|
}
|
|
|
|
void bc_vec_empty(BcVec *v) {
|
|
bc_vec_npop(v, v->len);
|
|
bc_vec_pushByte(v, '\0');
|
|
}
|
|
|
|
void* bc_vec_item(BcVec *v, size_t idx) {
|
|
return v->v + v->size * idx;
|
|
}
|
|
|
|
void* bc_vec_item_rev(BcVec *v, size_t idx) {
|
|
return v->v + v->size * (v->len - idx - 1);
|
|
}
|
|
|
|
void bc_vec_free(void *vec) {
|
|
BcVec *v = (BcVec*) vec;
|
|
bc_vec_npop(v, v->len);
|
|
free(v->v);
|
|
}
|
|
|
|
static size_t bc_map_find(BcVec *v, struct str_len *ptr) {
|
|
|
|
size_t low = 0, high = v->len;
|
|
|
|
while (low < high) {
|
|
|
|
size_t mid = (low + high) / 2;
|
|
struct str_len *id = bc_vec_item(v, mid);
|
|
int result = bc_id_cmp(ptr, id);
|
|
|
|
if (!result) return mid;
|
|
else if (result < 0) high = mid;
|
|
else low = mid + 1;
|
|
}
|
|
|
|
return low;
|
|
}
|
|
|
|
int bc_map_insert(BcVec *v, struct str_len *ptr, size_t *i) {
|
|
|
|
*i = bc_map_find(v, ptr);
|
|
|
|
if (*i == v->len) bc_vec_push(v, ptr);
|
|
else if (!bc_id_cmp(ptr, bc_vec_item(v, *i))) return 0;
|
|
else bc_vec_pushAt(v, ptr, *i);
|
|
|
|
return 1;
|
|
}
|
|
|
|
size_t bc_map_index(BcVec *v, struct str_len *ptr) {
|
|
size_t i = bc_map_find(v, ptr);
|
|
if (i >= v->len) return SIZE_MAX;
|
|
return bc_id_cmp(ptr, bc_vec_item(v, i)) ? SIZE_MAX : i;
|
|
}
|
|
|
|
static int bc_read_binary(char *buf, size_t size) {
|
|
|
|
size_t i;
|
|
|
|
for (i = 0; i < size; ++i)
|
|
if ((buf[i]<' ' && !isspace(buf[i])) || buf[i]>'~') return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
BcStatus bc_read_chars(BcVec *vec, char *prompt) {
|
|
|
|
int i;
|
|
signed char c = 0;
|
|
|
|
bc_vec_npop(vec, vec->len);
|
|
|
|
if (BC_TTYIN && !FLAG(s)) {
|
|
fputs(prompt, stderr);
|
|
fflush(stderr);
|
|
}
|
|
|
|
while (!TT.sig && c != '\n') {
|
|
|
|
i = fgetc(stdin);
|
|
|
|
if (i == EOF) {
|
|
|
|
if (errno == EINTR) {
|
|
|
|
if (TT.sig == SIGTERM || TT.sig == SIGQUIT) return BC_STATUS_SIGNAL;
|
|
|
|
TT.sig = 0;
|
|
|
|
if (BC_TTYIN) {
|
|
fputs(bc_program_ready_msg, stderr);
|
|
if (!FLAG(s)) fputs(prompt, stderr);
|
|
fflush(stderr);
|
|
}
|
|
else return BC_STATUS_SIGNAL;
|
|
|
|
continue;
|
|
}
|
|
|
|
bc_vec_pushByte(vec, '\0');
|
|
return BC_STATUS_EOF;
|
|
}
|
|
|
|
c = (signed char) i;
|
|
bc_vec_push(vec, &c);
|
|
}
|
|
|
|
bc_vec_pushByte(vec, '\0');
|
|
|
|
return TT.sig ? BC_STATUS_SIGNAL : BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
BcStatus bc_read_line(BcVec *vec, char *prompt) {
|
|
|
|
BcStatus s;
|
|
|
|
// We are about to output to stderr, so flush stdout to
|
|
// make sure that we don't get the outputs mixed up.
|
|
fflush(stdout);
|
|
|
|
s = bc_read_chars(vec, prompt);
|
|
if (s && s != BC_STATUS_EOF) return s;
|
|
if (bc_read_binary(vec->v, vec->len - 1))
|
|
return bc_vm_verr(BC_ERROR_VM_BIN_FILE, bc_program_stdin_name);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
BcStatus bc_read_file(char *path, char **buf) {
|
|
|
|
BcError e = BC_ERROR_VM_IO_ERR;
|
|
FILE *f;
|
|
size_t size, read;
|
|
long res;
|
|
struct stat pstat;
|
|
|
|
f = fopen(path, "r");
|
|
if (!f) return bc_vm_verr(BC_ERROR_EXEC_FILE_ERR, path);
|
|
if (fstat(fileno(f), &pstat) == -1) goto malloc_err;
|
|
|
|
if (S_ISDIR(pstat.st_mode)) {
|
|
e = BC_ERROR_VM_PATH_DIR;
|
|
goto malloc_err;
|
|
}
|
|
|
|
if (fseek(f, 0, SEEK_END) == -1) goto malloc_err;
|
|
res = ftell(f);
|
|
if (res < 0) goto malloc_err;
|
|
if (fseek(f, 0, SEEK_SET) == -1) goto malloc_err;
|
|
|
|
size = (size_t) res;
|
|
*buf = xmalloc(size + 1);
|
|
|
|
read = fread(*buf, 1, size, f);
|
|
if (read != size) goto read_err;
|
|
|
|
(*buf)[size] = '\0';
|
|
|
|
if (bc_read_binary(*buf, size)) {
|
|
e = BC_ERROR_VM_BIN_FILE;
|
|
goto read_err;
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
|
|
read_err:
|
|
free(*buf);
|
|
malloc_err:
|
|
fclose(f);
|
|
return bc_vm_verr(e, path);
|
|
}
|
|
|
|
static void bc_num_setToZero(BcNum *n, size_t scale) {
|
|
n->len = 0;
|
|
n->neg = 0;
|
|
n->rdx = scale;
|
|
}
|
|
|
|
void bc_num_one(BcNum *n) {
|
|
bc_num_setToZero(n, 0);
|
|
n->len = 1;
|
|
n->num[0] = 1;
|
|
}
|
|
|
|
void bc_num_ten(BcNum *n) {
|
|
bc_num_setToZero(n, 0);
|
|
n->len = 2;
|
|
n->num[0] = 0;
|
|
n->num[1] = 1;
|
|
}
|
|
|
|
static size_t bc_num_log10(size_t i) {
|
|
size_t len;
|
|
for (len = 1; i; i /= 10, ++len);
|
|
return len;
|
|
}
|
|
|
|
static BcStatus bc_num_subArrays(signed char *a, signed char *b, size_t len)
|
|
{
|
|
size_t i, j;
|
|
for (i = 0; !TT.sig && i < len; ++i) {
|
|
for (a[i] -= b[i], j = 0; !TT.sig && a[i + j] < 0;) {
|
|
a[i + j++] += 10;
|
|
a[i + j] -= 1;
|
|
}
|
|
}
|
|
return TT.sig ? BC_STATUS_SIGNAL : BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static ssize_t bc_num_compare(signed char *a, signed char *b, size_t len)
|
|
{
|
|
size_t i;
|
|
int c = 0;
|
|
|
|
for (i = len - 1; !TT.sig && i < len && !(c = a[i] - b[i]); --i);
|
|
return BC_NUM_NEG(i + 1, c < 0);
|
|
}
|
|
|
|
ssize_t bc_num_cmp(BcNum *a, BcNum *b) {
|
|
|
|
size_t i, min, a_int, b_int, diff;
|
|
signed char *max_num, *min_num;
|
|
int a_max, neg = 0;
|
|
ssize_t cmp;
|
|
|
|
if (a == b) return 0;
|
|
if (!a->len) return BC_NUM_NEG(b->len != 0, !b->neg);
|
|
if (!b->len) return BC_NUM_CMP_ZERO(a);
|
|
if (a->neg) {
|
|
if (b->neg) neg = 1;
|
|
else return -1;
|
|
} else if (b->neg) return 1;
|
|
|
|
a_int = BC_NUM_INT(a);
|
|
b_int = BC_NUM_INT(b);
|
|
a_int -= b_int;
|
|
a_max = (a->rdx > b->rdx);
|
|
|
|
if (a_int) return neg ? -((ssize_t) a_int) : (ssize_t) a_int;
|
|
|
|
if (a_max) {
|
|
min = b->rdx;
|
|
diff = a->rdx - b->rdx;
|
|
max_num = a->num + diff;
|
|
min_num = b->num;
|
|
} else {
|
|
min = a->rdx;
|
|
diff = b->rdx - a->rdx;
|
|
max_num = b->num + diff;
|
|
min_num = a->num;
|
|
}
|
|
|
|
cmp = bc_num_compare(max_num, min_num, b_int + min);
|
|
if (cmp) return BC_NUM_NEG(cmp, (!a_max) != neg);
|
|
|
|
for (max_num -= diff, i = diff - 1; !TT.sig && i < diff; --i) {
|
|
if (max_num[i]) return BC_NUM_NEG(1, (!a_max) != neg);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void bc_num_clean(BcNum *n) {
|
|
while (n->len && !n->num[n->len - 1]) --n->len;
|
|
if (!n->len) n->neg = 0;
|
|
else if (n->len < n->rdx) n->len = n->rdx;
|
|
}
|
|
|
|
void bc_num_truncate(BcNum *n, size_t places) {
|
|
|
|
if (!places) return;
|
|
|
|
n->rdx -= places;
|
|
|
|
if (n->len) {
|
|
n->len -= places;
|
|
memmove(n->num, n->num + places, n->len);
|
|
bc_num_clean(n);
|
|
}
|
|
}
|
|
|
|
static void bc_num_extend(BcNum *n, size_t places) {
|
|
|
|
size_t len = n->len + places;
|
|
|
|
if (!places) return;
|
|
|
|
if (n->cap < len) bc_num_expand(n, len);
|
|
|
|
memmove(n->num + places, n->num, n->len);
|
|
memset(n->num, 0, places);
|
|
|
|
if (n->len) n->len += places;
|
|
|
|
n->rdx += places;
|
|
}
|
|
|
|
static void bc_num_retireMul(BcNum *n, size_t scale, int neg1, int neg2) {
|
|
|
|
if (n->rdx < scale) bc_num_extend(n, scale - n->rdx);
|
|
else bc_num_truncate(n, n->rdx - scale);
|
|
|
|
bc_num_clean(n);
|
|
if (n->len) n->neg = (!neg1 != !neg2);
|
|
}
|
|
|
|
static void bc_num_split(BcNum *n, size_t idx, BcNum *a, BcNum *b) {
|
|
|
|
if (idx < n->len) {
|
|
|
|
b->len = n->len - idx;
|
|
a->len = idx;
|
|
a->rdx = b->rdx = 0;
|
|
|
|
memcpy(b->num, n->num + idx, b->len);
|
|
memcpy(a->num, n->num, idx);
|
|
|
|
bc_num_clean(b);
|
|
}
|
|
else bc_num_copy(a, n);
|
|
|
|
bc_num_clean(a);
|
|
}
|
|
|
|
static BcStatus bc_num_shift(BcNum *n, size_t places) {
|
|
|
|
if (!places || !n->len) return BC_STATUS_SUCCESS;
|
|
if (places + n->len > BC_MAX_NUM)
|
|
return bc_vm_verr(BC_ERROR_MATH_OVERFLOW, "shifted left too far");
|
|
|
|
if (n->rdx >= places) n->rdx -= places;
|
|
else {
|
|
bc_num_extend(n, places - n->rdx);
|
|
n->rdx = 0;
|
|
}
|
|
|
|
bc_num_clean(n);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_num_inv(BcNum *a, BcNum *b, size_t scale) {
|
|
|
|
BcNum one;
|
|
signed char num[2];
|
|
|
|
one.cap = 2;
|
|
one.num = num;
|
|
bc_num_one(&one);
|
|
|
|
return bc_num_div(&one, a, b, scale);
|
|
}
|
|
|
|
static unsigned int bc_num_addDigit(signed char *num, unsigned int d, unsigned int c)
|
|
{
|
|
d += c;
|
|
*num = d % 10;
|
|
return d / 10;
|
|
}
|
|
|
|
static BcStatus bc_num_a(BcNum *a, BcNum *b, BcNum *c, size_t sub) {
|
|
|
|
signed char *ptr, *ptr_a, *ptr_b, *ptr_c;
|
|
size_t i, max, min_rdx, min_int, diff, a_int, b_int;
|
|
unsigned int carry;
|
|
|
|
// Because this function doesn't need to use scale (per the bc spec),
|
|
// I am hijacking it to say whether it's doing an add or a subtract.
|
|
|
|
if (!a->len) {
|
|
bc_num_copy(c, b);
|
|
if (sub && c->len) c->neg = !c->neg;
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
if (!b->len) {
|
|
bc_num_copy(c, a);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
c->neg = a->neg;
|
|
c->rdx = maxof(a->rdx, b->rdx);
|
|
min_rdx = minof(a->rdx, b->rdx);
|
|
|
|
if (a->rdx > b->rdx) {
|
|
diff = a->rdx - b->rdx;
|
|
ptr = a->num;
|
|
ptr_a = a->num + diff;
|
|
ptr_b = b->num;
|
|
}
|
|
else {
|
|
diff = b->rdx - a->rdx;
|
|
ptr = b->num;
|
|
ptr_a = a->num;
|
|
ptr_b = b->num + diff;
|
|
}
|
|
|
|
for (ptr_c = c->num, i = 0; i < diff; ++i) ptr_c[i] = ptr[i];
|
|
|
|
c->len = diff;
|
|
ptr_c += diff;
|
|
a_int = BC_NUM_INT(a);
|
|
b_int = BC_NUM_INT(b);
|
|
|
|
if (a_int > b_int) {
|
|
min_int = b_int;
|
|
max = a_int;
|
|
ptr = ptr_a;
|
|
}
|
|
else {
|
|
min_int = a_int;
|
|
max = b_int;
|
|
ptr = ptr_b;
|
|
}
|
|
|
|
for (carry = 0, i = 0; !TT.sig && i < min_rdx + min_int; ++i) {
|
|
unsigned int in = (unsigned int) (ptr_a[i] + ptr_b[i]);
|
|
carry = bc_num_addDigit(ptr_c + i, in, carry);
|
|
}
|
|
|
|
for (; !TT.sig && i < max + min_rdx; ++i)
|
|
carry = bc_num_addDigit(ptr_c + i, (unsigned int) ptr[i], carry);
|
|
|
|
c->len += i;
|
|
|
|
if (carry) c->num[c->len++] = carry;
|
|
|
|
return TT.sig ? BC_STATUS_SIGNAL : BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_num_s(BcNum *a, BcNum *b, BcNum *c, size_t sub) {
|
|
|
|
BcStatus s;
|
|
ssize_t cmp;
|
|
BcNum *minuend, *subtrahend;
|
|
size_t start;
|
|
int aneg, bneg, neg;
|
|
|
|
// Because this function doesn't need to use scale (per the bc spec),
|
|
// I am hijacking it to say whether it's doing an add or a subtract.
|
|
|
|
if (!a->len) {
|
|
bc_num_copy(c, b);
|
|
if (sub && c->len) c->neg = !c->neg;
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
if (!b->len) {
|
|
bc_num_copy(c, a);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
aneg = a->neg;
|
|
bneg = b->neg;
|
|
a->neg = b->neg = 0;
|
|
|
|
cmp = bc_num_cmp(a, b);
|
|
|
|
a->neg = aneg;
|
|
b->neg = bneg;
|
|
|
|
if (!cmp) {
|
|
bc_num_setToZero(c, maxof(a->rdx, b->rdx));
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
if (cmp > 0) {
|
|
neg = a->neg;
|
|
minuend = a;
|
|
subtrahend = b;
|
|
}
|
|
else {
|
|
neg = b->neg;
|
|
if (sub) neg = !neg;
|
|
minuend = b;
|
|
subtrahend = a;
|
|
}
|
|
|
|
bc_num_copy(c, minuend);
|
|
c->neg = neg;
|
|
|
|
if (c->rdx < subtrahend->rdx) {
|
|
bc_num_extend(c, subtrahend->rdx - c->rdx);
|
|
start = 0;
|
|
}
|
|
else start = c->rdx - subtrahend->rdx;
|
|
|
|
s = bc_num_subArrays(c->num + start, subtrahend->num, subtrahend->len);
|
|
|
|
bc_num_clean(c);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_k(BcNum *a, BcNum *b, BcNum *c) {
|
|
|
|
BcStatus s;
|
|
size_t max = maxof(a->len, b->len), max2 = (max + 1) / 2;
|
|
BcNum l1, h1, l2, h2, m2, m1, z0, z1, z2, temp;
|
|
int aone = BC_NUM_ONE(a);
|
|
|
|
// This is here because the function is recursive.
|
|
if (TT.sig) return BC_STATUS_SIGNAL;
|
|
if (!a->len || !b->len) {
|
|
bc_num_setToZero(c, 0);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
if (aone || BC_NUM_ONE(b)) {
|
|
bc_num_copy(c, aone ? b : a);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
// check karatsuba length
|
|
if (a->len + b->len < 32 || a->len < 32 || b->len < 32)
|
|
{
|
|
size_t i, j, len;
|
|
unsigned int carry;
|
|
signed char *ptr_c;
|
|
|
|
bc_num_expand(c, a->len + b->len + 1);
|
|
|
|
ptr_c = c->num;
|
|
memset(ptr_c, 0, c->cap);
|
|
c->len = len = 0;
|
|
|
|
for (i = 0; !TT.sig && i < b->len; ++i) {
|
|
|
|
signed char *ptr = ptr_c + i;
|
|
|
|
carry = 0;
|
|
|
|
for (j = 0; !TT.sig && j < a->len; ++j) {
|
|
unsigned int in = (uchar) ptr[j];
|
|
in += ((unsigned int) a->num[j]) * ((unsigned int) b->num[i]);
|
|
carry = bc_num_addDigit(ptr + j, in, carry);
|
|
}
|
|
// todo: is this typecast useless?
|
|
ptr[j] += (signed) carry;
|
|
len = maxof(len, i + j + (carry != 0));
|
|
}
|
|
|
|
c->len = len;
|
|
|
|
return TT.sig ? BC_STATUS_SIGNAL : BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
bc_num_init(&l1, max);
|
|
bc_num_init(&h1, max);
|
|
bc_num_init(&l2, max);
|
|
bc_num_init(&h2, max);
|
|
bc_num_init(&m1, max);
|
|
bc_num_init(&m2, max);
|
|
bc_num_init(&z0, max);
|
|
bc_num_init(&z1, max);
|
|
bc_num_init(&z2, max);
|
|
bc_num_init(&temp, max + max);
|
|
|
|
bc_num_split(a, max2, &l1, &h1);
|
|
bc_num_split(b, max2, &l2, &h2);
|
|
|
|
s = bc_num_add(&h1, &l1, &m1, 0);
|
|
if (s) goto err;
|
|
s = bc_num_add(&h2, &l2, &m2, 0);
|
|
if (s) goto err;
|
|
|
|
s = bc_num_k(&h1, &h2, &z0);
|
|
if (s) goto err;
|
|
s = bc_num_k(&m1, &m2, &z1);
|
|
if (s) goto err;
|
|
s = bc_num_k(&l1, &l2, &z2);
|
|
if (s) goto err;
|
|
|
|
s = bc_num_sub(&z1, &z0, &temp, 0);
|
|
if (s) goto err;
|
|
s = bc_num_sub(&temp, &z2, &z1, 0);
|
|
if (s) goto err;
|
|
|
|
s = bc_num_shift(&z0, max2 * 2);
|
|
if (s) goto err;
|
|
s = bc_num_shift(&z1, max2);
|
|
if (s) goto err;
|
|
s = bc_num_add(&z0, &z1, &temp, 0);
|
|
if (s) goto err;
|
|
s = bc_num_add(&temp, &z2, c, 0);
|
|
|
|
err:
|
|
bc_num_free(&temp);
|
|
bc_num_free(&z2);
|
|
bc_num_free(&z1);
|
|
bc_num_free(&z0);
|
|
bc_num_free(&m2);
|
|
bc_num_free(&m1);
|
|
bc_num_free(&h2);
|
|
bc_num_free(&l2);
|
|
bc_num_free(&h1);
|
|
bc_num_free(&l1);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_m(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
|
|
BcStatus s;
|
|
BcNum cpa, cpb;
|
|
size_t maxrdx = maxof(a->rdx, b->rdx);
|
|
|
|
scale = maxof(scale, a->rdx);
|
|
scale = maxof(scale, b->rdx);
|
|
scale = minof(a->rdx + b->rdx, scale);
|
|
maxrdx = maxof(maxrdx, scale);
|
|
|
|
bc_num_createCopy(&cpa, a);
|
|
bc_num_createCopy(&cpb, b);
|
|
|
|
cpa.neg = cpb.neg = 0;
|
|
|
|
s = bc_num_shift(&cpa, maxrdx);
|
|
if (s) goto err;
|
|
s = bc_num_shift(&cpb, maxrdx);
|
|
if (s) goto err;
|
|
s = bc_num_k(&cpa, &cpb, c);
|
|
if (s) goto err;
|
|
|
|
maxrdx += scale;
|
|
bc_num_expand(c, c->len + maxrdx);
|
|
|
|
if (c->len < maxrdx) {
|
|
memset(c->num + c->len, 0, c->cap - c->len);
|
|
c->len += maxrdx;
|
|
}
|
|
|
|
c->rdx = maxrdx;
|
|
bc_num_retireMul(c, scale, a->neg, b->neg);
|
|
|
|
err:
|
|
bc_num_free(&cpb);
|
|
bc_num_free(&cpa);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_d(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
signed char *n, *p, q;
|
|
size_t len, end, i;
|
|
BcNum cp;
|
|
int zero = 1;
|
|
|
|
if (!b->len) return bc_vm_err(BC_ERROR_MATH_DIVIDE_BY_ZERO);
|
|
if (!a->len) {
|
|
bc_num_setToZero(c, scale);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
if (BC_NUM_ONE(b)) {
|
|
bc_num_copy(c, a);
|
|
bc_num_retireMul(c, scale, a->neg, b->neg);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
bc_num_init(&cp, bc_num_mulReq(a, b, scale));
|
|
bc_num_copy(&cp, a);
|
|
len = b->len;
|
|
|
|
if (len > cp.len) {
|
|
bc_num_expand(&cp, len + 2);
|
|
bc_num_extend(&cp, len - cp.len);
|
|
}
|
|
|
|
if (b->rdx > cp.rdx) bc_num_extend(&cp, b->rdx - cp.rdx);
|
|
cp.rdx -= b->rdx;
|
|
if (scale > cp.rdx) bc_num_extend(&cp, scale - cp.rdx);
|
|
|
|
if (b->rdx == b->len) {
|
|
for (i = 0; zero && i < len; ++i) zero = !b->num[len - i - 1];
|
|
len -= i - 1;
|
|
}
|
|
|
|
if (cp.cap == cp.len) bc_num_expand(&cp, cp.len + 1);
|
|
|
|
// We want an extra zero in front to make things simpler.
|
|
cp.num[cp.len++] = 0;
|
|
end = cp.len - len;
|
|
|
|
bc_num_expand(c, cp.len);
|
|
|
|
memset(c->num + end, 0, c->cap - end);
|
|
c->rdx = cp.rdx;
|
|
c->len = cp.len;
|
|
p = b->num;
|
|
|
|
for (i = end - 1; !TT.sig && !s && i < end; --i) {
|
|
n = cp.num + i;
|
|
for (q = 0; !s && (n[len] || bc_num_compare(n, p, len) >= 0); ++q)
|
|
s = bc_num_subArrays(n, p, len);
|
|
c->num[i] = q;
|
|
}
|
|
|
|
if (!s) bc_num_retireMul(c, scale, a->neg, b->neg);
|
|
bc_num_free(&cp);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_r(BcNum *a, BcNum *b, BcNum *c, BcNum *d, size_t scale,
|
|
size_t ts)
|
|
{
|
|
BcStatus s;
|
|
BcNum temp;
|
|
int neg;
|
|
|
|
if (!b->len) return bc_vm_err(BC_ERROR_MATH_DIVIDE_BY_ZERO);
|
|
if (!a->len) {
|
|
bc_num_setToZero(c, ts);
|
|
bc_num_setToZero(d, ts);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
bc_num_init(&temp, d->cap);
|
|
bc_num_d(a, b, c, scale);
|
|
|
|
if (scale) scale = ts;
|
|
|
|
s = bc_num_m(c, b, &temp, scale);
|
|
if (s) goto err;
|
|
s = bc_num_sub(a, &temp, d, scale);
|
|
if (s) goto err;
|
|
|
|
if (ts > d->rdx && d->len) bc_num_extend(d, ts - d->rdx);
|
|
|
|
neg = d->neg;
|
|
bc_num_retireMul(d, ts, a->neg, b->neg);
|
|
d->neg = neg;
|
|
|
|
err:
|
|
bc_num_free(&temp);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_rem(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
|
|
BcStatus s;
|
|
BcNum c1;
|
|
size_t ts = maxof(scale + b->rdx, a->rdx), len = bc_num_mulReq(a, b, ts);
|
|
|
|
bc_num_init(&c1, len);
|
|
s = bc_num_r(a, b, &c1, c, scale, ts);
|
|
bc_num_free(&c1);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_p(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcNum copy;
|
|
unsigned long pow = 0;
|
|
size_t i, powrdx, resrdx;
|
|
int neg, zero;
|
|
|
|
if (b->rdx) return bc_vm_err(BC_ERROR_MATH_NON_INTEGER);
|
|
|
|
if (!b->len) {
|
|
bc_num_one(c);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
if (!a->len) {
|
|
if (b->neg) return bc_vm_err(BC_ERROR_MATH_DIVIDE_BY_ZERO);
|
|
bc_num_setToZero(c, scale);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
if (BC_NUM_ONE(b)) {
|
|
if (!b->neg) bc_num_copy(c, a);
|
|
else s = bc_num_inv(a, c, scale);
|
|
return s;
|
|
}
|
|
|
|
neg = b->neg;
|
|
b->neg = 0;
|
|
s = bc_num_ulong(b, &pow);
|
|
b->neg = neg;
|
|
if (s) return s;
|
|
|
|
bc_num_createCopy(©, a);
|
|
|
|
if (!neg) scale = minof(a->rdx * pow, maxof(scale, a->rdx));
|
|
|
|
for (powrdx = a->rdx; !TT.sig && !(pow & 1); pow >>= 1) {
|
|
powrdx <<= 1;
|
|
s = bc_num_mul(©, ©, ©, powrdx);
|
|
if (s) goto err;
|
|
}
|
|
|
|
if (TT.sig) {
|
|
s = BC_STATUS_SIGNAL;
|
|
goto err;
|
|
}
|
|
|
|
bc_num_copy(c, ©);
|
|
resrdx = powrdx;
|
|
|
|
while (!TT.sig && (pow >>= 1)) {
|
|
|
|
powrdx <<= 1;
|
|
s = bc_num_mul(©, ©, ©, powrdx);
|
|
if (s) goto err;
|
|
|
|
if (pow & 1) {
|
|
resrdx += powrdx;
|
|
s = bc_num_mul(c, ©, c, resrdx);
|
|
if (s) goto err;
|
|
}
|
|
}
|
|
|
|
if (neg) {
|
|
s = bc_num_inv(c, c, scale);
|
|
if (s) goto err;
|
|
}
|
|
|
|
if (TT.sig) {
|
|
s = BC_STATUS_SIGNAL;
|
|
goto err;
|
|
}
|
|
|
|
if (c->rdx > scale) bc_num_truncate(c, c->rdx - scale);
|
|
|
|
// We can't use bc_num_clean() here.
|
|
for (zero = 1, i = 0; zero && i < c->len; ++i) zero = !c->num[i];
|
|
if (zero) bc_num_setToZero(c, scale);
|
|
|
|
err:
|
|
bc_num_free(©);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
|
|
BcNumBinaryOp op, size_t req)
|
|
{
|
|
BcStatus s;
|
|
BcNum num2, *ptr_a, *ptr_b;
|
|
int init = 0;
|
|
|
|
if (c == a) {
|
|
ptr_a = &num2;
|
|
memcpy(ptr_a, c, sizeof(BcNum));
|
|
init = 1;
|
|
}
|
|
else ptr_a = a;
|
|
|
|
if (c == b) {
|
|
ptr_b = &num2;
|
|
if (c != a) {
|
|
memcpy(ptr_b, c, sizeof(BcNum));
|
|
init = 1;
|
|
}
|
|
}
|
|
else ptr_b = b;
|
|
|
|
if (init) bc_num_init(c, req);
|
|
else bc_num_expand(c, req);
|
|
|
|
s = op(ptr_a, ptr_b, c, scale);
|
|
|
|
if (init) bc_num_free(&num2);
|
|
|
|
return s;
|
|
}
|
|
|
|
static unsigned long bc_num_parseChar(char c, size_t base_t) {
|
|
|
|
if (isupper(c)) {
|
|
c += 10 - 'A';
|
|
if (c >= base_t) c = base_t - 1;
|
|
} else c -= '0';
|
|
|
|
return c;
|
|
}
|
|
|
|
static BcStatus bc_num_parseBase(BcNum *n, char *val,
|
|
BcNum *base, size_t base_t)
|
|
{
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcNum temp, mult, result;
|
|
signed char c = 0;
|
|
int zero = 1;
|
|
unsigned long v;
|
|
size_t i, digits, len = strlen(val);
|
|
|
|
for (i = 0; zero && i < len; ++i) zero = (val[i] == '.' || val[i] == '0');
|
|
if (zero) return BC_STATUS_SUCCESS;
|
|
|
|
bc_num_init(&temp, BC_NUM_LONG_LOG10);
|
|
bc_num_init(&mult, BC_NUM_LONG_LOG10);
|
|
|
|
for (i = 0; i < len && (c = val[i]) && c != '.'; ++i) {
|
|
|
|
v = bc_num_parseChar(c, base_t);
|
|
|
|
s = bc_num_mul(n, base, &mult, 0);
|
|
if (s) goto int_err;
|
|
bc_num_ulong2num(&temp, v);
|
|
s = bc_num_add(&mult, &temp, n, 0);
|
|
if (s) goto int_err;
|
|
}
|
|
|
|
if (i == len && !(c = val[i])) goto int_err;
|
|
|
|
bc_num_init(&result, base->len);
|
|
bc_num_one(&mult);
|
|
|
|
for (i += 1, digits = 0; i < len && (c = val[i]); ++i, ++digits) {
|
|
|
|
v = bc_num_parseChar(c, base_t);
|
|
|
|
s = bc_num_mul(&result, base, &result, 0);
|
|
if (s) goto err;
|
|
bc_num_ulong2num(&temp, v);
|
|
s = bc_num_add(&result, &temp, &result, 0);
|
|
if (s) goto err;
|
|
s = bc_num_mul(&mult, base, &mult, 0);
|
|
if (s) goto err;
|
|
}
|
|
|
|
s = bc_num_div(&result, &mult, &result, digits);
|
|
if (s) goto err;
|
|
s = bc_num_add(n, &result, n, digits);
|
|
if (s) goto err;
|
|
|
|
if (n->len) {
|
|
if (n->rdx < digits) bc_num_extend(n, digits - n->rdx);
|
|
}
|
|
else bc_num_setToZero(n, 0);
|
|
|
|
|
|
err:
|
|
bc_num_free(&result);
|
|
int_err:
|
|
bc_num_free(&mult);
|
|
bc_num_free(&temp);
|
|
return s;
|
|
}
|
|
|
|
static void bc_num_printNewline() {
|
|
if (TT.nchars >= TT.line_len - 1) {
|
|
putchar('\\');
|
|
putchar('\n');
|
|
TT.nchars = 0;
|
|
}
|
|
}
|
|
|
|
static void bc_num_printDigits(size_t n, size_t len, int rdx) {
|
|
|
|
size_t exp, pow;
|
|
|
|
bc_num_printNewline();
|
|
putchar(rdx ? '.' : ' ');
|
|
++TT.nchars;
|
|
|
|
bc_num_printNewline();
|
|
for (exp = 0, pow = 1; exp < len - 1; ++exp, pow *= 10);
|
|
|
|
for (exp = 0; exp < len; pow /= 10, ++TT.nchars, ++exp) {
|
|
size_t dig;
|
|
bc_num_printNewline();
|
|
dig = n / pow;
|
|
n -= dig * pow;
|
|
putchar(((uchar) dig) + '0');
|
|
}
|
|
}
|
|
|
|
static void bc_num_printHex(size_t n, size_t len, int rdx) {
|
|
|
|
if (rdx) {
|
|
bc_num_printNewline();
|
|
putchar('.');
|
|
TT.nchars += 1;
|
|
}
|
|
|
|
bc_num_printNewline();
|
|
putchar(bc_num_hex_digits[n]);
|
|
TT.nchars += len;
|
|
}
|
|
|
|
static void bc_num_printDecimal(BcNum *n) {
|
|
|
|
size_t i, rdx = n->rdx - 1;
|
|
|
|
if (n->neg) putchar('-');
|
|
TT.nchars += n->neg;
|
|
|
|
for (i = n->len - 1; i < n->len; --i)
|
|
bc_num_printHex((size_t) n->num[i], 1, i == rdx);
|
|
}
|
|
|
|
static BcStatus bc_num_printNum(BcNum *n, BcNum *base,
|
|
size_t len, BcNumDigitOp print)
|
|
{
|
|
BcStatus s;
|
|
BcVec stack;
|
|
BcNum intp, fracp, digit, frac_len;
|
|
unsigned long dig, *ptr;
|
|
size_t i;
|
|
int radix;
|
|
|
|
if (!n->len) {
|
|
print(0, len, 0);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
bc_vec_init(&stack, sizeof(unsigned long), NULL);
|
|
bc_num_init(&fracp, n->rdx);
|
|
bc_num_init(&digit, len);
|
|
bc_num_init(&frac_len, BC_NUM_INT(n));
|
|
bc_num_one(&frac_len);
|
|
bc_num_createCopy(&intp, n);
|
|
|
|
bc_num_truncate(&intp, intp.rdx);
|
|
s = bc_num_sub(n, &intp, &fracp, 0);
|
|
if (s) goto err;
|
|
|
|
while (intp.len) {
|
|
s = bc_num_divmod(&intp, base, &intp, &digit, 0);
|
|
if (s) goto err;
|
|
s = bc_num_ulong(&digit, &dig);
|
|
if (s) goto err;
|
|
bc_vec_push(&stack, &dig);
|
|
}
|
|
|
|
for (i = 0; i < stack.len; ++i) {
|
|
ptr = bc_vec_item_rev(&stack, i);
|
|
print(*ptr, len, 0);
|
|
}
|
|
|
|
if (!n->rdx) goto err;
|
|
|
|
for (radix = 1; frac_len.len <= n->rdx; radix = 0) {
|
|
s = bc_num_mul(&fracp, base, &fracp, n->rdx);
|
|
if (s) goto err;
|
|
s = bc_num_ulong(&fracp, &dig);
|
|
if (s) goto err;
|
|
bc_num_ulong2num(&intp, dig);
|
|
s = bc_num_sub(&fracp, &intp, &fracp, 0);
|
|
if (s) goto err;
|
|
print(dig, len, radix);
|
|
s = bc_num_mul(&frac_len, base, &frac_len, 0);
|
|
if (s) goto err;
|
|
}
|
|
|
|
err:
|
|
bc_num_free(&frac_len);
|
|
bc_num_free(&digit);
|
|
bc_num_free(&fracp);
|
|
bc_num_free(&intp);
|
|
bc_vec_free(&stack);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_num_printBase(BcNum *n, BcNum *base, size_t base_t) {
|
|
|
|
BcStatus s;
|
|
size_t width;
|
|
BcNumDigitOp print;
|
|
int neg = n->neg;
|
|
|
|
if (neg) putchar('-');
|
|
TT.nchars += neg;
|
|
|
|
n->neg = 0;
|
|
|
|
if (base_t <= 16) {
|
|
width = 1;
|
|
print = bc_num_printHex;
|
|
} else {
|
|
width = bc_num_log10(base_t - 1) - 1;
|
|
print = bc_num_printDigits;
|
|
}
|
|
|
|
s = bc_num_printNum(n, base, width, print);
|
|
n->neg = neg;
|
|
|
|
return s;
|
|
}
|
|
|
|
void bc_num_setup(BcNum *n, signed char *num, size_t cap) {
|
|
n->num = num;
|
|
n->cap = cap;
|
|
n->rdx = n->len = 0;
|
|
n->neg = 0;
|
|
}
|
|
|
|
void bc_num_init(BcNum *n, size_t req) {
|
|
req = req >= BC_NUM_DEF_SIZE ? req : BC_NUM_DEF_SIZE;
|
|
bc_num_setup(n, xmalloc(req), req);
|
|
}
|
|
|
|
void bc_num_expand(BcNum *n, size_t req) {
|
|
req = req >= BC_NUM_DEF_SIZE ? req : BC_NUM_DEF_SIZE;
|
|
if (req > n->cap) {
|
|
n->num = xrealloc(n->num, req);
|
|
n->cap = req;
|
|
}
|
|
}
|
|
|
|
void bc_num_free(void *num) {
|
|
free(((BcNum*) num)->num);
|
|
}
|
|
|
|
void bc_num_copy(BcNum *d, BcNum *s) {
|
|
if (d == s) return;
|
|
bc_num_expand(d, s->len);
|
|
d->len = s->len;
|
|
d->neg = s->neg;
|
|
d->rdx = s->rdx;
|
|
memcpy(d->num, s->num, d->len);
|
|
}
|
|
|
|
void bc_num_createCopy(BcNum *d, BcNum *s) {
|
|
bc_num_init(d, s->len);
|
|
bc_num_copy(d, s);
|
|
}
|
|
|
|
void bc_num_createFromUlong(BcNum *n, unsigned long val) {
|
|
bc_num_init(n, BC_NUM_LONG_LOG10);
|
|
bc_num_ulong2num(n, val);
|
|
}
|
|
|
|
BcStatus bc_num_parse(BcNum *n, char *val,
|
|
BcNum *base, size_t base_t, int letter)
|
|
{
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
|
|
if (letter) bc_num_ulong2num(n, bc_num_parseChar(val[0], 'Z'+11));
|
|
else if (base_t == 10) {
|
|
size_t len, i;
|
|
char *ptr;
|
|
int zero = 1;
|
|
|
|
while (*val == '0') val++;
|
|
|
|
len = strlen(val);
|
|
if (len) {
|
|
for (i = 0; zero && i < len; ++i) zero = (val[i] == '0') || val[i] == '.';
|
|
bc_num_expand(n, len);
|
|
}
|
|
ptr = strchr(val, '.');
|
|
n->rdx = ptr ? (val + len) - (ptr + 1) : 0;
|
|
|
|
if (!zero) {
|
|
for (i = len - 1; i < len; ++n->len, --i) {
|
|
|
|
char c = val[i];
|
|
|
|
if (c == '.') n->len -= 1;
|
|
else {
|
|
if (isupper(c)) c = '9';
|
|
n->num[n->len] = c - '0';
|
|
}
|
|
}
|
|
}
|
|
} else s = bc_num_parseBase(n, val, base, base_t);
|
|
|
|
return s;
|
|
}
|
|
|
|
BcStatus bc_num_ulong(BcNum *n, unsigned long *result) {
|
|
|
|
size_t i;
|
|
unsigned long r;
|
|
|
|
*result = 0;
|
|
|
|
if (n->neg) return bc_vm_err(BC_ERROR_MATH_NEGATIVE);
|
|
|
|
for (r = 0, i = n->len; i > n->rdx;) {
|
|
|
|
unsigned long prev = r * 10;
|
|
|
|
if (prev == SIZE_MAX || prev / 10 != r)
|
|
return bc_vm_err(BC_ERROR_MATH_OVERFLOW);
|
|
|
|
r = prev + ((uchar) n->num[--i]);
|
|
|
|
if (r == SIZE_MAX || r < prev) return bc_vm_err(BC_ERROR_MATH_OVERFLOW);
|
|
}
|
|
|
|
*result = r;
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
void bc_num_ulong2num(BcNum *n, unsigned long val) {
|
|
|
|
size_t len;
|
|
signed char *ptr;
|
|
unsigned long i;
|
|
|
|
bc_num_setToZero(n, 0);
|
|
|
|
if (!val) return;
|
|
|
|
len = bc_num_log10(ULONG_MAX);
|
|
bc_num_expand(n, len);
|
|
for (ptr = n->num, i = 0; val; ++i, ++n->len, val /= 10) ptr[i] = val % 10;
|
|
}
|
|
|
|
size_t bc_num_addReq(BcNum *a, BcNum *b, size_t scale) {
|
|
return maxof(a->rdx, b->rdx) + maxof(BC_NUM_INT(a), BC_NUM_INT(b)) + 1;
|
|
}
|
|
|
|
size_t bc_num_mulReq(BcNum *a, BcNum *b, size_t scale) {
|
|
return BC_NUM_INT(a) + BC_NUM_INT(b) + maxof(scale, a->rdx + b->rdx) + 1;
|
|
}
|
|
|
|
size_t bc_num_powReq(BcNum *a, BcNum *b, size_t scale) {
|
|
return a->len + b->len + 1;
|
|
}
|
|
|
|
BcStatus bc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
BcNumBinaryOp op = (!a->neg == !b->neg) ? bc_num_a : bc_num_s;
|
|
return bc_num_binary(a, b, c, 0, op, bc_num_addReq(a, b, scale));
|
|
}
|
|
|
|
BcStatus bc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
BcNumBinaryOp op = (!a->neg == !b->neg) ? bc_num_s : bc_num_a;
|
|
return bc_num_binary(a, b, c, 1, op, bc_num_addReq(a, b, scale));
|
|
}
|
|
|
|
BcStatus bc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
return bc_num_binary(a, b, c, scale, bc_num_m, bc_num_mulReq(a, b, scale));
|
|
}
|
|
|
|
BcStatus bc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
return bc_num_binary(a, b, c, scale, bc_num_d, bc_num_mulReq(a, b, scale));
|
|
}
|
|
|
|
BcStatus bc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
return bc_num_binary(a, b, c, scale, bc_num_rem, bc_num_mulReq(a, b, scale));
|
|
}
|
|
|
|
BcStatus bc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale) {
|
|
return bc_num_binary(a, b, c, scale, bc_num_p, a->len + b->len + 1);
|
|
}
|
|
|
|
BcStatus bc_num_sqrt(BcNum *a, BcNum *b, size_t scale) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcNum num1, num2, half, f, fprime, *x0, *x1, *temp;
|
|
size_t pow, len, digs, digs1, resrdx, times = 0;
|
|
ssize_t cmp = 1, cmp1 = SSIZE_MAX, cmp2 = SSIZE_MAX;
|
|
signed char half_digs[2];
|
|
|
|
bc_num_init(b, maxof(scale, a->rdx) + ((BC_NUM_INT(a) + 1) >> 1) + 1);
|
|
|
|
if (!a->len) {
|
|
bc_num_setToZero(b, scale);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
if (a->neg) return bc_vm_err(BC_ERROR_MATH_NEGATIVE);
|
|
if (BC_NUM_ONE(a)) {
|
|
bc_num_one(b);
|
|
bc_num_extend(b, scale);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
scale = maxof(scale, a->rdx) + 1;
|
|
len = a->len + scale;
|
|
|
|
bc_num_init(&num1, len);
|
|
bc_num_init(&num2, len);
|
|
bc_num_setup(&half, half_digs, sizeof(half_digs));
|
|
|
|
bc_num_one(&half);
|
|
half.num[0] = 5;
|
|
half.rdx = 1;
|
|
|
|
bc_num_init(&f, len);
|
|
bc_num_init(&fprime, len);
|
|
|
|
x0 = &num1;
|
|
x1 = &num2;
|
|
|
|
bc_num_one(x0);
|
|
pow = BC_NUM_INT(a);
|
|
|
|
if (pow) {
|
|
|
|
if (pow & 1) x0->num[0] = 2;
|
|
else x0->num[0] = 6;
|
|
|
|
pow -= 2 - (pow & 1);
|
|
|
|
bc_num_extend(x0, pow);
|
|
|
|
// Make sure to move the radix back.
|
|
x0->rdx -= pow;
|
|
}
|
|
|
|
x0->rdx = digs = digs1 = 0;
|
|
resrdx = scale + 2;
|
|
len = BC_NUM_INT(x0) + resrdx - 1;
|
|
|
|
while (!TT.sig && (cmp || digs < len)) {
|
|
|
|
s = bc_num_div(a, x0, &f, resrdx);
|
|
if (s) goto err;
|
|
s = bc_num_add(x0, &f, &fprime, resrdx);
|
|
if (s) goto err;
|
|
s = bc_num_mul(&fprime, &half, x1, resrdx);
|
|
if (s) goto err;
|
|
|
|
cmp = bc_num_cmp(x1, x0);
|
|
digs = x1->len - (unsigned long long) llabs(cmp);
|
|
|
|
if (cmp == cmp2 && digs == digs1) times += 1;
|
|
else times = 0;
|
|
|
|
resrdx += times > 4;
|
|
|
|
cmp2 = cmp1;
|
|
cmp1 = cmp;
|
|
digs1 = digs;
|
|
|
|
temp = x0;
|
|
x0 = x1;
|
|
x1 = temp;
|
|
}
|
|
|
|
if (TT.sig) {
|
|
s = BC_STATUS_SIGNAL;
|
|
goto err;
|
|
}
|
|
|
|
bc_num_copy(b, x0);
|
|
scale -= 1;
|
|
if (b->rdx > scale) bc_num_truncate(b, b->rdx - scale);
|
|
|
|
err:
|
|
bc_num_free(&fprime);
|
|
bc_num_free(&f);
|
|
bc_num_free(&num2);
|
|
bc_num_free(&num1);
|
|
return s;
|
|
}
|
|
|
|
BcStatus bc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d, size_t scale) {
|
|
|
|
BcStatus s;
|
|
BcNum num2, *ptr_a;
|
|
int init = 0;
|
|
size_t ts = maxof(scale + b->rdx, a->rdx), len = bc_num_mulReq(a, b, ts);
|
|
|
|
if (c == a) {
|
|
memcpy(&num2, c, sizeof(BcNum));
|
|
ptr_a = &num2;
|
|
bc_num_init(c, len);
|
|
init = 1;
|
|
}
|
|
else {
|
|
ptr_a = a;
|
|
bc_num_expand(c, len);
|
|
}
|
|
|
|
s = bc_num_r(ptr_a, b, c, d, scale, ts);
|
|
|
|
if (init) bc_num_free(&num2);
|
|
|
|
return s;
|
|
}
|
|
|
|
int bc_id_cmp(struct str_len *e1, struct str_len *e2) {
|
|
return strcmp(e1->str, e2->str);
|
|
}
|
|
|
|
void bc_id_free(void *id) {
|
|
free(((struct str_len *)id)->str);
|
|
}
|
|
|
|
void bc_string_free(void *string) {
|
|
free(*((char**) string));
|
|
}
|
|
|
|
BcStatus bc_func_insert(BcFunc *f, char *name, BcType type, size_t line) {
|
|
|
|
struct str_len a;
|
|
size_t i;
|
|
|
|
for (i = 0; i < f->autos.len; ++i) {
|
|
struct str_len *id = bc_vec_item(&f->autos, i);
|
|
if (!strcmp(name, id->str) && type == (BcType) id->len)
|
|
return bc_vm_error(BC_ERROR_PARSE_DUP_LOCAL, line, name);
|
|
}
|
|
|
|
a.len = type;
|
|
a.str = name;
|
|
|
|
bc_vec_push(&f->autos, &a);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
void bc_func_init(BcFunc *f, char *name) {
|
|
bc_vec_init(&f->code, sizeof(uchar), NULL);
|
|
bc_vec_init(&f->strs, sizeof(char*), bc_string_free);
|
|
bc_vec_init(&f->consts, sizeof(char*), bc_string_free);
|
|
bc_vec_init(&f->autos, sizeof(struct str_len), bc_id_free);
|
|
bc_vec_init(&f->labels, sizeof(size_t), NULL);
|
|
f->nparams = 0;
|
|
f->voidfn = 0;
|
|
f->name = name;
|
|
}
|
|
|
|
void bc_func_reset(BcFunc *f) {
|
|
bc_vec_npop(&f->code, f->code.len);
|
|
bc_vec_npop(&f->strs, f->strs.len);
|
|
bc_vec_npop(&f->consts, f->consts.len);
|
|
bc_vec_npop(&f->autos, f->autos.len);
|
|
bc_vec_npop(&f->labels, f->labels.len);
|
|
f->nparams = 0;
|
|
f->voidfn = 0;
|
|
}
|
|
|
|
void bc_func_free(void *func) {
|
|
BcFunc *f = (BcFunc*) func;
|
|
bc_vec_free(&f->code);
|
|
bc_vec_free(&f->strs);
|
|
bc_vec_free(&f->consts);
|
|
bc_vec_free(&f->autos);
|
|
bc_vec_free(&f->labels);
|
|
}
|
|
|
|
void bc_array_init(BcVec *a, int nums) {
|
|
if (nums) bc_vec_init(a, sizeof(BcNum), bc_num_free);
|
|
else bc_vec_init(a, sizeof(BcVec), bc_vec_free);
|
|
bc_array_expand(a, 1);
|
|
}
|
|
|
|
void bc_array_copy(BcVec *d, BcVec *s) {
|
|
|
|
size_t i;
|
|
|
|
bc_vec_npop(d, d->len);
|
|
bc_vec_expand(d, s->cap);
|
|
d->len = s->len;
|
|
|
|
for (i = 0; i < s->len; ++i) {
|
|
BcNum *dnum = bc_vec_item(d, i), *snum = bc_vec_item(s, i);
|
|
bc_num_createCopy(dnum, snum);
|
|
}
|
|
}
|
|
|
|
void bc_array_expand(BcVec *a, size_t len) {
|
|
|
|
if (a->size == sizeof(BcNum) && a->dtor == bc_num_free) {
|
|
BcNum n;
|
|
while (len > a->len) {
|
|
bc_num_init(&n, BC_NUM_DEF_SIZE);
|
|
bc_vec_push(a, &n);
|
|
}
|
|
}
|
|
else {
|
|
BcVec v;
|
|
while (len > a->len) {
|
|
bc_array_init(&v, 1);
|
|
bc_vec_push(a, &v);
|
|
}
|
|
}
|
|
}
|
|
|
|
void bc_result_free(void *result) {
|
|
|
|
BcResult *r = (BcResult*) result;
|
|
|
|
switch (r->t) {
|
|
|
|
case BC_RESULT_TEMP:
|
|
case BC_RESULT_IBASE:
|
|
case BC_RESULT_SCALE:
|
|
case BC_RESULT_OBASE:
|
|
{
|
|
bc_num_free(&r->d.n);
|
|
break;
|
|
}
|
|
|
|
case BC_RESULT_VAR:
|
|
case BC_RESULT_ARRAY:
|
|
case BC_RESULT_ARRAY_ELEM:
|
|
{
|
|
free(r->d.id.str);
|
|
break;
|
|
}
|
|
|
|
case BC_RESULT_STR:
|
|
case BC_RESULT_CONSTANT:
|
|
case BC_RESULT_VOID:
|
|
case BC_RESULT_ONE:
|
|
case BC_RESULT_LAST:
|
|
{
|
|
// Do nothing.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
BcStatus bc_lex_invalidChar(BcLex *l, char c) {
|
|
l->t = BC_LEX_INVALID;
|
|
return bc_lex_verr(l, BC_ERROR_PARSE_CHAR, c);
|
|
}
|
|
|
|
void bc_lex_lineComment(BcLex *l) {
|
|
l->t = BC_LEX_WHITESPACE;
|
|
while (l->i < l->len && l->buf[l->i] != '\n') ++l->i;
|
|
}
|
|
|
|
BcStatus bc_lex_comment(BcLex *l) {
|
|
|
|
size_t i, nlines = 0;
|
|
char *buf = l->buf;
|
|
int end = 0;
|
|
char c;
|
|
|
|
l->t = BC_LEX_WHITESPACE;
|
|
|
|
for (i = ++l->i; !end; i += !end) {
|
|
|
|
for (; (c = buf[i]) && c != '*'; ++i) nlines += (c == '\n');
|
|
|
|
if (!c || buf[i + 1] == '\0') {
|
|
l->i = i;
|
|
return bc_lex_err(l, BC_ERROR_PARSE_COMMENT);
|
|
}
|
|
|
|
end = buf[i + 1] == '/';
|
|
}
|
|
|
|
l->i = i + 2;
|
|
l->line += nlines;
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
void bc_lex_whitespace(BcLex *l) {
|
|
char c;
|
|
l->t = BC_LEX_WHITESPACE;
|
|
for (c = l->buf[l->i]; c != '\n' && isspace(c); c = l->buf[++l->i]);
|
|
}
|
|
|
|
BcStatus bc_lex_number(BcLex *l, char start) {
|
|
|
|
char *buf = l->buf + l->i;
|
|
size_t i;
|
|
char last_valid, c;
|
|
int last_pt, pt = (start == '.');
|
|
|
|
l->t = BC_LEX_NUMBER;
|
|
last_valid = 'Z';
|
|
|
|
bc_vec_npop(&l->str, l->str.len);
|
|
bc_vec_push(&l->str, &start);
|
|
|
|
for (i = 0; (c = buf[i]) && (BC_LEX_NUM_CHAR(c, last_valid, pt) ||
|
|
(c == '\\' && buf[i + 1] == '\n')); ++i)
|
|
{
|
|
if (c == '\\') {
|
|
|
|
if (buf[i + 1] == '\n') {
|
|
|
|
i += 2;
|
|
|
|
// Make sure to eat whitespace at the beginning of the line.
|
|
while(isspace(buf[i]) && buf[i] != '\n') ++i;
|
|
|
|
c = buf[i];
|
|
|
|
if (!BC_LEX_NUM_CHAR(c, last_valid, pt)) break;
|
|
}
|
|
else break;
|
|
}
|
|
|
|
last_pt = (c == '.');
|
|
if (pt && last_pt) break;
|
|
pt = pt || last_pt;
|
|
|
|
bc_vec_push(&l->str, &c);
|
|
}
|
|
|
|
if (l->str.len - pt > BC_MAX_NUM)
|
|
return bc_lex_verr(l, BC_ERROR_EXEC_NUM_LEN, BC_MAX_NUM);
|
|
|
|
bc_vec_pushByte(&l->str, '\0');
|
|
l->i += i;
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
BcStatus bc_lex_name(BcLex *l) {
|
|
|
|
size_t i = 0;
|
|
char *buf = l->buf + l->i - 1;
|
|
char c = buf[i];
|
|
|
|
l->t = BC_LEX_NAME;
|
|
|
|
while ((c >= 'a' && c <= 'z') || isdigit(c) || c == '_') c = buf[++i];
|
|
|
|
if (i > BC_MAX_NAME)
|
|
return bc_lex_verr(l, BC_ERROR_EXEC_NAME_LEN, BC_MAX_NAME);
|
|
|
|
bc_vec_string(&l->str, i, buf);
|
|
|
|
// Increment the index. We minus 1 because it has already been incremented.
|
|
l->i += i - 1;
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
void bc_lex_init(BcLex *l) {
|
|
bc_vec_init(&l->str, sizeof(char), NULL);
|
|
}
|
|
|
|
void bc_lex_file(BcLex *l, char *file) {
|
|
l->line = 1;
|
|
TT.file = file;
|
|
}
|
|
|
|
BcStatus bc_lex_next(BcLex *l) {
|
|
|
|
BcStatus s;
|
|
|
|
l->last = l->t;
|
|
l->line += (l->i != 0 && l->buf[l->i - 1] == '\n');
|
|
|
|
if (l->last == BC_LEX_EOF) return bc_lex_err(l, BC_ERROR_PARSE_EOF);
|
|
|
|
l->t = BC_LEX_EOF;
|
|
|
|
if (l->i == l->len) return BC_STATUS_SUCCESS;
|
|
|
|
// Loop until failure or we don't have whitespace. This
|
|
// is so the parser doesn't get inundated with whitespace.
|
|
do {
|
|
s = bc_lex_token(l);
|
|
} while (!s && l->t == BC_LEX_WHITESPACE);
|
|
|
|
return s;
|
|
}
|
|
|
|
BcStatus bc_lex_text(BcLex *l, char *text) {
|
|
l->buf = text;
|
|
l->i = 0;
|
|
l->len = strlen(text);
|
|
l->t = l->last = BC_LEX_INVALID;
|
|
return bc_lex_next(l);
|
|
}
|
|
|
|
static BcStatus bc_lex_identifier(BcLex *l) {
|
|
|
|
BcStatus s;
|
|
size_t i;
|
|
char *buf = l->buf + l->i - 1;
|
|
|
|
for (i = 0; i < bc_lex_kws_len; ++i) {
|
|
|
|
BcLexKeyword *kw = bc_lex_kws + i;
|
|
size_t len = BC_LEX_KW_LEN(kw);
|
|
|
|
if (!strncmp(buf, kw->name, len) && !isalnum(buf[len]) && buf[len] != '_')
|
|
{
|
|
l->t = BC_LEX_KEY_AUTO + (BcLexType) i;
|
|
|
|
if (!BC_LEX_KW_POSIX(kw)) {
|
|
s = bc_lex_vposixErr(l, BC_ERROR_POSIX_KW, kw->name);
|
|
if (s) return s;
|
|
}
|
|
|
|
// We minus 1 because the index has already been incremented.
|
|
l->i += len - 1;
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
s = bc_lex_name(l);
|
|
if (s) return s;
|
|
|
|
if (l->str.len - 1 > 1) s = bc_lex_vposixErr(l, BC_ERROR_POSIX_NAME_LEN, buf);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_lex_string(BcLex *l) {
|
|
|
|
size_t len, nlines = 0, i = l->i;
|
|
char *buf = l->buf;
|
|
char c;
|
|
|
|
l->t = BC_LEX_STR;
|
|
|
|
for (; (c = buf[i]) && c != '"'; ++i) nlines += c == '\n';
|
|
|
|
if (c == '\0') {
|
|
l->i = i;
|
|
return bc_lex_err(l, BC_ERROR_PARSE_STRING);
|
|
}
|
|
|
|
len = i - l->i;
|
|
|
|
if (len > BC_MAX_STRING)
|
|
return bc_lex_verr(l, BC_ERROR_EXEC_STRING_LEN, BC_MAX_STRING);
|
|
|
|
bc_vec_string(&l->str, len, l->buf + l->i);
|
|
|
|
l->i = i + 1;
|
|
l->line += nlines;
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static void bc_lex_assign(BcLex *l, BcLexType with, BcLexType without) {
|
|
if (l->buf[l->i] == '=') {
|
|
++l->i;
|
|
l->t = with;
|
|
}
|
|
else l->t = without;
|
|
}
|
|
|
|
BcStatus bc_lex_token(BcLex *l) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
char c = l->buf[l->i++], c2;
|
|
|
|
// This is the workhorse of the lexer.
|
|
switch (c) {
|
|
|
|
case '\0':
|
|
case '\n':
|
|
{
|
|
l->t = !c ? BC_LEX_EOF : BC_LEX_NLINE;
|
|
break;
|
|
}
|
|
|
|
case '\t':
|
|
case '\v':
|
|
case '\f':
|
|
case '\r':
|
|
case ' ':
|
|
{
|
|
bc_lex_whitespace(l);
|
|
break;
|
|
}
|
|
|
|
case '!':
|
|
{
|
|
bc_lex_assign(l, BC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT);
|
|
|
|
if (l->t == BC_LEX_OP_BOOL_NOT) {
|
|
s = bc_lex_vposixErr(l, BC_ERROR_POSIX_BOOL, "!");
|
|
if (s) return s;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case '"':
|
|
{
|
|
s = bc_lex_string(l);
|
|
break;
|
|
}
|
|
|
|
case '#':
|
|
{
|
|
s = bc_lex_posixErr(l, BC_ERROR_POSIX_COMMENT);
|
|
if (s) return s;
|
|
|
|
bc_lex_lineComment(l);
|
|
|
|
break;
|
|
}
|
|
|
|
case '%':
|
|
{
|
|
bc_lex_assign(l, BC_LEX_OP_ASSIGN_MODULUS, BC_LEX_OP_MODULUS);
|
|
break;
|
|
}
|
|
|
|
case '&':
|
|
{
|
|
c2 = l->buf[l->i];
|
|
if (c2 == '&') {
|
|
|
|
s = bc_lex_vposixErr(l, BC_ERROR_POSIX_BOOL, "&&");
|
|
if (s) return s;
|
|
|
|
++l->i;
|
|
l->t = BC_LEX_OP_BOOL_AND;
|
|
}
|
|
else s = bc_lex_invalidChar(l, c);
|
|
|
|
break;
|
|
}
|
|
case '(':
|
|
case ')':
|
|
{
|
|
l->t = (BcLexType) (c - '(' + BC_LEX_LPAREN);
|
|
break;
|
|
}
|
|
|
|
case '*':
|
|
{
|
|
bc_lex_assign(l, BC_LEX_OP_ASSIGN_MULTIPLY, BC_LEX_OP_MULTIPLY);
|
|
break;
|
|
}
|
|
|
|
case '+':
|
|
{
|
|
c2 = l->buf[l->i];
|
|
if (c2 == '+') {
|
|
++l->i;
|
|
l->t = BC_LEX_OP_INC;
|
|
}
|
|
else bc_lex_assign(l, BC_LEX_OP_ASSIGN_PLUS, BC_LEX_OP_PLUS);
|
|
break;
|
|
}
|
|
|
|
case ',':
|
|
{
|
|
l->t = BC_LEX_COMMA;
|
|
break;
|
|
}
|
|
|
|
case '-':
|
|
{
|
|
c2 = l->buf[l->i];
|
|
if (c2 == '-') {
|
|
++l->i;
|
|
l->t = BC_LEX_OP_DEC;
|
|
}
|
|
else bc_lex_assign(l, BC_LEX_OP_ASSIGN_MINUS, BC_LEX_OP_MINUS);
|
|
break;
|
|
}
|
|
|
|
case '.':
|
|
{
|
|
c2 = l->buf[l->i];
|
|
if (BC_LEX_NUM_CHAR(c2, 'Z', 1)) s = bc_lex_number(l, c);
|
|
else {
|
|
l->t = BC_LEX_KEY_LAST;
|
|
s = bc_lex_posixErr(l, BC_ERROR_POSIX_DOT);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case '/':
|
|
{
|
|
c2 = l->buf[l->i];
|
|
if (c2 =='*') s = bc_lex_comment(l);
|
|
else bc_lex_assign(l, BC_LEX_OP_ASSIGN_DIVIDE, BC_LEX_OP_DIVIDE);
|
|
break;
|
|
}
|
|
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case 'A':
|
|
case 'B':
|
|
case 'C':
|
|
case 'D':
|
|
case 'E':
|
|
case 'F':
|
|
// Apparently, GNU bc (and maybe others) allows any uppercase letter as a
|
|
// number. When single digits, they act like the ones above. When multi-
|
|
// digit, any letter above the input base is automatically set to the
|
|
// biggest allowable digit in the input base.
|
|
case 'G':
|
|
case 'H':
|
|
case 'I':
|
|
case 'J':
|
|
case 'K':
|
|
case 'L':
|
|
case 'M':
|
|
case 'N':
|
|
case 'O':
|
|
case 'P':
|
|
case 'Q':
|
|
case 'R':
|
|
case 'S':
|
|
case 'T':
|
|
case 'U':
|
|
case 'V':
|
|
case 'W':
|
|
case 'X':
|
|
case 'Y':
|
|
case 'Z':
|
|
{
|
|
s = bc_lex_number(l, c);
|
|
break;
|
|
}
|
|
|
|
case ';':
|
|
{
|
|
l->t = BC_LEX_SCOLON;
|
|
break;
|
|
}
|
|
|
|
case '<':
|
|
{
|
|
bc_lex_assign(l, BC_LEX_OP_REL_LE, BC_LEX_OP_REL_LT);
|
|
break;
|
|
}
|
|
|
|
case '=':
|
|
{
|
|
bc_lex_assign(l, BC_LEX_OP_REL_EQ, BC_LEX_OP_ASSIGN);
|
|
break;
|
|
}
|
|
|
|
case '>':
|
|
{
|
|
bc_lex_assign(l, BC_LEX_OP_REL_GE, BC_LEX_OP_REL_GT);
|
|
break;
|
|
}
|
|
|
|
case '[':
|
|
case ']':
|
|
{
|
|
l->t = (BcLexType) (c - '[' + BC_LEX_LBRACKET);
|
|
break;
|
|
}
|
|
|
|
case '\\':
|
|
{
|
|
if (l->buf[l->i] == '\n') {
|
|
l->t = BC_LEX_WHITESPACE;
|
|
++l->i;
|
|
}
|
|
else s = bc_lex_invalidChar(l, c);
|
|
break;
|
|
}
|
|
|
|
case '^':
|
|
{
|
|
bc_lex_assign(l, BC_LEX_OP_ASSIGN_POWER, BC_LEX_OP_POWER);
|
|
break;
|
|
}
|
|
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
case 'd':
|
|
case 'e':
|
|
case 'f':
|
|
case 'g':
|
|
case 'h':
|
|
case 'i':
|
|
case 'j':
|
|
case 'k':
|
|
case 'l':
|
|
case 'm':
|
|
case 'n':
|
|
case 'o':
|
|
case 'p':
|
|
case 'q':
|
|
case 'r':
|
|
case 's':
|
|
case 't':
|
|
case 'u':
|
|
case 'v':
|
|
case 'w':
|
|
case 'x':
|
|
case 'y':
|
|
case 'z':
|
|
{
|
|
s = bc_lex_identifier(l);
|
|
break;
|
|
}
|
|
|
|
case '{':
|
|
case '}':
|
|
{
|
|
l->t = (BcLexType) (c - '{' + BC_LEX_LBRACE);
|
|
break;
|
|
}
|
|
|
|
case '|':
|
|
{
|
|
c2 = l->buf[l->i];
|
|
|
|
if (c2 == '|') {
|
|
|
|
s = bc_lex_vposixErr(l, BC_ERROR_POSIX_BOOL, "||");
|
|
if (s) return s;
|
|
|
|
++l->i;
|
|
l->t = BC_LEX_OP_BOOL_OR;
|
|
}
|
|
else s = bc_lex_invalidChar(l, c);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
s = bc_lex_invalidChar(l, c);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
void bc_parse_updateFunc(BcParse *p, size_t fidx) {
|
|
p->fidx = fidx;
|
|
p->func = bc_vec_item(&p->prog->fns, fidx);
|
|
}
|
|
|
|
void bc_parse_pushName(BcParse *p, char *name) {
|
|
bc_vec_npush(&p->func->code, strlen(name), name);
|
|
bc_parse_push(p, UCHAR_MAX);
|
|
}
|
|
|
|
void bc_parse_pushIndex(BcParse *p, size_t idx) {
|
|
bc_vec_pushIndex(&p->func->code, idx);
|
|
}
|
|
|
|
void bc_parse_addId(BcParse *p, uchar inst) {
|
|
|
|
BcFunc *f = p->func;
|
|
BcVec *v = inst == BC_INST_NUM ? &f->consts : &f->strs;
|
|
size_t idx = v->len;
|
|
char *str = xstrdup(p->l.str.v);
|
|
|
|
bc_vec_push(v, &str);
|
|
bc_parse_updateFunc(p, p->fidx);
|
|
bc_parse_push(p, inst);
|
|
bc_parse_pushIndex(p, idx);
|
|
}
|
|
|
|
BcStatus bc_parse_text(BcParse *p, char *text) {
|
|
// Make sure the pointer isn't invalidated.
|
|
p->func = bc_vec_item(&p->prog->fns, p->fidx);
|
|
return bc_lex_text(&p->l, text);
|
|
}
|
|
|
|
BcStatus bc_parse_reset(BcParse *p, BcStatus s) {
|
|
|
|
if (p->fidx != BC_PROG_MAIN) {
|
|
bc_func_reset(p->func);
|
|
bc_parse_updateFunc(p, BC_PROG_MAIN);
|
|
}
|
|
|
|
p->l.i = p->l.len;
|
|
p->l.t = BC_LEX_EOF;
|
|
p->auto_part = 0;
|
|
|
|
bc_vec_npop(&p->flags, p->flags.len - 1);
|
|
bc_vec_npop(&p->exits, p->exits.len);
|
|
bc_vec_npop(&p->conds, p->conds.len);
|
|
bc_vec_npop(&p->ops, p->ops.len);
|
|
|
|
return bc_program_reset(p->prog, s);
|
|
}
|
|
|
|
void bc_parse_free(BcParse *p) {
|
|
bc_vec_free(&p->flags);
|
|
bc_vec_free(&p->exits);
|
|
bc_vec_free(&p->conds);
|
|
bc_vec_free(&p->ops);
|
|
bc_vec_free(&p->l.str);
|
|
}
|
|
|
|
void bc_parse_init(BcParse *p, BcProgram *prog, size_t func)
|
|
{
|
|
uint16_t flag = 0;
|
|
bc_vec_init(&p->flags, sizeof(uint16_t), NULL);
|
|
bc_vec_push(&p->flags, &flag);
|
|
bc_vec_init(&p->exits, sizeof(BcInstPtr), NULL);
|
|
bc_vec_init(&p->conds, sizeof(size_t), NULL);
|
|
bc_vec_init(&p->ops, sizeof(BcLexType), NULL);
|
|
|
|
bc_lex_init(&p->l);
|
|
|
|
p->prog = prog;
|
|
p->auto_part = 0;
|
|
bc_parse_updateFunc(p, func);
|
|
}
|
|
|
|
static BcStatus bc_parse_else(BcParse *p);
|
|
static BcStatus bc_parse_stmt(BcParse *p);
|
|
static BcStatus bc_parse_expr_err(BcParse *p, uint8_t flags, BcParseNext next);
|
|
|
|
static int bc_parse_inst_isLeaf(BcInst t) {
|
|
return (t >= BC_INST_NUM && t <= BC_INST_ABS) ||
|
|
t == BC_INST_INC_POST || t == BC_INST_DEC_POST;
|
|
}
|
|
|
|
static int bc_parse_isDelimiter(BcParse *p) {
|
|
|
|
BcLexType t = p->l.t;
|
|
int good = 0;
|
|
|
|
if (BC_PARSE_DELIMITER(t)) return 1;
|
|
|
|
if (t == BC_LEX_KEY_ELSE) {
|
|
|
|
size_t i;
|
|
uint16_t *fptr = NULL, flags = BC_PARSE_FLAG_ELSE;
|
|
|
|
for (i = 0; i < p->flags.len && BC_PARSE_BLOCK_STMT(flags); ++i) {
|
|
fptr = bc_vec_item_rev(&p->flags, i);
|
|
flags = *fptr;
|
|
if ((flags & BC_PARSE_FLAG_BRACE) && p->l.last != BC_LEX_RBRACE)
|
|
return 0;
|
|
}
|
|
|
|
good = ((flags & BC_PARSE_FLAG_IF) != 0);
|
|
}
|
|
else if (t == BC_LEX_RBRACE) {
|
|
|
|
size_t i;
|
|
|
|
for (i = 0; !good && i < p->flags.len; ++i) {
|
|
uint16_t *fptr = bc_vec_item_rev(&p->flags, i);
|
|
good = (((*fptr) & BC_PARSE_FLAG_BRACE) != 0);
|
|
}
|
|
}
|
|
|
|
return good;
|
|
}
|
|
|
|
static void bc_parse_setLabel(BcParse *p) {
|
|
|
|
BcFunc *func = p->func;
|
|
BcInstPtr *ip = bc_vec_top(&p->exits);
|
|
size_t *label;
|
|
|
|
label = bc_vec_item(&func->labels, ip->idx);
|
|
*label = func->code.len;
|
|
|
|
bc_vec_pop(&p->exits);
|
|
}
|
|
|
|
static void bc_parse_createLabel(BcParse *p, size_t idx) {
|
|
bc_vec_push(&p->func->labels, &idx);
|
|
}
|
|
|
|
static void bc_parse_createCondLabel(BcParse *p, size_t idx) {
|
|
bc_parse_createLabel(p, p->func->code.len);
|
|
bc_vec_push(&p->conds, &idx);
|
|
}
|
|
|
|
static void bc_parse_createExitLabel(BcParse *p, size_t idx, int loop) {
|
|
|
|
BcInstPtr ip;
|
|
|
|
ip.func = loop;
|
|
ip.idx = idx;
|
|
ip.len = 0;
|
|
|
|
bc_vec_push(&p->exits, &ip);
|
|
bc_parse_createLabel(p, SIZE_MAX);
|
|
}
|
|
|
|
static size_t bc_parse_addFunc(BcParse *p, char *name) {
|
|
|
|
size_t idx = bc_program_insertFunc(p->prog, name);
|
|
|
|
// Make sure that this pointer was not invalidated.
|
|
p->func = bc_vec_item(&p->prog->fns, p->fidx);
|
|
|
|
return idx;
|
|
}
|
|
|
|
static void bc_parse_operator(BcParse *p, BcLexType type,
|
|
size_t start, size_t *nexprs)
|
|
{
|
|
BcLexType t;
|
|
uchar l, r = BC_PARSE_OP_PREC(type);
|
|
uchar left = BC_PARSE_OP_LEFT(type);
|
|
|
|
while (p->ops.len > start) {
|
|
|
|
t = BC_PARSE_TOP_OP(p);
|
|
if (t == BC_LEX_LPAREN) break;
|
|
|
|
l = BC_PARSE_OP_PREC(t);
|
|
if (l >= r && (l != r || !left)) break;
|
|
|
|
bc_parse_push(p, BC_PARSE_TOKEN_INST(t));
|
|
bc_vec_pop(&p->ops);
|
|
*nexprs -= !BC_PARSE_OP_PREFIX(t);
|
|
}
|
|
|
|
bc_vec_push(&p->ops, &type);
|
|
}
|
|
|
|
static BcStatus bc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs) {
|
|
|
|
BcLexType top;
|
|
|
|
if (p->ops.len <= ops_bgn) return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
while ((top = BC_PARSE_TOP_OP(p)) != BC_LEX_LPAREN) {
|
|
|
|
bc_parse_push(p, BC_PARSE_TOKEN_INST(top));
|
|
|
|
bc_vec_pop(&p->ops);
|
|
*nexs -= !BC_PARSE_OP_PREFIX(top);
|
|
|
|
if (p->ops.len <= ops_bgn) return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
}
|
|
|
|
bc_vec_pop(&p->ops);
|
|
|
|
return bc_lex_next(&p->l);
|
|
}
|
|
|
|
static BcStatus bc_parse_params(BcParse *p, uint8_t flags) {
|
|
|
|
BcStatus s;
|
|
int comma = 0;
|
|
size_t nparams;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
for (nparams = 0; p->l.t != BC_LEX_RPAREN; ++nparams) {
|
|
|
|
flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
|
|
s = bc_parse_expr_status(p, flags, bc_parse_next_param);
|
|
if (s) return s;
|
|
|
|
comma = p->l.t == BC_LEX_COMMA;
|
|
if (comma) {
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
}
|
|
}
|
|
|
|
if (comma) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
bc_parse_push(p, BC_INST_CALL);
|
|
bc_parse_pushIndex(p, nparams);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_parse_call(BcParse *p, char *name, uint8_t flags) {
|
|
|
|
BcStatus s;
|
|
struct str_len id;
|
|
size_t idx;
|
|
|
|
id.str = name;
|
|
|
|
s = bc_parse_params(p, flags);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t != BC_LEX_RPAREN) {
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
goto err;
|
|
}
|
|
|
|
idx = bc_map_index(&p->prog->fn_map, &id);
|
|
|
|
if (idx == SIZE_MAX) {
|
|
bc_parse_addFunc(p, name);
|
|
idx = bc_map_index(&p->prog->fn_map, &id);
|
|
} else free(name);
|
|
|
|
bc_parse_pushIndex(p,
|
|
((struct str_len *)bc_vec_item(&p->prog->fn_map, idx))->len);
|
|
|
|
return bc_lex_next(&p->l);
|
|
|
|
err:
|
|
free(name);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_name(BcParse *p, BcInst *type, uint8_t flags) {
|
|
|
|
BcStatus s;
|
|
char *name;
|
|
|
|
name = xstrdup(p->l.str.v);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t == BC_LEX_LBRACKET) {
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t == BC_LEX_RBRACKET) {
|
|
|
|
if (!(flags & BC_PARSE_ARRAY)) {
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
goto err;
|
|
}
|
|
|
|
*type = BC_INST_ARRAY;
|
|
}
|
|
else {
|
|
|
|
*type = BC_INST_ARRAY_ELEM;
|
|
|
|
flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
|
|
s = bc_parse_expr_status(p, flags, bc_parse_next_elem);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t != BC_LEX_RBRACKET) {
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
|
|
bc_parse_push(p, *type);
|
|
bc_parse_pushName(p, name);
|
|
}
|
|
else if (p->l.t == BC_LEX_LPAREN) {
|
|
|
|
if (flags & BC_PARSE_NOCALL) {
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
goto err;
|
|
}
|
|
|
|
*type = BC_INST_CALL;
|
|
|
|
// Return early because bc_parse_call() frees the name.
|
|
return bc_parse_call(p, name, flags);
|
|
}
|
|
else {
|
|
*type = BC_INST_VAR;
|
|
bc_parse_push(p, BC_INST_VAR);
|
|
bc_parse_pushName(p, name);
|
|
}
|
|
|
|
err:
|
|
free(name);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_read(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_LPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_RPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
bc_parse_push(p, BC_INST_READ);
|
|
|
|
return bc_lex_next(&p->l);
|
|
}
|
|
|
|
static BcStatus bc_parse_builtin(BcParse *p, BcLexType type,
|
|
uint8_t flags, BcInst *prev)
|
|
{
|
|
BcStatus s;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_LPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL));
|
|
if (type == BC_LEX_KEY_LENGTH) flags |= BC_PARSE_ARRAY;
|
|
|
|
s = bc_parse_expr_status(p, flags, bc_parse_next_rel);
|
|
if (s) return s;
|
|
|
|
if (p->l.t != BC_LEX_RPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
*prev = type - BC_LEX_KEY_LENGTH + BC_INST_LENGTH;
|
|
bc_parse_push(p, *prev);
|
|
|
|
return bc_lex_next(&p->l);
|
|
}
|
|
|
|
static BcStatus bc_parse_scale(BcParse *p, BcInst *type, uint8_t flags) {
|
|
|
|
BcStatus s;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
if (p->l.t != BC_LEX_LPAREN) {
|
|
*type = BC_INST_SCALE;
|
|
bc_parse_push(p, BC_INST_SCALE);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
*type = BC_INST_SCALE_FUNC;
|
|
flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
s = bc_parse_expr_status(p, flags, bc_parse_next_rel);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_RPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
bc_parse_push(p, BC_INST_SCALE_FUNC);
|
|
|
|
return bc_lex_next(&p->l);
|
|
}
|
|
|
|
static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev,
|
|
size_t *nexs, uint8_t flags)
|
|
{
|
|
BcStatus s;
|
|
BcLexType type;
|
|
uchar inst;
|
|
BcInst etype = *prev;
|
|
BcLexType last = p->l.last;
|
|
|
|
if (last == BC_LEX_OP_INC || last == BC_LEX_OP_DEC || last == BC_LEX_RPAREN)
|
|
return s = bc_parse_err(p, BC_ERROR_PARSE_ASSIGN);
|
|
|
|
if (BC_PARSE_INST_VAR(etype)) {
|
|
*prev = inst = BC_INST_INC_POST + (p->l.t != BC_LEX_OP_INC);
|
|
bc_parse_push(p, inst);
|
|
s = bc_lex_next(&p->l);
|
|
}
|
|
else {
|
|
|
|
*prev = inst = BC_INST_INC_PRE + (p->l.t != BC_LEX_OP_INC);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
type = p->l.t;
|
|
|
|
// Because we parse the next part of the expression
|
|
// right here, we need to increment this.
|
|
*nexs = *nexs + 1;
|
|
|
|
if (type == BC_LEX_NAME)
|
|
s = bc_parse_name(p, prev, flags | BC_PARSE_NOCALL);
|
|
else if (type >= BC_LEX_KEY_LAST && type <= BC_LEX_KEY_OBASE) {
|
|
bc_parse_push(p, type - BC_LEX_KEY_LAST + BC_INST_LAST);
|
|
s = bc_lex_next(&p->l);
|
|
}
|
|
else if (type == BC_LEX_KEY_SCALE) {
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (p->l.t == BC_LEX_LPAREN) s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
else bc_parse_push(p, BC_INST_SCALE);
|
|
}
|
|
else s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
if (!s) bc_parse_push(p, inst);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
|
|
int rparen, int bin_last, size_t *nexprs)
|
|
{
|
|
BcStatus s;
|
|
BcLexType type;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
type = BC_PARSE_LEAF(*prev, bin_last, rparen) ? BC_LEX_OP_MINUS : BC_LEX_NEG;
|
|
*prev = BC_PARSE_TOKEN_INST(type);
|
|
|
|
// We can just push onto the op stack because this is the largest
|
|
// precedence operator that gets pushed. Inc/dec does not.
|
|
if (type != BC_LEX_OP_MINUS) bc_vec_push(&p->ops, &type);
|
|
else bc_parse_operator(p, type, ops_bgn, nexprs);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_str(BcParse *p, char inst) {
|
|
bc_parse_string(p);
|
|
bc_parse_push(p, inst);
|
|
return bc_lex_next(&p->l);
|
|
}
|
|
|
|
static BcStatus bc_parse_print(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
BcLexType t;
|
|
int comma = 0;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
t = p->l.t;
|
|
|
|
if (bc_parse_isDelimiter(p)) return bc_parse_err(p, BC_ERROR_PARSE_PRINT);
|
|
|
|
do {
|
|
if (t == BC_LEX_STR) s = bc_parse_str(p, BC_INST_PRINT_POP);
|
|
else {
|
|
s = bc_parse_expr_status(p, 0, bc_parse_next_print);
|
|
if (!s) bc_parse_push(p, BC_INST_PRINT_POP);
|
|
}
|
|
|
|
if (s) return s;
|
|
|
|
comma = (p->l.t == BC_LEX_COMMA);
|
|
|
|
if (comma) s = bc_lex_next(&p->l);
|
|
else {
|
|
if (!bc_parse_isDelimiter(p))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
else break;
|
|
}
|
|
|
|
t = p->l.t;
|
|
} while (!s);
|
|
|
|
if (s) return s;
|
|
if (comma) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_return(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
BcLexType t;
|
|
int paren;
|
|
uchar inst = BC_INST_RET0;
|
|
|
|
if (!BC_PARSE_FUNC(p)) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
if (p->func->voidfn) inst = BC_INST_RET_VOID;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
t = p->l.t;
|
|
paren = t == BC_LEX_LPAREN;
|
|
|
|
if (bc_parse_isDelimiter(p)) bc_parse_push(p, inst);
|
|
else {
|
|
|
|
s = bc_parse_expr_err(p, 0, bc_parse_next_expr);
|
|
if (s && s != BC_STATUS_EMPTY_EXPR) return s;
|
|
else if (s == BC_STATUS_EMPTY_EXPR) {
|
|
bc_parse_push(p, inst);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
}
|
|
|
|
if (!paren || p->l.last != BC_LEX_RPAREN) {
|
|
s = bc_parse_posixErr(p, BC_ERROR_POSIX_RET);
|
|
if (s) return s;
|
|
}
|
|
else if (p->func->voidfn)
|
|
return bc_parse_verr(p, BC_ERROR_PARSE_RET_VOID, p->func->name);
|
|
|
|
bc_parse_push(p, BC_INST_RET);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_endBody(BcParse *p, int brace) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
int has_brace, new_else = 0;
|
|
|
|
if (p->flags.len <= 1) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
if (brace) {
|
|
if (p->l.t == BC_LEX_RBRACE) {
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (!bc_parse_isDelimiter(p))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
}
|
|
else return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
}
|
|
|
|
has_brace = (BC_PARSE_BRACE(p) != 0);
|
|
|
|
do {
|
|
size_t len = p->flags.len;
|
|
int loop;
|
|
|
|
if (has_brace && !brace) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
loop = BC_PARSE_LOOP_INNER(p) != 0;
|
|
|
|
if (loop || BC_PARSE_ELSE(p)) {
|
|
|
|
if (loop) {
|
|
|
|
size_t *label = bc_vec_top(&p->conds);
|
|
|
|
bc_parse_push(p, BC_INST_JUMP);
|
|
bc_parse_pushIndex(p, *label);
|
|
|
|
bc_vec_pop(&p->conds);
|
|
}
|
|
|
|
bc_parse_setLabel(p);
|
|
bc_vec_pop(&p->flags);
|
|
}
|
|
else if (BC_PARSE_FUNC_INNER(p)) {
|
|
BcInst inst = (p->func->voidfn ? BC_INST_RET_VOID : BC_INST_RET0);
|
|
bc_parse_push(p, inst);
|
|
bc_parse_updateFunc(p, BC_PROG_MAIN);
|
|
bc_vec_pop(&p->flags);
|
|
}
|
|
else if (BC_PARSE_BRACE(p) && !BC_PARSE_IF(p)) bc_vec_pop(&p->flags);
|
|
|
|
// This needs to be last to parse nested if's properly.
|
|
if (BC_PARSE_IF(p) && (len == p->flags.len || !BC_PARSE_BRACE(p))) {
|
|
|
|
while (p->l.t == BC_LEX_NLINE) {
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
}
|
|
|
|
bc_vec_pop(&p->flags);
|
|
*(BC_PARSE_TOP_FLAG_PTR(p)) |= BC_PARSE_FLAG_IF_END;
|
|
|
|
new_else = (p->l.t == BC_LEX_KEY_ELSE);
|
|
if (new_else) s = bc_parse_else(p);
|
|
else if (!has_brace && (!BC_PARSE_IF_END(p) || brace))
|
|
bc_parse_noElse(p);
|
|
}
|
|
|
|
if (brace && has_brace) brace = 0;
|
|
|
|
} while (p->flags.len > 1 && !new_else && (!BC_PARSE_IF_END(p) || brace) &&
|
|
!(has_brace = (BC_PARSE_BRACE(p) != 0)));
|
|
|
|
if (!s && p->flags.len == 1 && brace)
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
else if (brace && BC_PARSE_BRACE(p)) {
|
|
uint16_t flags = BC_PARSE_TOP_FLAG(p);
|
|
if (!(flags & (BC_PARSE_FLAG_FUNC_INNER | BC_PARSE_FLAG_LOOP_INNER)) &&
|
|
!(flags & (BC_PARSE_FLAG_IF | BC_PARSE_FLAG_ELSE)) &&
|
|
!(flags & (BC_PARSE_FLAG_IF_END)))
|
|
{
|
|
bc_vec_pop(&p->flags);
|
|
}
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static void bc_parse_startBody(BcParse *p, uint16_t flags) {
|
|
flags |= (BC_PARSE_TOP_FLAG(p) & (BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_LOOP));
|
|
flags |= BC_PARSE_FLAG_BODY;
|
|
bc_vec_push(&p->flags, &flags);
|
|
}
|
|
|
|
void bc_parse_noElse(BcParse *p) {
|
|
uint16_t *flag_ptr = BC_PARSE_TOP_FLAG_PTR(p);
|
|
*flag_ptr = (*flag_ptr & ~(BC_PARSE_FLAG_IF_END));
|
|
bc_parse_setLabel(p);
|
|
}
|
|
|
|
static BcStatus bc_parse_if(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
size_t idx;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_LPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
s = bc_parse_expr_status(p, BC_PARSE_REL, bc_parse_next_rel);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_RPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
bc_parse_push(p, BC_INST_JUMP_ZERO);
|
|
|
|
idx = p->func->labels.len;
|
|
|
|
bc_parse_pushIndex(p, idx);
|
|
bc_parse_createExitLabel(p, idx, 0);
|
|
bc_parse_startBody(p, BC_PARSE_FLAG_IF);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_parse_else(BcParse *p) {
|
|
|
|
size_t idx = p->func->labels.len;
|
|
|
|
if (!BC_PARSE_IF_END(p)) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
bc_parse_push(p, BC_INST_JUMP);
|
|
bc_parse_pushIndex(p, idx);
|
|
|
|
bc_parse_noElse(p);
|
|
|
|
bc_parse_createExitLabel(p, idx, 0);
|
|
bc_parse_startBody(p, BC_PARSE_FLAG_ELSE);
|
|
|
|
return bc_lex_next(&p->l);
|
|
}
|
|
|
|
static BcStatus bc_parse_while(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
size_t idx;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_LPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
bc_parse_createCondLabel(p, p->func->labels.len);
|
|
|
|
idx = p->func->labels.len;
|
|
|
|
bc_parse_createExitLabel(p, idx, 1);
|
|
|
|
s = bc_parse_expr_status(p, BC_PARSE_REL, bc_parse_next_rel);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_RPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
bc_parse_push(p, BC_INST_JUMP_ZERO);
|
|
bc_parse_pushIndex(p, idx);
|
|
bc_parse_startBody(p, BC_PARSE_FLAG_LOOP | BC_PARSE_FLAG_LOOP_INNER);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_parse_for(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
size_t cond_idx, exit_idx, body_idx, update_idx;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_LPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
if (p->l.t != BC_LEX_SCOLON) {
|
|
s = bc_parse_expr_status(p, 0, bc_parse_next_for);
|
|
if (!s) bc_parse_push(p, BC_INST_POP);
|
|
}
|
|
else s = bc_parse_posixErr(p, BC_ERROR_POSIX_FOR1);
|
|
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_SCOLON) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
cond_idx = p->func->labels.len;
|
|
update_idx = cond_idx + 1;
|
|
body_idx = update_idx + 1;
|
|
exit_idx = body_idx + 1;
|
|
|
|
bc_parse_createLabel(p, p->func->code.len);
|
|
|
|
if (p->l.t != BC_LEX_SCOLON)
|
|
s = bc_parse_expr_status(p, BC_PARSE_REL, bc_parse_next_for);
|
|
else {
|
|
|
|
// Set this for the next call to bc_parse_number.
|
|
// This is safe to set because the current token
|
|
// is a semicolon, which has no string requirement.
|
|
bc_vec_string(&p->l.str, strlen(bc_parse_const1), bc_parse_const1);
|
|
bc_parse_number(p);
|
|
|
|
s = bc_parse_posixErr(p, BC_ERROR_POSIX_FOR2);
|
|
}
|
|
|
|
if (s) return s;
|
|
if (p->l.t != BC_LEX_SCOLON) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
bc_parse_push(p, BC_INST_JUMP_ZERO);
|
|
bc_parse_pushIndex(p, exit_idx);
|
|
bc_parse_push(p, BC_INST_JUMP);
|
|
bc_parse_pushIndex(p, body_idx);
|
|
|
|
bc_parse_createCondLabel(p, update_idx);
|
|
|
|
if (p->l.t != BC_LEX_RPAREN) {
|
|
s = bc_parse_expr_status(p, 0, bc_parse_next_rel);
|
|
if (!s) bc_parse_push(p, BC_INST_POP);
|
|
}
|
|
else s = bc_parse_posixErr(p, BC_ERROR_POSIX_FOR3);
|
|
|
|
if (s) return s;
|
|
|
|
if (p->l.t != BC_LEX_RPAREN) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
bc_parse_push(p, BC_INST_JUMP);
|
|
bc_parse_pushIndex(p, cond_idx);
|
|
bc_parse_createLabel(p, p->func->code.len);
|
|
|
|
bc_parse_createExitLabel(p, exit_idx, 1);
|
|
s = bc_lex_next(&p->l);
|
|
if (!s) bc_parse_startBody(p, BC_PARSE_FLAG_LOOP | BC_PARSE_FLAG_LOOP_INNER);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type) {
|
|
|
|
size_t i;
|
|
BcInstPtr *ip;
|
|
|
|
if (!BC_PARSE_LOOP(p)) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
if (type == BC_LEX_KEY_BREAK) {
|
|
|
|
if (!p->exits.len) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
i = p->exits.len - 1;
|
|
ip = bc_vec_item(&p->exits, i);
|
|
|
|
while (!ip->func && i < p->exits.len) ip = bc_vec_item(&p->exits, i--);
|
|
if (i >= p->exits.len && !ip->func)
|
|
return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
i = ip->idx;
|
|
}
|
|
else i = *((size_t*) bc_vec_top(&p->conds));
|
|
|
|
bc_parse_push(p, BC_INST_JUMP);
|
|
bc_parse_pushIndex(p, i);
|
|
|
|
return bc_lex_next(&p->l);
|
|
}
|
|
|
|
static BcStatus bc_parse_func(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
int comma = 0, voidfn;
|
|
uint16_t flags;
|
|
char *name;
|
|
size_t idx;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
if (p->l.t != BC_LEX_NAME) return bc_parse_err(p, BC_ERROR_PARSE_FUNC);
|
|
|
|
voidfn = (!FLAG(s) && !FLAG(w) && p->l.t == BC_LEX_NAME &&
|
|
!strcmp(p->l.str.v, "void"));
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
voidfn = (voidfn && p->l.t == BC_LEX_NAME);
|
|
|
|
if (voidfn) {
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
}
|
|
|
|
if (p->l.t != BC_LEX_LPAREN) return bc_parse_err(p, BC_ERROR_PARSE_FUNC);
|
|
|
|
name = xstrdup(p->l.str.v);
|
|
idx = bc_program_insertFunc(p->prog, name);
|
|
bc_parse_updateFunc(p, idx);
|
|
p->func->voidfn = voidfn;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
while (p->l.t != BC_LEX_RPAREN) {
|
|
|
|
BcType t = BC_TYPE_VAR;
|
|
|
|
if (p->l.t != BC_LEX_NAME) return bc_parse_err(p, BC_ERROR_PARSE_FUNC);
|
|
|
|
++p->func->nparams;
|
|
|
|
name = xstrdup(p->l.str.v);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t == BC_LEX_LBRACKET) {
|
|
|
|
if (t == BC_TYPE_VAR) t = BC_TYPE_ARRAY;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t != BC_LEX_RBRACKET) {
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_FUNC);
|
|
goto err;
|
|
}
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
}
|
|
|
|
comma = p->l.t == BC_LEX_COMMA;
|
|
if (comma) {
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
}
|
|
|
|
s = bc_func_insert(p->func, name, t, p->l.line);
|
|
if (s) goto err;
|
|
}
|
|
|
|
if (comma) return bc_parse_err(p, BC_ERROR_PARSE_FUNC);
|
|
|
|
flags = BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_FUNC_INNER | BC_PARSE_FLAG_BODY;
|
|
bc_parse_startBody(p, flags);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
if (p->l.t != BC_LEX_LBRACE) s = bc_parse_posixErr(p, BC_ERROR_POSIX_BRACE);
|
|
|
|
return s;
|
|
|
|
err:
|
|
free(name);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_auto(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
int comma, one;
|
|
char *name;
|
|
|
|
if (!p->auto_part) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) return s;
|
|
|
|
p->auto_part = comma = 0;
|
|
one = p->l.t == BC_LEX_NAME;
|
|
|
|
while (p->l.t == BC_LEX_NAME) {
|
|
|
|
BcType t;
|
|
|
|
name = xstrdup(p->l.str.v);
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t == BC_LEX_LBRACKET) {
|
|
|
|
t = BC_TYPE_ARRAY;
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
|
|
if (p->l.t != BC_LEX_RBRACKET) {
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_FUNC);
|
|
goto err;
|
|
}
|
|
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
}
|
|
else t = BC_TYPE_VAR;
|
|
|
|
comma = p->l.t == BC_LEX_COMMA;
|
|
if (comma) {
|
|
s = bc_lex_next(&p->l);
|
|
if (s) goto err;
|
|
}
|
|
|
|
s = bc_func_insert(p->func, name, t, p->l.line);
|
|
if (s) goto err;
|
|
}
|
|
|
|
if (comma) return bc_parse_err(p, BC_ERROR_PARSE_FUNC);
|
|
if (!one) return bc_parse_err(p, BC_ERROR_PARSE_NO_AUTO);
|
|
if (!bc_parse_isDelimiter(p)) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
return s;
|
|
|
|
err:
|
|
free(name);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_body(BcParse *p, int brace) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
uint16_t *flag_ptr = BC_PARSE_TOP_FLAG_PTR(p);
|
|
|
|
*flag_ptr &= ~(BC_PARSE_FLAG_BODY);
|
|
|
|
if (*flag_ptr & BC_PARSE_FLAG_FUNC_INNER) {
|
|
|
|
if (!brace) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
|
|
p->auto_part = p->l.t != BC_LEX_KEY_AUTO;
|
|
|
|
if (!p->auto_part) {
|
|
|
|
// Make sure this is 1 to not get a parse error.
|
|
p->auto_part = 1;
|
|
|
|
s = bc_parse_auto(p);
|
|
if (s) return s;
|
|
}
|
|
|
|
if (p->l.t == BC_LEX_NLINE) s = bc_lex_next(&p->l);
|
|
}
|
|
else {
|
|
size_t len = p->flags.len;
|
|
s = bc_parse_stmt(p);
|
|
if (!s && !brace && !BC_PARSE_BODY(p) && len <= p->flags.len)
|
|
s = bc_parse_endBody(p, 0);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_stmt(BcParse *p) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
size_t len;
|
|
uint16_t flags;
|
|
BcLexType type = p->l.t;
|
|
|
|
if (type == BC_LEX_NLINE) return bc_lex_next(&p->l);
|
|
if (type == BC_LEX_KEY_AUTO) return bc_parse_auto(p);
|
|
|
|
p->auto_part = 0;
|
|
|
|
if (type != BC_LEX_KEY_ELSE) {
|
|
|
|
if (BC_PARSE_IF_END(p)) {
|
|
bc_parse_noElse(p);
|
|
if (p->flags.len > 1 && !BC_PARSE_BRACE(p))
|
|
s = bc_parse_endBody(p, 0);
|
|
return s;
|
|
}
|
|
else if (type == BC_LEX_LBRACE) {
|
|
|
|
if (!BC_PARSE_BODY(p)) {
|
|
bc_parse_startBody(p, BC_PARSE_FLAG_BRACE);
|
|
s = bc_lex_next(&p->l);
|
|
}
|
|
else {
|
|
*(BC_PARSE_TOP_FLAG_PTR(p)) |= BC_PARSE_FLAG_BRACE;
|
|
s = bc_lex_next(&p->l);
|
|
if (!s) s = bc_parse_body(p, 1);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
else if (BC_PARSE_BODY(p) && !BC_PARSE_BRACE(p))
|
|
return bc_parse_body(p, 0);
|
|
}
|
|
|
|
len = p->flags.len;
|
|
flags = BC_PARSE_TOP_FLAG(p);
|
|
|
|
switch (type) {
|
|
|
|
case BC_LEX_OP_INC:
|
|
case BC_LEX_OP_DEC:
|
|
case BC_LEX_OP_MINUS:
|
|
case BC_LEX_OP_BOOL_NOT:
|
|
case BC_LEX_LPAREN:
|
|
case BC_LEX_NAME:
|
|
case BC_LEX_NUMBER:
|
|
case BC_LEX_KEY_IBASE:
|
|
case BC_LEX_KEY_LAST:
|
|
case BC_LEX_KEY_LENGTH:
|
|
case BC_LEX_KEY_OBASE:
|
|
case BC_LEX_KEY_READ:
|
|
case BC_LEX_KEY_SCALE:
|
|
case BC_LEX_KEY_SQRT:
|
|
case BC_LEX_KEY_ABS:
|
|
{
|
|
s = bc_parse_expr_status(p, BC_PARSE_PRINT, bc_parse_next_expr);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_ELSE:
|
|
{
|
|
s = bc_parse_else(p);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_SCOLON:
|
|
{
|
|
// Do nothing.
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_RBRACE:
|
|
{
|
|
s = bc_parse_endBody(p, 1);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_STR:
|
|
{
|
|
s = bc_parse_str(p, BC_INST_PRINT_STR);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_BREAK:
|
|
case BC_LEX_KEY_CONTINUE:
|
|
{
|
|
s = bc_parse_loopExit(p, p->l.t);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_FOR:
|
|
{
|
|
s = bc_parse_for(p);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_HALT:
|
|
{
|
|
bc_parse_push(p, BC_INST_HALT);
|
|
s = bc_lex_next(&p->l);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_IF:
|
|
{
|
|
s = bc_parse_if(p);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_LIMITS:
|
|
{
|
|
printf("BC_BASE_MAX = %lu\n", BC_MAX_OBASE);
|
|
printf("BC_DIM_MAX = %lu\n", BC_MAX_DIM);
|
|
printf("BC_SCALE_MAX = %lu\n", BC_MAX_SCALE);
|
|
printf("BC_STRING_MAX = %lu\n", BC_MAX_STRING);
|
|
printf("BC_NAME_MAX = %lu\n", BC_MAX_NAME);
|
|
printf("BC_NUM_MAX = %lu\n", BC_MAX_NUM);
|
|
printf("MAX Exponent = %lu\n", BC_MAX_EXP);
|
|
printf("Number of vars = %lu\n", BC_MAX_VARS);
|
|
|
|
s = bc_lex_next(&p->l);
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_PRINT:
|
|
{
|
|
s = bc_parse_print(p);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_QUIT:
|
|
{
|
|
// Quit is a compile-time command. We don't exit directly,
|
|
// so the vm can clean up. Limits do the same thing.
|
|
s = BC_STATUS_QUIT;
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_RETURN:
|
|
{
|
|
s = bc_parse_return(p);
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_WHILE:
|
|
{
|
|
s = bc_parse_while(p);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!s && len == p->flags.len && flags == BC_PARSE_TOP_FLAG(p)) {
|
|
if (!bc_parse_isDelimiter(p)) s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
}
|
|
|
|
// Make sure semicolons are eaten.
|
|
while (!s && p->l.t == BC_LEX_SCOLON) s = bc_lex_next(&p->l);
|
|
|
|
return s;
|
|
}
|
|
|
|
BcStatus bc_parse_parse(BcParse *p) {
|
|
|
|
BcStatus s;
|
|
|
|
if (p->l.t == BC_LEX_EOF) s = bc_parse_err(p, BC_ERROR_PARSE_EOF);
|
|
else if (p->l.t == BC_LEX_KEY_DEFINE) {
|
|
if (BC_PARSE_NO_EXEC(p)) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
s = bc_parse_func(p);
|
|
}
|
|
else s = bc_parse_stmt(p);
|
|
|
|
if ((s && s != BC_STATUS_QUIT) || TT.sig) s = bc_parse_reset(p, s);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_parse_expr_err(BcParse *p, uint8_t flags, BcParseNext next) {
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcInst prev = BC_INST_PRINT;
|
|
BcLexType top, t = p->l.t;
|
|
size_t nexprs = 0, ops_bgn = p->ops.len;
|
|
uint32_t i, nparens, nrelops;
|
|
int pfirst, rprn, done, get_token, assign, bin_last, incdec;
|
|
char valid[] = {0xfc, 0xff, 0xff, 0x67, 0xc0, 0x00, 0x7c, 0x0b};
|
|
|
|
pfirst = p->l.t == BC_LEX_LPAREN;
|
|
nparens = nrelops = 0;
|
|
rprn = done = get_token = assign = incdec = 0;
|
|
bin_last = 1;
|
|
|
|
// We want to eat newlines if newlines are not a valid ending token.
|
|
// This is for spacing in things like for loop headers.
|
|
while (!s && (t = p->l.t) == BC_LEX_NLINE) s = bc_lex_next(&p->l);
|
|
|
|
// Loop checking if token is valid in this expression
|
|
for (; !TT.sig && !s && !done && (valid[t>>3] & (1<<(t&7))); t = p->l.t) {
|
|
|
|
switch (t) {
|
|
|
|
case BC_LEX_OP_INC:
|
|
case BC_LEX_OP_DEC:
|
|
{
|
|
if (incdec) return bc_parse_err(p, BC_ERROR_PARSE_ASSIGN);
|
|
s = bc_parse_incdec(p, &prev, &nexprs, flags);
|
|
rprn = get_token = bin_last = 0;
|
|
incdec = 1;
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_OP_MINUS:
|
|
{
|
|
s = bc_parse_minus(p, &prev, ops_bgn, rprn, bin_last, &nexprs);
|
|
rprn = get_token = 0;
|
|
bin_last = (prev == BC_INST_MINUS);
|
|
if (bin_last) incdec = 0;
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_OP_ASSIGN_POWER:
|
|
case BC_LEX_OP_ASSIGN_MULTIPLY:
|
|
case BC_LEX_OP_ASSIGN_DIVIDE:
|
|
case BC_LEX_OP_ASSIGN_MODULUS:
|
|
case BC_LEX_OP_ASSIGN_PLUS:
|
|
case BC_LEX_OP_ASSIGN_MINUS:
|
|
case BC_LEX_OP_ASSIGN:
|
|
{
|
|
if (!BC_PARSE_INST_VAR(prev)) {
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_ASSIGN);
|
|
break;
|
|
}
|
|
}
|
|
// Fallthrough.
|
|
case BC_LEX_OP_POWER:
|
|
case BC_LEX_OP_MULTIPLY:
|
|
case BC_LEX_OP_DIVIDE:
|
|
case BC_LEX_OP_MODULUS:
|
|
case BC_LEX_OP_PLUS:
|
|
case BC_LEX_OP_REL_EQ:
|
|
case BC_LEX_OP_REL_LE:
|
|
case BC_LEX_OP_REL_GE:
|
|
case BC_LEX_OP_REL_NE:
|
|
case BC_LEX_OP_REL_LT:
|
|
case BC_LEX_OP_REL_GT:
|
|
case BC_LEX_OP_BOOL_NOT:
|
|
case BC_LEX_OP_BOOL_OR:
|
|
case BC_LEX_OP_BOOL_AND:
|
|
{
|
|
if (BC_PARSE_OP_PREFIX(t)) {
|
|
if (!bin_last && !BC_PARSE_OP_PREFIX(p->l.last))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
}
|
|
else if (BC_PARSE_PREV_PREFIX(prev) || bin_last)
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
nrelops += (t >= BC_LEX_OP_REL_EQ && t <= BC_LEX_OP_REL_GT);
|
|
prev = BC_PARSE_TOKEN_INST(t);
|
|
bc_parse_operator(p, t, ops_bgn, &nexprs);
|
|
rprn = incdec = 0;
|
|
get_token = 1;
|
|
bin_last = !BC_PARSE_OP_PREFIX(t);
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_LPAREN:
|
|
{
|
|
if (BC_PARSE_LEAF(prev, bin_last, rprn))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
++nparens;
|
|
rprn = incdec = 0;
|
|
get_token = 1;
|
|
bc_vec_push(&p->ops, &t);
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_RPAREN:
|
|
{
|
|
// This needs to be a status. The error
|
|
// is handled in bc_parse_expr_status().
|
|
if (p->l.last == BC_LEX_LPAREN) return BC_STATUS_EMPTY_EXPR;
|
|
|
|
if (bin_last || BC_PARSE_PREV_PREFIX(prev))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
if (!nparens) {
|
|
s = BC_STATUS_SUCCESS;
|
|
done = 1;
|
|
get_token = 0;
|
|
break;
|
|
}
|
|
|
|
--nparens;
|
|
rprn = 1;
|
|
get_token = bin_last = incdec = 0;
|
|
|
|
s = bc_parse_rightParen(p, ops_bgn, &nexprs);
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_NAME:
|
|
{
|
|
if (BC_PARSE_LEAF(prev, bin_last, rprn))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
get_token = bin_last = 0;
|
|
s = bc_parse_name(p, &prev, flags & ~BC_PARSE_NOCALL);
|
|
rprn = (prev == BC_INST_CALL);
|
|
++nexprs;
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_NUMBER:
|
|
{
|
|
if (BC_PARSE_LEAF(prev, bin_last, rprn))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
bc_parse_number(p);
|
|
nexprs += 1;
|
|
prev = BC_INST_NUM;
|
|
get_token = 1;
|
|
rprn = bin_last = 0;
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_IBASE:
|
|
case BC_LEX_KEY_LAST:
|
|
case BC_LEX_KEY_OBASE:
|
|
{
|
|
if (BC_PARSE_LEAF(prev, bin_last, rprn))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
prev = (uchar) (t - BC_LEX_KEY_LAST + BC_INST_LAST);
|
|
bc_parse_push(p, (uchar) prev);
|
|
|
|
get_token = 1;
|
|
rprn = bin_last = 0;
|
|
++nexprs;
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_LENGTH:
|
|
case BC_LEX_KEY_SQRT:
|
|
case BC_LEX_KEY_ABS:
|
|
{
|
|
if (BC_PARSE_LEAF(prev, bin_last, rprn))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
s = bc_parse_builtin(p, t, flags, &prev);
|
|
rprn = get_token = bin_last = incdec = 0;
|
|
++nexprs;
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_READ:
|
|
{
|
|
if (BC_PARSE_LEAF(prev, bin_last, rprn))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
else if (flags & BC_PARSE_NOREAD)
|
|
s = bc_parse_err(p, BC_ERROR_EXEC_REC_READ);
|
|
else s = bc_parse_read(p);
|
|
|
|
rprn = get_token = bin_last = incdec = 0;
|
|
++nexprs;
|
|
prev = BC_INST_READ;
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_LEX_KEY_SCALE:
|
|
{
|
|
if (BC_PARSE_LEAF(prev, bin_last, rprn))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
s = bc_parse_scale(p, &prev, flags);
|
|
rprn = get_token = bin_last = 0;
|
|
++nexprs;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
s = bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!s && get_token) s = bc_lex_next(&p->l);
|
|
}
|
|
|
|
if (s) return s;
|
|
if (TT.sig) return BC_STATUS_SIGNAL;
|
|
|
|
while (p->ops.len > ops_bgn) {
|
|
|
|
top = BC_PARSE_TOP_OP(p);
|
|
assign = top >= BC_LEX_OP_ASSIGN_POWER && top <= BC_LEX_OP_ASSIGN;
|
|
|
|
if (top == BC_LEX_LPAREN || top == BC_LEX_RPAREN)
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
bc_parse_push(p, BC_PARSE_TOKEN_INST(top));
|
|
|
|
nexprs -= !BC_PARSE_OP_PREFIX(top);
|
|
bc_vec_pop(&p->ops);
|
|
}
|
|
|
|
if (nexprs != 1) return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
for (i = 0; i < next.len && t != next.tokens[i]; ++i);
|
|
if (i == next.len && !bc_parse_isDelimiter(p))
|
|
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
|
|
|
|
if (!(flags & BC_PARSE_REL) && nrelops) {
|
|
s = bc_parse_posixErr(p, BC_ERROR_POSIX_REL_POS);
|
|
if (s) return s;
|
|
}
|
|
else if ((flags & BC_PARSE_REL) && nrelops > 1) {
|
|
s = bc_parse_posixErr(p, BC_ERROR_POSIX_MULTIREL);
|
|
if (s) return s;
|
|
}
|
|
|
|
if (flags & BC_PARSE_PRINT) {
|
|
if (pfirst || !assign) bc_parse_push(p, BC_INST_PRINT);
|
|
bc_parse_push(p, BC_INST_POP);
|
|
}
|
|
|
|
// We want to eat newlines if newlines are not a valid ending token.
|
|
// This is for spacing in things like for loop headers.
|
|
for (incdec = 1, i = 0; i < next.len && incdec; ++i)
|
|
incdec = (next.tokens[i] != BC_LEX_NLINE);
|
|
if (incdec) {
|
|
while (!s && p->l.t == BC_LEX_NLINE) s = bc_lex_next(&p->l);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
BcStatus bc_parse_expr_status(BcParse *p, uint8_t flags, BcParseNext next) {
|
|
|
|
BcStatus s = bc_parse_expr_err(p, flags, next);
|
|
|
|
if (s == BC_STATUS_EMPTY_EXPR) s = bc_parse_err(p, BC_ERROR_PARSE_EMPTY_EXPR);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_type_num(BcResult *r, BcNum *n) {
|
|
if (!BC_PROG_NUM(r, n)) return bc_vm_err(BC_ERROR_EXEC_TYPE);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_program_type_match(BcResult *r, BcType t) {
|
|
if ((r->t != BC_RESULT_ARRAY) != (!t)) return bc_vm_err(BC_ERROR_EXEC_TYPE);
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static char *bc_program_str(BcProgram *p, size_t idx, int str) {
|
|
|
|
BcFunc *f;
|
|
BcVec *v;
|
|
size_t i;
|
|
|
|
BcInstPtr *ip = bc_vec_item_rev(&p->stack, 0);
|
|
i = ip->func;
|
|
|
|
f = bc_vec_item(&p->fns, i);
|
|
v = str ? &f->strs : &f->consts;
|
|
|
|
return *((char**) bc_vec_item(v, idx));
|
|
}
|
|
|
|
static size_t bc_program_index(char *code, size_t *bgn) {
|
|
|
|
uchar amt = (uchar) code[(*bgn)++], i = 0;
|
|
size_t res = 0;
|
|
|
|
for (; i < amt; ++i, ++(*bgn)) {
|
|
size_t temp = ((size_t) ((int) (uchar) code[*bgn]) & UCHAR_MAX);
|
|
res |= (temp << (i * CHAR_BIT));
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static char *bc_program_name(char *code, size_t *bgn) {
|
|
|
|
size_t i;
|
|
uchar c;
|
|
char *s;
|
|
char *str = code + *bgn, *ptr = strchr(str, UCHAR_MAX);
|
|
|
|
s = xmalloc(((unsigned long) ptr) - ((unsigned long) str) + 1);
|
|
|
|
for (i = 0; (c = (uchar) code[(*bgn)++]) && c != UCHAR_MAX; ++i)
|
|
s[i] = (char) c;
|
|
|
|
s[i] = '\0';
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcVec* bc_program_search(BcProgram *p, char *id, BcType type) {
|
|
|
|
struct str_len e, *ptr;
|
|
BcVec *v, *map;
|
|
size_t i;
|
|
BcResultData data;
|
|
int new, var = (type == BC_TYPE_VAR);
|
|
|
|
v = var ? &p->vars : &p->arrs;
|
|
map = var ? &p->var_map : &p->arr_map;
|
|
|
|
e.str = id;
|
|
e.len = v->len;
|
|
new = bc_map_insert(map, &e, &i);
|
|
|
|
if (new) {
|
|
bc_array_init(&data.v, var);
|
|
bc_vec_push(v, &data.v);
|
|
}
|
|
|
|
ptr = bc_vec_item(map, i);
|
|
if (new) ptr->str = xstrdup(e.str);
|
|
|
|
return bc_vec_item(v, ptr->len);
|
|
}
|
|
|
|
static BcStatus bc_program_num(BcProgram *p, BcResult *r, BcNum **num) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcNum *n = &r->d.n;
|
|
|
|
switch (r->t) {
|
|
|
|
case BC_RESULT_CONSTANT:
|
|
{
|
|
char *str = bc_program_str(p, r->d.id.len, 0);
|
|
size_t len = strlen(str);
|
|
|
|
bc_num_init(n, len);
|
|
|
|
s = bc_num_parse(n, str, &p->ib, p->ib_t, len == 1);
|
|
|
|
if (s) {
|
|
bc_num_free(n);
|
|
return s;
|
|
}
|
|
|
|
r->t = BC_RESULT_TEMP;
|
|
}
|
|
// Fallthrough.
|
|
case BC_RESULT_STR:
|
|
case BC_RESULT_TEMP:
|
|
case BC_RESULT_IBASE:
|
|
case BC_RESULT_SCALE:
|
|
case BC_RESULT_OBASE:
|
|
{
|
|
*num = n;
|
|
break;
|
|
}
|
|
|
|
case BC_RESULT_VAR:
|
|
case BC_RESULT_ARRAY:
|
|
case BC_RESULT_ARRAY_ELEM:
|
|
{
|
|
BcVec *v;
|
|
BcType type = (r->t == BC_RESULT_VAR) ? BC_TYPE_VAR : BC_TYPE_ARRAY;
|
|
|
|
v = bc_program_search(p, r->d.id.str, type);
|
|
|
|
if (r->t == BC_RESULT_ARRAY_ELEM) {
|
|
|
|
size_t idx = r->d.id.len;
|
|
|
|
v = bc_vec_top(v);
|
|
|
|
if (v->len <= idx) bc_array_expand(v, idx + 1);
|
|
*num = bc_vec_item(v, idx);
|
|
}
|
|
else *num = bc_vec_top(v);
|
|
|
|
break;
|
|
}
|
|
|
|
case BC_RESULT_LAST:
|
|
{
|
|
*num = &p->last;
|
|
break;
|
|
}
|
|
|
|
case BC_RESULT_ONE:
|
|
{
|
|
*num = &p->one;
|
|
break;
|
|
}
|
|
|
|
case BC_RESULT_VOID:
|
|
{
|
|
s = bc_vm_err(BC_ERROR_EXEC_VOID_VAL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_operand(BcProgram *p, BcResult **r,
|
|
BcNum **n, size_t idx)
|
|
{
|
|
|
|
*r = bc_vec_item_rev(&p->results, idx);
|
|
|
|
return bc_program_num(p, *r, n);
|
|
}
|
|
|
|
static BcStatus bc_program_binPrep(BcProgram *p, BcResult **l, BcNum **ln,
|
|
BcResult **r, BcNum **rn)
|
|
{
|
|
BcStatus s;
|
|
BcResultType lt;
|
|
|
|
s = bc_program_operand(p, l, ln, 1);
|
|
if (s) return s;
|
|
s = bc_program_operand(p, r, rn, 0);
|
|
if (s) return s;
|
|
|
|
lt = (*l)->t;
|
|
|
|
// We run this again under these conditions in case any vector has been
|
|
// reallocated out from under the BcNums or arrays we had.
|
|
if (lt == (*r)->t && (lt == BC_RESULT_VAR || lt == BC_RESULT_ARRAY_ELEM))
|
|
s = bc_program_num(p, *l, ln);
|
|
|
|
if (lt == BC_RESULT_STR) return bc_vm_err(BC_ERROR_EXEC_TYPE);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_binOpPrep(BcProgram *p, BcResult **l, BcNum **ln,
|
|
BcResult **r, BcNum **rn)
|
|
{
|
|
BcStatus s;
|
|
|
|
s = bc_program_binPrep(p, l, ln, r, rn);
|
|
if (s) return s;
|
|
|
|
s = bc_program_type_num(*l, *ln);
|
|
if (s) return s;
|
|
|
|
return bc_program_type_num(*r, *rn);
|
|
}
|
|
|
|
static BcStatus bc_program_assignPrep(BcProgram *p, BcResult **l, BcNum **ln,
|
|
BcResult **r, BcNum **rn)
|
|
{
|
|
BcStatus s;
|
|
int good = 0;
|
|
BcResultType lt;
|
|
|
|
s = bc_program_binPrep(p, l, ln, r, rn);
|
|
if (s) return s;
|
|
|
|
lt = (*l)->t;
|
|
|
|
if (lt == BC_RESULT_CONSTANT || lt == BC_RESULT_TEMP ||lt == BC_RESULT_ARRAY)
|
|
return bc_vm_err(BC_ERROR_EXEC_TYPE);
|
|
|
|
if (lt == BC_RESULT_ONE) return bc_vm_err(BC_ERROR_EXEC_TYPE);
|
|
|
|
if (!good) s = bc_program_type_num(*r, *rn);
|
|
|
|
return s;
|
|
}
|
|
|
|
static void bc_program_binOpRetire(BcProgram *p, BcResult *r) {
|
|
r->t = BC_RESULT_TEMP;
|
|
bc_vec_pop(&p->results);
|
|
bc_vec_pop(&p->results);
|
|
bc_vec_push(&p->results, r);
|
|
}
|
|
|
|
static BcStatus bc_program_prep(BcProgram *p, BcResult **r, BcNum **n) {
|
|
|
|
BcStatus s;
|
|
|
|
s = bc_program_operand(p, r, n, 0);
|
|
if (s) return s;
|
|
|
|
return bc_program_type_num(*r, *n);
|
|
}
|
|
|
|
static void bc_program_retire(BcProgram *p, BcResult *r, BcResultType t) {
|
|
r->t = t;
|
|
bc_vec_pop(&p->results);
|
|
bc_vec_push(&p->results, r);
|
|
}
|
|
|
|
static BcStatus bc_program_op(BcProgram *p, uchar inst) {
|
|
|
|
BcStatus s;
|
|
BcResult *opd1, *opd2, res;
|
|
BcNum *n1 = NULL, *n2 = NULL;
|
|
size_t idx = inst - BC_INST_POWER;
|
|
|
|
s = bc_program_binOpPrep(p, &opd1, &n1, &opd2, &n2);
|
|
if (s) return s;
|
|
bc_num_init(&res.d.n, bc_program_opReqs[idx](n1, n2, p->scale));
|
|
|
|
s = bc_program_ops[idx](n1, n2, &res.d.n, p->scale);
|
|
if (s) goto err;
|
|
bc_program_binOpRetire(p, &res);
|
|
|
|
return s;
|
|
|
|
err:
|
|
bc_num_free(&res.d.n);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_read(BcProgram *p) {
|
|
|
|
BcStatus s;
|
|
BcParse parse;
|
|
BcVec buf;
|
|
BcInstPtr ip;
|
|
size_t i;
|
|
char *file;
|
|
BcFunc *f = bc_vec_item(&p->fns, BC_PROG_READ);
|
|
|
|
for (i = 0; i < p->stack.len; ++i) {
|
|
BcInstPtr *ip_ptr = bc_vec_item(&p->stack, i);
|
|
if (ip_ptr->func == BC_PROG_READ)
|
|
return bc_vm_err(BC_ERROR_EXEC_REC_READ);
|
|
}
|
|
|
|
file = TT.file;
|
|
bc_lex_file(&parse.l, bc_program_stdin_name);
|
|
bc_vec_npop(&f->code, f->code.len);
|
|
bc_vec_init(&buf, sizeof(char), NULL);
|
|
|
|
s = bc_read_line(&buf, "read> ");
|
|
if (s) {
|
|
if (s == BC_STATUS_EOF) s = bc_vm_err(BC_ERROR_EXEC_READ_EXPR);
|
|
goto io_err;
|
|
}
|
|
|
|
bc_parse_init(&parse, p, BC_PROG_READ);
|
|
|
|
s = bc_parse_text(&parse, buf.v);
|
|
if (s) goto exec_err;
|
|
s = bc_parse_expr_status(&parse, BC_PARSE_NOREAD, bc_parse_next_read);
|
|
if (s) goto exec_err;
|
|
|
|
if (parse.l.t != BC_LEX_NLINE && parse.l.t != BC_LEX_EOF) {
|
|
s = bc_vm_err(BC_ERROR_EXEC_READ_EXPR);
|
|
goto exec_err;
|
|
}
|
|
|
|
ip.func = BC_PROG_READ;
|
|
ip.idx = 0;
|
|
ip.len = p->results.len;
|
|
|
|
// Update this pointer, just in case.
|
|
f = bc_vec_item(&p->fns, BC_PROG_READ);
|
|
|
|
bc_vec_pushByte(&f->code, BC_INST_RET);
|
|
bc_vec_push(&p->stack, &ip);
|
|
|
|
exec_err:
|
|
bc_parse_free(&parse);
|
|
io_err:
|
|
bc_vec_free(&buf);
|
|
TT.file = file;
|
|
return s;
|
|
}
|
|
|
|
static void bc_program_printChars(char *str) {
|
|
char *nl;
|
|
TT.nchars += printf("%s", str);
|
|
nl = strrchr(str, '\n');
|
|
if (nl) TT.nchars = strlen(nl + 1);
|
|
}
|
|
|
|
// Output, substituting escape sequences, see also unescape() in lib/
|
|
static void bc_program_printString(char *str)
|
|
{
|
|
int i, c, idx;
|
|
|
|
for (i = 0; str[i]; ++i, ++TT.nchars) {
|
|
if ((c = str[i]) == '\\' && str[i+1]) {
|
|
if ((idx = stridx("ab\\efnqrt", c = str[i+1])) >= 0) {
|
|
if (c == 'n') TT.nchars = SIZE_MAX;
|
|
c = "\a\b\\\\\f\n\"\r\t"[idx];
|
|
}
|
|
else putchar('\\');
|
|
i++;
|
|
}
|
|
|
|
putchar(c);
|
|
}
|
|
}
|
|
|
|
static BcStatus bc_program_print(BcProgram *p, uchar inst, size_t idx) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcResult *r;
|
|
char *str;
|
|
BcNum *n = NULL;
|
|
int pop = inst != BC_INST_PRINT;
|
|
|
|
r = bc_vec_item_rev(&p->results, idx);
|
|
|
|
if (r->t == BC_RESULT_VOID) {
|
|
if (pop) return bc_vm_err(BC_ERROR_EXEC_VOID_VAL);
|
|
return s;
|
|
}
|
|
|
|
s = bc_program_num(p, r, &n);
|
|
if (s) return s;
|
|
|
|
if (BC_PROG_NUM(r, n)) {
|
|
bc_num_printNewline();
|
|
|
|
if (!n->len) bc_num_printHex(0, 1, 0);
|
|
else if (p->ob_t == 10) bc_num_printDecimal(n);
|
|
else s = bc_num_printBase(n, &p->ob, p->ob_t);
|
|
|
|
if (!s && !pop) {
|
|
putchar('\n');
|
|
TT.nchars = 0;
|
|
}
|
|
if (!s) bc_num_copy(&p->last, n);
|
|
} else {
|
|
|
|
size_t i = (r->t == BC_RESULT_STR) ? r->d.id.len : n->rdx;
|
|
|
|
str = bc_program_str(p, i, 1);
|
|
|
|
if (inst == BC_INST_PRINT_STR) bc_program_printChars(str);
|
|
else {
|
|
bc_program_printString(str);
|
|
if (inst == BC_INST_PRINT) {
|
|
putchar('\n');
|
|
TT.nchars = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!s && pop) bc_vec_pop(&p->results);
|
|
|
|
return s;
|
|
}
|
|
|
|
void bc_program_negate(BcResult *r, BcNum *n) {
|
|
BcNum *rn = &r->d.n;
|
|
bc_num_copy(rn, n);
|
|
if (rn->len) rn->neg = !rn->neg;
|
|
}
|
|
|
|
void bc_program_not(BcResult *r, BcNum *n) {
|
|
if (!BC_NUM_CMP_ZERO(n)) bc_num_one(&r->d.n);
|
|
}
|
|
|
|
static BcStatus bc_program_unary(BcProgram *p, uchar inst) {
|
|
|
|
BcStatus s;
|
|
BcResult res, *ptr;
|
|
BcNum *num = NULL;
|
|
|
|
s = bc_program_prep(p, &ptr, &num);
|
|
if (s) return s;
|
|
|
|
bc_num_init(&res.d.n, num->len);
|
|
bc_program_unarys[inst - BC_INST_NEG](&res, num);
|
|
bc_program_retire(p, &res, BC_RESULT_TEMP);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_logical(BcProgram *p, uchar inst) {
|
|
|
|
BcStatus s;
|
|
BcResult *opd1, *opd2, res;
|
|
BcNum *n1 = NULL, *n2 = NULL;
|
|
int cond = 0;
|
|
ssize_t cmp;
|
|
|
|
s = bc_program_binOpPrep(p, &opd1, &n1, &opd2, &n2);
|
|
if (s) return s;
|
|
bc_num_init(&res.d.n, BC_NUM_DEF_SIZE);
|
|
|
|
if (inst == BC_INST_BOOL_AND)
|
|
cond = BC_NUM_CMP_ZERO(n1) && BC_NUM_CMP_ZERO(n2);
|
|
else if (inst == BC_INST_BOOL_OR)
|
|
cond = BC_NUM_CMP_ZERO(n1) || BC_NUM_CMP_ZERO(n2);
|
|
else {
|
|
|
|
cmp = bc_num_cmp(n1, n2);
|
|
|
|
switch (inst) {
|
|
|
|
case BC_INST_REL_EQ:
|
|
{
|
|
cond = cmp == 0;
|
|
break;
|
|
}
|
|
|
|
case BC_INST_REL_LE:
|
|
{
|
|
cond = cmp <= 0;
|
|
break;
|
|
}
|
|
|
|
case BC_INST_REL_GE:
|
|
{
|
|
cond = cmp >= 0;
|
|
break;
|
|
}
|
|
|
|
case BC_INST_REL_NE:
|
|
{
|
|
cond = cmp != 0;
|
|
break;
|
|
}
|
|
|
|
case BC_INST_REL_LT:
|
|
{
|
|
cond = cmp < 0;
|
|
break;
|
|
}
|
|
|
|
case BC_INST_REL_GT:
|
|
{
|
|
cond = cmp > 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cond) bc_num_one(&res.d.n);
|
|
|
|
bc_program_binOpRetire(p, &res);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_copyToVar(BcProgram *p, char *name,
|
|
BcType t, int last)
|
|
{
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcResult *ptr, r;
|
|
BcVec *vec;
|
|
BcNum *n = NULL;
|
|
int var = (t == BC_TYPE_VAR);
|
|
|
|
if (!last) {
|
|
|
|
ptr = bc_vec_top(&p->results);
|
|
|
|
if (ptr->t == BC_RESULT_VAR || ptr->t == BC_RESULT_ARRAY) {
|
|
BcVec *v = bc_program_search(p, ptr->d.id.str, t);
|
|
n = bc_vec_item_rev(v, 1);
|
|
}
|
|
else s = bc_program_num(p, ptr, &n);
|
|
}
|
|
else s = bc_program_operand(p, &ptr, &n, 0);
|
|
|
|
if (s) return s;
|
|
|
|
s = bc_program_type_match(ptr, t);
|
|
if (s) return s;
|
|
|
|
vec = bc_program_search(p, name, t);
|
|
|
|
// Do this once more to make sure that pointers were not invalidated.
|
|
vec = bc_program_search(p, name, t);
|
|
|
|
if (var) bc_num_createCopy(&r.d.n, n);
|
|
else {
|
|
bc_array_init(&r.d.v, 1);
|
|
bc_array_copy(&r.d.v, (BcVec *)n);
|
|
}
|
|
|
|
bc_vec_push(vec, &r.d);
|
|
bc_vec_pop(&p->results);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_assign(BcProgram *p, uchar inst) {
|
|
|
|
BcStatus s;
|
|
BcResult *left, *right, res;
|
|
BcNum *l = NULL, *r = NULL;
|
|
int ib, sc;
|
|
|
|
s = bc_program_assignPrep(p, &left, &l, &right, &r);
|
|
if (s) return s;
|
|
|
|
ib = (left->t == BC_RESULT_IBASE);
|
|
sc = (left->t == BC_RESULT_SCALE);
|
|
|
|
if (inst == BC_INST_ASSIGN) bc_num_copy(l, r);
|
|
else {
|
|
s = bc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, p->scale);
|
|
if (s) return s;
|
|
}
|
|
|
|
if (ib || sc || left->t == BC_RESULT_OBASE) {
|
|
|
|
size_t *ptr;
|
|
unsigned long val, max, min;
|
|
BcError e;
|
|
|
|
s = bc_num_ulong(l, &val);
|
|
if (s) return s;
|
|
e = left->t - BC_RESULT_IBASE + BC_ERROR_EXEC_IBASE;
|
|
|
|
if (sc) {
|
|
max = BC_MAX_SCALE;
|
|
min = 0;
|
|
ptr = &p->scale;
|
|
}
|
|
else {
|
|
max = ib ? TT.max_ibase : BC_MAX_OBASE;
|
|
min = 2;
|
|
ptr = ib ? &p->ib_t : &p->ob_t;
|
|
}
|
|
|
|
if (val > max || val < min) return bc_vm_verr(e, min, max);
|
|
if (!sc) bc_num_ulong2num(ib ? &p->ib : &p->ob, (unsigned long) val);
|
|
|
|
*ptr = (size_t) val;
|
|
s = BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
bc_num_createCopy(&res.d.n, l);
|
|
bc_program_binOpRetire(p, &res);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_pushVar(BcProgram *p, char *code, size_t *bgn) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcResult r;
|
|
char *name = bc_program_name(code, bgn);
|
|
|
|
r.t = BC_RESULT_VAR;
|
|
r.d.id.str = name;
|
|
|
|
bc_vec_push(&p->results, &r);
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_pushArray(BcProgram *p, char *code,
|
|
size_t *bgn, uchar inst)
|
|
{
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcResult r;
|
|
BcNum *num = NULL;
|
|
|
|
r.d.id.str = bc_program_name(code, bgn);
|
|
|
|
if (inst == BC_INST_ARRAY) {
|
|
r.t = BC_RESULT_ARRAY;
|
|
bc_vec_push(&p->results, &r);
|
|
}
|
|
else {
|
|
|
|
BcResult *operand;
|
|
unsigned long temp;
|
|
|
|
s = bc_program_prep(p, &operand, &num);
|
|
if (s) goto err;
|
|
s = bc_num_ulong(num, &temp);
|
|
if (s) goto err;
|
|
|
|
if (temp > BC_MAX_DIM) {
|
|
s = bc_vm_verr(BC_ERROR_EXEC_ARRAY_LEN, BC_MAX_DIM);
|
|
goto err;
|
|
}
|
|
|
|
r.d.id.len = temp;
|
|
bc_program_retire(p, &r, BC_RESULT_ARRAY_ELEM);
|
|
}
|
|
|
|
err:
|
|
if (s) free(r.d.id.str);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_incdec(BcProgram *p, uchar inst) {
|
|
|
|
BcStatus s;
|
|
BcResult *ptr, res, copy;
|
|
BcNum *num = NULL;
|
|
uchar inst2;
|
|
|
|
s = bc_program_prep(p, &ptr, &num);
|
|
if (s) return s;
|
|
|
|
if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) {
|
|
copy.t = BC_RESULT_TEMP;
|
|
bc_num_createCopy(©.d.n, num);
|
|
}
|
|
|
|
res.t = BC_RESULT_ONE;
|
|
inst2 = BC_INST_ASSIGN_PLUS + (inst & 0x01);
|
|
|
|
bc_vec_push(&p->results, &res);
|
|
bc_program_assign(p, inst2);
|
|
|
|
if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) {
|
|
bc_vec_pop(&p->results);
|
|
bc_vec_push(&p->results, ©);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_program_call(BcProgram *p, char *code,
|
|
size_t *idx)
|
|
{
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcInstPtr ip;
|
|
size_t i, nparams = bc_program_index(code, idx);
|
|
BcFunc *f;
|
|
BcVec *v;
|
|
struct str_len *a;
|
|
BcResultData param;
|
|
BcResult *arg;
|
|
|
|
ip.idx = 0;
|
|
ip.func = bc_program_index(code, idx);
|
|
f = bc_vec_item(&p->fns, ip.func);
|
|
|
|
if (!f->code.len) return bc_vm_verr(BC_ERROR_EXEC_UNDEF_FUNC, f->name);
|
|
if (nparams != f->nparams)
|
|
return bc_vm_verr(BC_ERROR_EXEC_PARAMS, f->nparams, nparams);
|
|
ip.len = p->results.len - nparams;
|
|
|
|
for (i = 0; i < nparams; ++i) {
|
|
|
|
size_t j;
|
|
int last = 1;
|
|
|
|
a = bc_vec_item(&f->autos, nparams - 1 - i);
|
|
arg = bc_vec_top(&p->results);
|
|
|
|
// If I have already pushed to a var, I need to make sure I
|
|
// get the previous version, not the already pushed one.
|
|
if (arg->t == BC_RESULT_VAR || arg->t == BC_RESULT_ARRAY) {
|
|
for (j = 0; j < i && last; ++j) {
|
|
struct str_len *id = bc_vec_item(&f->autos, nparams - 1 - j);
|
|
last = strcmp(arg->d.id.str, id->str) ||
|
|
(!id->len) != (arg->t == BC_RESULT_VAR);
|
|
}
|
|
}
|
|
|
|
s = bc_program_copyToVar(p, a->str, a->len, last);
|
|
if (s) return s;
|
|
}
|
|
|
|
for (; i < f->autos.len; ++i) {
|
|
|
|
a = bc_vec_item(&f->autos, i);
|
|
v = bc_program_search(p, a->str, a->len);
|
|
|
|
if (a->len == BC_TYPE_VAR) {
|
|
bc_num_init(¶m.n, BC_NUM_DEF_SIZE);
|
|
bc_vec_push(v, ¶m.n);
|
|
}
|
|
else {
|
|
bc_array_init(¶m.v, 1);
|
|
bc_vec_push(v, ¶m.v);
|
|
}
|
|
}
|
|
|
|
bc_vec_push(&p->stack, &ip);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_program_return(BcProgram *p, uchar inst) {
|
|
|
|
BcStatus s;
|
|
BcResult res;
|
|
BcFunc *f;
|
|
size_t i;
|
|
BcInstPtr *ip = bc_vec_top(&p->stack);
|
|
|
|
f = bc_vec_item(&p->fns, ip->func);
|
|
res.t = BC_RESULT_TEMP;
|
|
|
|
if (inst == BC_INST_RET) {
|
|
|
|
BcNum *num = NULL;
|
|
BcResult *operand;
|
|
|
|
s = bc_program_operand(p, &operand, &num, 0);
|
|
if (s) return s;
|
|
|
|
bc_num_createCopy(&res.d.n, num);
|
|
}
|
|
else if (inst == BC_INST_RET_VOID) res.t = BC_RESULT_VOID;
|
|
else bc_num_init(&res.d.n, BC_NUM_DEF_SIZE);
|
|
|
|
// We need to pop arguments as well, so this takes that into account.
|
|
for (i = 0; i < f->autos.len; ++i) {
|
|
|
|
BcVec *v;
|
|
struct str_len *a = bc_vec_item(&f->autos, i);
|
|
|
|
v = bc_program_search(p, a->str, a->len);
|
|
bc_vec_pop(v);
|
|
}
|
|
|
|
bc_vec_npop(&p->results, p->results.len - ip->len);
|
|
bc_vec_push(&p->results, &res);
|
|
bc_vec_pop(&p->stack);
|
|
|
|
return BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
unsigned long bc_program_scale(BcNum *n) {
|
|
return (unsigned long) n->rdx;
|
|
}
|
|
|
|
unsigned long bc_program_len(BcNum *n) {
|
|
|
|
unsigned long len = n->len;
|
|
size_t i;
|
|
|
|
if (n->rdx != n->len) return len;
|
|
for (i = n->len - 1; i < n->len && !n->num[i]; --len, --i);
|
|
|
|
return len;
|
|
}
|
|
|
|
static BcStatus bc_program_builtin(BcProgram *p, uchar inst) {
|
|
|
|
BcStatus s;
|
|
BcResult *opnd;
|
|
BcResult res;
|
|
BcNum *num = NULL, *resn = &res.d.n;
|
|
int len = (inst == BC_INST_LENGTH);
|
|
|
|
s = bc_program_operand(p, &opnd, &num, 0);
|
|
if (s) return s;
|
|
|
|
if (inst == BC_INST_SQRT) s = bc_num_sqrt(num, resn, p->scale);
|
|
else if (inst == BC_INST_ABS) {
|
|
bc_num_createCopy(resn, num);
|
|
resn->neg = 0;
|
|
}
|
|
else {
|
|
|
|
unsigned long val = 0;
|
|
|
|
if (len) {
|
|
if (opnd->t == BC_RESULT_ARRAY)
|
|
val = (unsigned long) ((BcVec*) num)->len;
|
|
else val = bc_program_len(num);
|
|
}
|
|
else val = bc_program_scale(num);
|
|
|
|
bc_num_createFromUlong(resn, val);
|
|
}
|
|
|
|
bc_program_retire(p, &res, BC_RESULT_TEMP);
|
|
|
|
return s;
|
|
}
|
|
|
|
static void bc_program_pushGlobal(BcProgram *p, uchar inst) {
|
|
|
|
BcResult res;
|
|
unsigned long val;
|
|
|
|
res.t = inst - BC_INST_IBASE + BC_RESULT_IBASE;
|
|
if (inst == BC_INST_IBASE) val = (unsigned long) p->ib_t;
|
|
else if (inst == BC_INST_SCALE) val = (unsigned long) p->scale;
|
|
else val = (unsigned long) p->ob_t;
|
|
|
|
bc_num_createFromUlong(&res.d.n, val);
|
|
bc_vec_push(&p->results, &res);
|
|
}
|
|
|
|
void bc_program_free(BcProgram *p) {
|
|
bc_vec_free(&p->fns);
|
|
bc_vec_free(&p->fn_map);
|
|
bc_vec_free(&p->vars);
|
|
bc_vec_free(&p->var_map);
|
|
bc_vec_free(&p->arrs);
|
|
bc_vec_free(&p->arr_map);
|
|
bc_vec_free(&p->results);
|
|
bc_vec_free(&p->stack);
|
|
bc_num_free(&p->last);
|
|
}
|
|
|
|
void bc_program_init(BcProgram *p) {
|
|
|
|
BcInstPtr ip;
|
|
|
|
memset(p, 0, sizeof(BcProgram));
|
|
memset(&ip, 0, sizeof(BcInstPtr));
|
|
|
|
bc_num_setup(&p->ib, p->ib_num, BC_NUM_LONG_LOG10);
|
|
bc_num_ten(&p->ib);
|
|
p->ib_t = 10;
|
|
|
|
bc_num_setup(&p->ob, p->ob_num, BC_NUM_LONG_LOG10);
|
|
bc_num_ten(&p->ob);
|
|
p->ob_t = 10;
|
|
|
|
bc_num_setup(&p->one, p->one_num, BC_PROG_ONE_CAP);
|
|
bc_num_one(&p->one);
|
|
bc_num_init(&p->last, BC_NUM_DEF_SIZE);
|
|
|
|
bc_vec_init(&p->fns, sizeof(BcFunc), bc_func_free);
|
|
bc_vec_init(&p->fn_map, sizeof(struct str_len), bc_id_free);
|
|
bc_program_insertFunc(p, xstrdup(bc_func_main));
|
|
bc_program_insertFunc(p, xstrdup(bc_func_read));
|
|
|
|
bc_vec_init(&p->vars, sizeof(BcVec), bc_vec_free);
|
|
bc_vec_init(&p->var_map, sizeof(struct str_len), bc_id_free);
|
|
|
|
bc_vec_init(&p->arrs, sizeof(BcVec), bc_vec_free);
|
|
bc_vec_init(&p->arr_map, sizeof(struct str_len), bc_id_free);
|
|
|
|
bc_vec_init(&p->results, sizeof(BcResult), bc_result_free);
|
|
bc_vec_init(&p->stack, sizeof(BcInstPtr), NULL);
|
|
bc_vec_push(&p->stack, &ip);
|
|
}
|
|
|
|
void bc_program_addFunc(BcProgram *p, BcFunc *f, char *name) {
|
|
bc_func_init(f, name);
|
|
bc_vec_push(&p->fns, f);
|
|
}
|
|
|
|
size_t bc_program_insertFunc(BcProgram *p, char *name) {
|
|
|
|
struct str_len id;
|
|
BcFunc f;
|
|
int new;
|
|
size_t idx;
|
|
|
|
id.str = name;
|
|
id.len = p->fns.len;
|
|
|
|
new = bc_map_insert(&p->fn_map, &id, &idx);
|
|
idx = ((struct ptr_len *)bc_vec_item(&p->fn_map, idx))->len;
|
|
|
|
if (!new) {
|
|
BcFunc *func = bc_vec_item(&p->fns, idx);
|
|
bc_func_reset(func);
|
|
free(name);
|
|
} else bc_program_addFunc(p, &f, name);
|
|
|
|
return idx;
|
|
}
|
|
|
|
BcStatus bc_program_reset(BcProgram *p, BcStatus s) {
|
|
|
|
BcFunc *f;
|
|
BcInstPtr *ip;
|
|
|
|
bc_vec_npop(&p->stack, p->stack.len - 1);
|
|
bc_vec_npop(&p->results, p->results.len);
|
|
|
|
f = bc_vec_item(&p->fns, 0);
|
|
ip = bc_vec_top(&p->stack);
|
|
ip->idx = f->code.len;
|
|
|
|
if (TT.sig == SIGTERM || TT.sig == SIGQUIT ||
|
|
(!s && TT.sig == SIGINT && FLAG(i))) return BC_STATUS_QUIT;
|
|
TT.sig = 0;
|
|
|
|
if (!s || s == BC_STATUS_SIGNAL) {
|
|
if (BC_TTYIN) {
|
|
fputs(bc_program_ready_msg, stderr);
|
|
fflush(stderr);
|
|
s = BC_STATUS_SUCCESS;
|
|
}
|
|
else s = BC_STATUS_QUIT;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
BcStatus bc_program_exec(BcProgram *p) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
size_t idx;
|
|
BcResult r, *ptr;
|
|
BcInstPtr *ip = bc_vec_top(&p->stack);
|
|
BcFunc *func = bc_vec_item(&p->fns, ip->func);
|
|
char *code = func->code.v;
|
|
int cond = 0;
|
|
BcNum *num;
|
|
|
|
while (!s && ip->idx < func->code.len) {
|
|
|
|
uchar inst = (uchar) code[(ip->idx)++];
|
|
|
|
switch (inst) {
|
|
|
|
case BC_INST_JUMP_ZERO:
|
|
{
|
|
s = bc_program_prep(p, &ptr, &num);
|
|
if (s) return s;
|
|
cond = !BC_NUM_CMP_ZERO(num);
|
|
bc_vec_pop(&p->results);
|
|
}
|
|
// Fallthrough.
|
|
case BC_INST_JUMP:
|
|
{
|
|
size_t *addr;
|
|
idx = bc_program_index(code, &ip->idx);
|
|
addr = bc_vec_item(&func->labels, idx);
|
|
if (inst == BC_INST_JUMP || cond) ip->idx = *addr;
|
|
break;
|
|
}
|
|
|
|
case BC_INST_CALL:
|
|
{
|
|
s = bc_program_call(p, code, &ip->idx);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_INC_PRE:
|
|
case BC_INST_DEC_PRE:
|
|
case BC_INST_INC_POST:
|
|
case BC_INST_DEC_POST:
|
|
{
|
|
s = bc_program_incdec(p, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_HALT:
|
|
{
|
|
s = BC_STATUS_QUIT;
|
|
break;
|
|
}
|
|
|
|
case BC_INST_RET:
|
|
case BC_INST_RET0:
|
|
case BC_INST_RET_VOID:
|
|
{
|
|
s = bc_program_return(p, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_LAST:
|
|
{
|
|
r.t = BC_RESULT_LAST;
|
|
bc_vec_push(&p->results, &r);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_BOOL_OR:
|
|
case BC_INST_BOOL_AND:
|
|
case BC_INST_REL_EQ:
|
|
case BC_INST_REL_LE:
|
|
case BC_INST_REL_GE:
|
|
case BC_INST_REL_NE:
|
|
case BC_INST_REL_LT:
|
|
case BC_INST_REL_GT:
|
|
{
|
|
s = bc_program_logical(p, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_READ:
|
|
{
|
|
s = bc_program_read(p);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_VAR:
|
|
{
|
|
s = bc_program_pushVar(p, code, &ip->idx);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_ARRAY_ELEM:
|
|
case BC_INST_ARRAY:
|
|
{
|
|
s = bc_program_pushArray(p, code, &ip->idx, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_IBASE:
|
|
case BC_INST_SCALE:
|
|
case BC_INST_OBASE:
|
|
{
|
|
bc_program_pushGlobal(p, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_LENGTH:
|
|
case BC_INST_SCALE_FUNC:
|
|
case BC_INST_SQRT:
|
|
case BC_INST_ABS:
|
|
{
|
|
s = bc_program_builtin(p, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_NUM:
|
|
{
|
|
r.t = BC_RESULT_CONSTANT;
|
|
r.d.id.len = bc_program_index(code, &ip->idx);
|
|
bc_vec_push(&p->results, &r);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_POP:
|
|
{
|
|
bc_vec_pop(&p->results);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_PRINT:
|
|
case BC_INST_PRINT_POP:
|
|
case BC_INST_PRINT_STR:
|
|
{
|
|
s = bc_program_print(p, inst, 0);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_STR:
|
|
{
|
|
r.t = BC_RESULT_STR;
|
|
r.d.id.len = bc_program_index(code, &ip->idx);
|
|
bc_vec_push(&p->results, &r);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_POWER:
|
|
case BC_INST_MULTIPLY:
|
|
case BC_INST_DIVIDE:
|
|
case BC_INST_MODULUS:
|
|
case BC_INST_PLUS:
|
|
case BC_INST_MINUS:
|
|
{
|
|
s = bc_program_op(p, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_NEG:
|
|
case BC_INST_BOOL_NOT:
|
|
{
|
|
s = bc_program_unary(p, inst);
|
|
break;
|
|
}
|
|
|
|
case BC_INST_ASSIGN_POWER:
|
|
case BC_INST_ASSIGN_MULTIPLY:
|
|
case BC_INST_ASSIGN_DIVIDE:
|
|
case BC_INST_ASSIGN_MODULUS:
|
|
case BC_INST_ASSIGN_PLUS:
|
|
case BC_INST_ASSIGN_MINUS:
|
|
case BC_INST_ASSIGN:
|
|
{
|
|
s = bc_program_assign(p, inst);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((s && s != BC_STATUS_QUIT) || TT.sig) s = bc_program_reset(p, s);
|
|
|
|
// If the stack has changed, pointers may be invalid.
|
|
ip = bc_vec_top(&p->stack);
|
|
func = bc_vec_item(&p->fns, ip->func);
|
|
code = func->code.v;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static void bc_vm_sig(int sig) {
|
|
int err = errno;
|
|
|
|
// If you run bc 2>/dev/full ctrl-C is ignored. Why? No idea.
|
|
if (sig == SIGINT) {
|
|
size_t len = strlen(bc_sig_msg);
|
|
if (write(2, bc_sig_msg, len) != len) sig = 0;
|
|
}
|
|
TT.sig = sig;
|
|
errno = err;
|
|
}
|
|
|
|
void bc_vm_info(void) {
|
|
printf("%s %s\n", toys.which->name, "1.1.0");
|
|
fputs(bc_copyright, stdout);
|
|
}
|
|
|
|
static void bc_vm_printError(BcError e, char *fmt,
|
|
size_t line, va_list args)
|
|
{
|
|
// Make sure all of stdout is written first.
|
|
fflush(stdout);
|
|
|
|
fprintf(stderr, fmt, bc_errs[(size_t) bc_err_ids[e]]);
|
|
vfprintf(stderr, bc_err_msgs[e], args);
|
|
|
|
// This is the condition for parsing vs runtime.
|
|
// If line is not 0, it is parsing.
|
|
if (line) {
|
|
fprintf(stderr, "\n %s", TT.file);
|
|
fprintf(stderr, bc_err_line, line);
|
|
}
|
|
else {
|
|
BcInstPtr *ip = bc_vec_item_rev(&BC_VM->prog.stack, 0);
|
|
BcFunc *f = bc_vec_item(&BC_VM->prog.fns, ip->func);
|
|
fprintf(stderr, "\n Function: %s", f->name);
|
|
}
|
|
|
|
fputs("\n\n", stderr);
|
|
fflush(stderr);
|
|
}
|
|
|
|
BcStatus bc_vm_error(BcError e, size_t line, ...) {
|
|
|
|
va_list args;
|
|
|
|
va_start(args, line);
|
|
bc_vm_printError(e, bc_err_fmt, line, args);
|
|
va_end(args);
|
|
|
|
return BC_STATUS_ERROR;
|
|
}
|
|
|
|
BcStatus bc_vm_posixError(BcError e, size_t line, ...) {
|
|
|
|
va_list args;
|
|
|
|
if (!(FLAG(s) || FLAG(w))) return BC_STATUS_SUCCESS;
|
|
|
|
va_start(args, line);
|
|
bc_vm_printError(e, FLAG(s) ? bc_err_fmt : bc_warn_fmt, line, args);
|
|
va_end(args);
|
|
|
|
return FLAG(s) ? BC_STATUS_ERROR : BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static void bc_vm_clean()
|
|
{
|
|
BcProgram *prog = &BC_VM->prog;
|
|
BcFunc *f = bc_vec_item(&prog->fns, BC_PROG_MAIN);
|
|
BcInstPtr *ip = bc_vec_item(&prog->stack, 0);
|
|
|
|
// If this condition is 1, we can get rid of strings,
|
|
// constants, and code. This is an idea from busybox.
|
|
if (!BC_PARSE_NO_EXEC(&BC_VM->prs) && prog->stack.len == 1 &&
|
|
!prog->results.len && ip->idx == f->code.len)
|
|
{
|
|
bc_vec_npop(&f->labels, f->labels.len);
|
|
bc_vec_npop(&f->strs, f->strs.len);
|
|
bc_vec_npop(&f->consts, f->consts.len);
|
|
bc_vec_npop(&f->code, f->code.len);
|
|
ip->idx = 0;
|
|
}
|
|
}
|
|
|
|
static BcStatus bc_vm_process(char *text, int is_stdin) {
|
|
|
|
BcStatus s;
|
|
uint16_t *flags;
|
|
|
|
s = bc_parse_text(&BC_VM->prs, text);
|
|
if (s) goto err;
|
|
|
|
while (BC_VM->prs.l.t != BC_LEX_EOF) {
|
|
s = bc_parse_parse(&BC_VM->prs);
|
|
if (s) goto err;
|
|
}
|
|
|
|
flags = BC_PARSE_TOP_FLAG_PTR(&BC_VM->prs);
|
|
|
|
if (!is_stdin && BC_VM->prs.flags.len == 1 && *flags == BC_PARSE_FLAG_IF_END)
|
|
bc_parse_noElse(&BC_VM->prs);
|
|
|
|
if (BC_PARSE_NO_EXEC(&BC_VM->prs)) goto err;
|
|
|
|
s = bc_program_exec(&BC_VM->prog);
|
|
if (FLAG(i)) fflush(stdout);
|
|
|
|
err:
|
|
if (s || TT.sig) s = bc_program_reset(&BC_VM->prog, s);
|
|
bc_vm_clean();
|
|
return s == BC_STATUS_QUIT || !FLAG(i) || !is_stdin ? s : BC_STATUS_SUCCESS;
|
|
}
|
|
|
|
static BcStatus bc_vm_file(char *file) {
|
|
|
|
BcStatus s;
|
|
char *data;
|
|
|
|
bc_lex_file(&BC_VM->prs.l, file);
|
|
s = bc_read_file(file, &data);
|
|
if (s) return s;
|
|
|
|
s = bc_vm_process(data, 0);
|
|
if (s) goto err;
|
|
|
|
if (BC_PARSE_NO_EXEC(&BC_VM->prs))
|
|
s = bc_parse_err(&BC_VM->prs, BC_ERROR_PARSE_BLOCK);
|
|
|
|
err:
|
|
free(data);
|
|
return s;
|
|
}
|
|
|
|
static BcStatus bc_vm_stdin(void) {
|
|
|
|
BcStatus s = BC_STATUS_SUCCESS;
|
|
BcVec buf, buffer;
|
|
size_t string = 0;
|
|
int comment = 0, done = 0;
|
|
|
|
bc_lex_file(&BC_VM->prs.l, bc_program_stdin_name);
|
|
|
|
bc_vec_init(&buffer, sizeof(uchar), NULL);
|
|
bc_vec_init(&buf, sizeof(uchar), NULL);
|
|
bc_vec_pushByte(&buffer, '\0');
|
|
|
|
// This loop is complex because the vm tries not to send any lines that end
|
|
// with a backslash to the parser, which
|
|
// treats a backslash+newline combo as whitespace per the bc spec. In that
|
|
// case, and for strings and comments, the parser will expect more stuff.
|
|
while (!done && (s = bc_read_line(&buf, ">>> ")) != BC_STATUS_ERROR &&
|
|
buf.len > 1 && !TT.sig && s != BC_STATUS_SIGNAL)
|
|
{
|
|
char c2, *str = buf.v;
|
|
size_t i, len = buf.len - 1;
|
|
|
|
done = (s == BC_STATUS_EOF);
|
|
|
|
if (len >= 2 && str[len - 1] == '\n' && str[len - 2] == '\\') {
|
|
bc_vec_concat(&buffer, buf.v);
|
|
continue;
|
|
}
|
|
|
|
for (i = 0; i < len; ++i) {
|
|
|
|
int notend = len > i + 1;
|
|
uchar c = (uchar) str[i];
|
|
|
|
if (!comment && (i - 1 > len || str[i - 1] != '\\')) string ^= c == '"';
|
|
|
|
if (!string && notend) {
|
|
|
|
c2 = str[i + 1];
|
|
|
|
if (c == '/' && !comment && c2 == '*') {
|
|
comment = 1;
|
|
++i;
|
|
}
|
|
else if (c == '*' && comment && c2 == '/') {
|
|
comment = 0;
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
bc_vec_concat(&buffer, buf.v);
|
|
|
|
if (string || comment) continue;
|
|
if (len >= 2 && str[len - 2] == '\\' && str[len - 1] == '\n') continue;
|
|
|
|
s = bc_vm_process(buffer.v, 1);
|
|
if (s) goto err;
|
|
|
|
bc_vec_empty(&buffer);
|
|
}
|
|
|
|
if (s && s != BC_STATUS_EOF) goto err;
|
|
else if (TT.sig && !s) s = BC_STATUS_SIGNAL;
|
|
else if (s != BC_STATUS_ERROR) {
|
|
if (comment) s = bc_parse_err(&BC_VM->prs, BC_ERROR_PARSE_COMMENT);
|
|
else if (string) s = bc_parse_err(&BC_VM->prs, BC_ERROR_PARSE_STRING);
|
|
else if (BC_PARSE_NO_EXEC(&BC_VM->prs))
|
|
s = bc_parse_err(&BC_VM->prs, BC_ERROR_PARSE_BLOCK);
|
|
}
|
|
|
|
err:
|
|
bc_vec_free(&buf);
|
|
bc_vec_free(&buffer);
|
|
return s;
|
|
}
|
|
|
|
void bc_main(void)
|
|
{
|
|
BcStatus s = 0;
|
|
char *ss;
|
|
|
|
struct sigaction sa;
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_handler = bc_vm_sig;
|
|
sa.sa_flags = 0;
|
|
sigaction(SIGINT, &sa, NULL);
|
|
sigaction(SIGTERM, &sa, NULL);
|
|
sigaction(SIGQUIT, &sa, NULL);
|
|
|
|
TT.line_len = 69;
|
|
ss = getenv("BC_LINE_LENGTH");
|
|
if (ss) {
|
|
int len = atoi(ss);
|
|
if (len>=2 && len <= UINT16_MAX) TT.line_len = len;
|
|
}
|
|
|
|
TT.vm = xzalloc(sizeof(BcVm));
|
|
bc_program_init(&BC_VM->prog);
|
|
bc_parse_init(&BC_VM->prs, &BC_VM->prog, BC_PROG_MAIN);
|
|
|
|
if (getenv("POSIXLY_CORRECT")) toys.optflags |= FLAG_s;
|
|
toys.optflags |= isatty(0) ? BC_FLAG_TTYIN : 0;
|
|
toys.optflags |= BC_TTYIN && isatty(1) ? FLAG_i : 0;
|
|
|
|
TT.max_ibase = !FLAG(s) && !FLAG(w) ? 16 : 36;
|
|
|
|
if (FLAG(i) && !(toys.optflags & FLAG_q)) bc_vm_info();
|
|
|
|
// load -l library (if any)
|
|
if (FLAG(l)) {
|
|
bc_lex_file(&BC_VM->prs.l, bc_lib_name);
|
|
s = bc_parse_text(&BC_VM->prs, bc_lib);
|
|
|
|
while (!s && BC_VM->prs.l.t != BC_LEX_EOF) s = bc_parse_parse(&BC_VM->prs);
|
|
}
|
|
|
|
// parse command line argument files, then stdin
|
|
if (!s) {
|
|
int i;
|
|
|
|
for (i = 0; !s && i < toys.optc; ++i) s = bc_vm_file(toys.optargs[i]);
|
|
if (!s) s = bc_vm_stdin();
|
|
}
|
|
|
|
if (CFG_TOYBOX_FREE) {
|
|
bc_program_free(&BC_VM->prog);
|
|
bc_parse_free(&BC_VM->prs);
|
|
free(TT.vm);
|
|
}
|
|
|
|
toys.exitval = s == BC_STATUS_ERROR;
|
|
}
|