I submitted this to Rob about 2 weeks ago, but I forgot to CC the list.
Here's it resubmitted (attached).
The patch itself is various cleanup (Removal of -s -w, and anything
"posixError", removal of
unneeded typedefs, compacting case statements, removing unneeded indirection,
etc)
- Oliver Webb <aquahobby...@proton.me>
From 0ab688638da60fb2275f3a09cc698bc342c47671 Mon Sep 17 00:00:00 2001
From: Oliver Webb <aquahobby...@proton.me>
Date: Sun, 24 Mar 2024 21:27:17 -0500
Subject: [PATCH] bc: Get rid of -s and -w and the code for it, unneeded
parentheses in case statements, CHAR_MAX, move data closer to code,
formatting
---
toys/pending/bc.c | 589 ++++++++--------------------------------------
1 file changed, 103 insertions(+), 486 deletions(-)
diff --git a/toys/pending/bc.c b/toys/pending/bc.c
index 2a47bf92..fdb4e37b 100644
--- a/toys/pending/bc.c
+++ b/toys/pending/bc.c
@@ -27,8 +27,6 @@ config BC
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
*/
@@ -41,7 +39,7 @@ GLOBALS(
char *vm;
size_t nchars;
- char *file, sig, max_ibase;
+ char *file, sig;
uint16_t line_len;
)
@@ -53,7 +51,6 @@ struct str_len {
#define BC_VM ((BcVm*) TT.vm)
typedef enum BcStatus {
-
BC_STATUS_SUCCESS = 0,
BC_STATUS_ERROR,
BC_STATUS_EOF,
@@ -63,8 +60,7 @@ typedef enum BcStatus {
} BcStatus;
-typedef enum BcError {
-
+enum BcError {
BC_ERROR_VM_ALLOC_ERR,
BC_ERROR_VM_IO_ERR,
BC_ERROR_VM_BIN_FILE,
@@ -105,29 +101,12 @@ typedef enum BcError {
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)
@@ -154,7 +133,7 @@ typedef struct BcNum {
// 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_LONG_LOG10 ((8 * sizeof(long) + 1) / 2 + 1)
#define BC_NUM_NEG(n, neg) ((((ssize_t) (n)) ^ -((ssize_t) (neg))) + (neg))
@@ -329,7 +308,6 @@ int bc_id_cmp(struct str_len *e1, struct str_len *e2);
// BC_LEX_NEG is not used in lexing; it is only for parsing.
typedef enum BcLexType {
-
BC_LEX_EOF,
BC_LEX_INVALID,
@@ -464,15 +442,8 @@ typedef struct 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);
@@ -514,7 +485,6 @@ BcStatus bc_lex_token(BcLex *l);
#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))
@@ -535,10 +505,8 @@ BcStatus bc_lex_token(BcLex *l);
// the first in the expr enum. Note: This only works for binary operators.
#define BC_PARSE_TOKEN_INST(t) ((char) ((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);
+BcStatus bc_parse_expr_status(BcParse *p, char flags, BcParseNext next);
void bc_parse_noElse(BcParse *p);
#define BC_PROG_ONE_CAP (1)
@@ -593,17 +561,12 @@ 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__))
@@ -613,27 +576,15 @@ typedef struct BcVm {
BcProgram prog;
} BcVm;
-BcStatus bc_vm_posixError(BcError e, size_t line, ...);
-
-BcStatus bc_vm_error(BcError e, size_t line, ...);
+BcStatus bc_vm_error(enum 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[] = {
@@ -647,10 +598,6 @@ char bc_err_ids[] = {
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[] = {
@@ -695,26 +642,13 @@ char *bc_err_msgs[] = {
"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)";
+#define BC_LEX_KW_ENTRY(a, b, c) \
+ { .data = ((b) & ~(BC_LEX_CHAR_MSB(1))) | BC_LEX_CHAR_MSB(c),.name = a }
BcLexKeyword bc_lex_kws[] = {
BC_LEX_KW_ENTRY("auto", 4, 1),
BC_LEX_KW_ENTRY("break", 5, 1),
@@ -741,9 +675,8 @@ BcLexKeyword bc_lex_kws[] = {
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.
+#define BC_PARSE_OP(p, l) (((p) & ~(BC_LEX_CHAR_MSB(1))) | (BC_LEX_CHAR_MSB(l)))
char bc_parse_ops[] = {
BC_PARSE_OP(0, 0), BC_PARSE_OP(0, 0),
BC_PARSE_OP(1, 0), BC_PARSE_OP(1, 0),
@@ -771,8 +704,6 @@ 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,
};
@@ -788,8 +719,6 @@ BcProgramUnary bc_program_unarys[] = {
char bc_program_ready_msg[] = "ready for more input\n";
-char *bc_lib_name = "gen/lib.bc";
-
char *bc_lib =
"scale=20;\n"
@@ -999,9 +928,9 @@ void bc_vec_pushIndex(BcVec *v, size_t idx) {
char amt, nums[sizeof(size_t)];
for (amt = 0; idx; ++amt) {
- nums[amt] = (char) idx;
- idx &= ((size_t) ~(UCHAR_MAX));
- idx >>= sizeof(char) * CHAR_BIT;
+ nums[amt] = idx;
+ idx &= ((size_t) ~(255));
+ idx >>= 8;
}
bc_vec_push(v, &amt);
@@ -1116,7 +1045,7 @@ BcStatus bc_read_chars(BcVec *vec, char *prompt) {
bc_vec_npop(vec, vec->len);
- if (BC_TTYIN && !FLAG(s)) {
+ if (FLAG(i) && !FLAG(s)) {
fputs(prompt, stderr);
fflush(stderr);
}
@@ -1133,7 +1062,7 @@ BcStatus bc_read_chars(BcVec *vec, char *prompt) {
TT.sig = 0;
- if (BC_TTYIN) {
+ if (FLAG(i)) {
fputs(bc_program_ready_msg, stderr);
if (!FLAG(s)) fputs(prompt, stderr);
fflush(stderr);
@@ -1174,7 +1103,7 @@ BcStatus bc_read_line(BcVec *vec, char *prompt) {
BcStatus bc_read_file(char *path, char **buf) {
- BcError e = BC_ERROR_VM_IO_ERR;
+ enum BcError e = BC_ERROR_VM_IO_ERR;
FILE *f;
size_t size, read;
long res;
@@ -1576,7 +1505,7 @@ static BcStatus bc_num_k(BcNum *a, BcNum *b, BcNum *c) {
carry = 0;
for (j = 0; !TT.sig && j < a->len; ++j) {
- unsigned int in = (char) ptr[j];
+ unsigned int in = ptr[j];
in += ((unsigned int) a->num[j]) * ((unsigned int) b->num[i]);
carry = bc_num_addDigit(ptr + j, in, carry);
}
@@ -2008,7 +1937,7 @@ static void bc_num_printDigits(size_t n, size_t len, int rdx) {
bc_num_printNewline();
dig = n / pow;
n -= dig * pow;
- putchar(((char) dig) + '0');
+ putchar(dig + '0');
}
}
@@ -2021,7 +1950,7 @@ static void bc_num_printHex(size_t n, size_t len, int rdx) {
}
bc_num_printNewline();
- putchar(bc_num_hex_digits[n]);
+ putchar("0123456789ABCDEF"[n]);
TT.nchars += len;
}
@@ -2051,7 +1980,7 @@ static BcStatus bc_num_printNum(BcNum *n, BcNum *base,
return BC_STATUS_SUCCESS;
}
- bc_vec_init(&stack, sizeof(unsigned long), NULL);
+ bc_vec_init(&stack, sizeof(long), NULL);
bc_num_init(&fracp, n->rdx);
bc_num_init(&digit, len);
bc_num_init(&frac_len, BC_NUM_INT(n));
@@ -2222,7 +2151,7 @@ BcStatus bc_num_ulong(BcNum *n, unsigned long *result) {
if (prev == SIZE_MAX || prev / 10 != r)
return bc_vm_err(BC_ERROR_MATH_OVERFLOW);
- r = prev + ((char) n->num[--i]);
+ r = prev + (n->num[--i]);
if (r == SIZE_MAX || r < prev) return bc_vm_err(BC_ERROR_MATH_OVERFLOW);
}
@@ -2443,7 +2372,7 @@ BcStatus bc_func_insert(BcFunc *f, char *name, BcType type, size_t line) {
}
void bc_func_init(BcFunc *f, char *name) {
- bc_vec_init(&f->code, sizeof(char), NULL);
+ bc_vec_init(&f->code, 1, 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);
@@ -2657,10 +2586,6 @@ BcStatus bc_lex_name(BcLex *l) {
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;
@@ -2711,11 +2636,6 @@ static BcStatus bc_lex_identifier(BcLex *l) {
{
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;
@@ -2725,9 +2645,7 @@ static BcStatus bc_lex_identifier(BcLex *l) {
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;
+ return 0;
}
static BcStatus bc_lex_string(BcLex *l) {
@@ -2776,85 +2694,55 @@ BcStatus bc_lex_token(BcLex *l) {
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;
@@ -2862,16 +2750,12 @@ BcStatus bc_lex_token(BcLex *l) {
}
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;
@@ -2879,149 +2763,67 @@ BcStatus bc_lex_token(BcLex *l) {
}
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':
+ case '0' ... '9':
+ case 'A' ... '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':
- {
+ case 'G' ... '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':
- {
+ case 'a' ... 'z':
s = bc_lex_identifier(l);
break;
- }
case '{':
case '}':
@@ -3035,10 +2837,6 @@ BcStatus bc_lex_token(BcLex *l) {
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;
}
@@ -3064,7 +2862,7 @@ void bc_parse_updateFunc(BcParse *p, size_t fidx) {
void bc_parse_pushName(BcParse *p, char *name) {
bc_vec_npush(&p->func->code, strlen(name), name);
- bc_parse_push(p, UCHAR_MAX);
+ bc_parse_push(p, 255);
}
void bc_parse_pushIndex(BcParse *p, size_t idx) {
@@ -3120,13 +2918,13 @@ void bc_parse_free(BcParse *p) {
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_init(&p->flags, 16, 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);
+ bc_vec_init(&p->l.str, 1, NULL);
p->prog = prog;
p->auto_part = 0;
@@ -3135,7 +2933,7 @@ void bc_parse_init(BcParse *p, BcProgram *prog, size_t 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 BcStatus bc_parse_expr_err(BcParse *p, char flags, BcParseNext next);
static int bc_parse_inst_isLeaf(BcInst t) {
return (t >= BC_INST_NUM && t <= BC_INST_ABS) ||
@@ -3263,7 +3061,7 @@ static BcStatus bc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs) {
return bc_lex_next(&p->l);
}
-static BcStatus bc_parse_params(BcParse *p, uint8_t flags) {
+static BcStatus bc_parse_params(BcParse *p, char flags) {
BcStatus s;
int comma = 0;
@@ -3292,7 +3090,7 @@ static BcStatus bc_parse_params(BcParse *p, uint8_t flags) {
return BC_STATUS_SUCCESS;
}
-static BcStatus bc_parse_call(BcParse *p, char *name, uint8_t flags) {
+static BcStatus bc_parse_call(BcParse *p, char *name, char flags) {
BcStatus s;
struct str_len id;
@@ -3325,7 +3123,7 @@ err:
return s;
}
-static BcStatus bc_parse_name(BcParse *p, BcInst *type, uint8_t flags) {
+static BcStatus bc_parse_name(BcParse *p, BcInst *type, char flags) {
BcStatus s;
char *name;
@@ -3409,7 +3207,7 @@ static BcStatus bc_parse_read(BcParse *p) {
}
static BcStatus bc_parse_builtin(BcParse *p, BcLexType type,
- uint8_t flags, BcInst *prev)
+ char flags, BcInst *prev)
{
BcStatus s;
@@ -3434,7 +3232,7 @@ static BcStatus bc_parse_builtin(BcParse *p, BcLexType type,
return bc_lex_next(&p->l);
}
-static BcStatus bc_parse_scale(BcParse *p, BcInst *type, uint8_t flags) {
+static BcStatus bc_parse_scale(BcParse *p, BcInst *type, char flags) {
BcStatus s;
@@ -3463,7 +3261,7 @@ static BcStatus bc_parse_scale(BcParse *p, BcInst *type, uint8_t flags) {
}
static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev,
- size_t *nexs, uint8_t flags)
+ size_t *nexs, char flags)
{
BcStatus s;
BcLexType type;
@@ -3578,10 +3376,7 @@ static BcStatus bc_parse_print(BcParse *p) {
}
static BcStatus bc_parse_return(BcParse *p) {
-
BcStatus s;
- BcLexType t;
- int paren;
char inst = BC_INST_RET0;
if (!BC_PARSE_FUNC(p)) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
@@ -3591,9 +3386,6 @@ static BcStatus bc_parse_return(BcParse *p) {
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 {
@@ -3605,11 +3397,7 @@ static BcStatus bc_parse_return(BcParse *p) {
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)
+ if (p->func->voidfn)
return bc_parse_verr(p, BC_ERROR_PARSE_RET_VOID, p->func->name);
bc_parse_push(p, BC_INST_RET);
@@ -3793,7 +3581,6 @@ static BcStatus bc_parse_while(BcParse *p) {
}
static BcStatus bc_parse_for(BcParse *p) {
-
BcStatus s;
size_t cond_idx, exit_idx, body_idx, update_idx;
@@ -3807,7 +3594,7 @@ static BcStatus bc_parse_for(BcParse *p) {
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);
+ else;
if (s) return s;
if (p->l.t != BC_LEX_SCOLON) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
@@ -3828,10 +3615,9 @@ static BcStatus bc_parse_for(BcParse *p) {
// 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_vec_string(&p->l.str, 1, "1");
bc_parse_number(p);
- s = bc_parse_posixErr(p, BC_ERROR_POSIX_FOR2);
}
if (s) return s;
@@ -3851,7 +3637,7 @@ static BcStatus bc_parse_for(BcParse *p) {
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);
+ else;
if (s) return s;
@@ -3867,8 +3653,8 @@ static BcStatus bc_parse_for(BcParse *p) {
return s;
}
-static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type) {
-
+static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type)
+{
size_t i;
BcInstPtr *ip;
@@ -3895,8 +3681,8 @@ static BcStatus bc_parse_loopExit(BcParse *p, BcLexType type) {
return bc_lex_next(&p->l);
}
-static BcStatus bc_parse_func(BcParse *p) {
-
+static BcStatus bc_parse_func(BcParse *p)
+{
BcStatus s;
int comma = 0, voidfn;
uint16_t flags;
@@ -3977,8 +3763,6 @@ static BcStatus bc_parse_func(BcParse *p) {
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:
@@ -4045,8 +3829,8 @@ err:
return s;
}
-static BcStatus bc_parse_body(BcParse *p, int brace) {
-
+static BcStatus bc_parse_body(BcParse *p, int brace)
+{
BcStatus s = BC_STATUS_SUCCESS;
uint16_t *flag_ptr = BC_PARSE_TOP_FLAG_PTR(p);
@@ -4079,8 +3863,8 @@ static BcStatus bc_parse_body(BcParse *p, int brace) {
return s;
}
-static BcStatus bc_parse_stmt(BcParse *p) {
-
+static BcStatus bc_parse_stmt(BcParse *p)
+{
BcStatus s = BC_STATUS_SUCCESS;
size_t len;
uint16_t flags;
@@ -4121,7 +3905,6 @@ static BcStatus bc_parse_stmt(BcParse *p) {
flags = BC_PARSE_TOP_FLAG(p);
switch (type) {
-
case BC_LEX_OP_INC:
case BC_LEX_OP_DEC:
case BC_LEX_OP_MINUS:
@@ -4137,108 +3920,64 @@ static BcStatus bc_parse_stmt(BcParse *p) {
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)) {
@@ -4251,8 +3990,8 @@ static BcStatus bc_parse_stmt(BcParse *p) {
return s;
}
-BcStatus bc_parse_parse(BcParse *p) {
-
+BcStatus bc_parse_parse(BcParse *p)
+{
BcStatus s;
if (p->l.t == BC_LEX_EOF) s = bc_parse_err(p, BC_ERROR_PARSE_EOF);
@@ -4267,12 +4006,12 @@ BcStatus bc_parse_parse(BcParse *p) {
return s;
}
-static BcStatus bc_parse_expr_err(BcParse *p, uint8_t flags, BcParseNext next) {
+static BcStatus bc_parse_expr_err(BcParse *p, char 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;
+ unsigned i, nparens, nrelops;
int pfirst, rprn, done, get_token, assign, bin_last, incdec;
char valid[] = {0xfc, 0xff, 0xff, 0x67, 0xc0, 0x00, 0x7c, 0x0b};
@@ -4427,8 +4166,8 @@ static BcStatus bc_parse_expr_err(BcParse *p, uint8_t flags, BcParseNext next) {
if (BC_PARSE_LEAF(prev, bin_last, rprn))
return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
- prev = (char) (t - BC_LEX_KEY_LAST + BC_INST_LAST);
- bc_parse_push(p, (char) prev);
+ prev = (t - BC_LEX_KEY_LAST + BC_INST_LAST);
+ bc_parse_push(p, prev);
get_token = 1;
rprn = bin_last = 0;
@@ -4511,15 +4250,6 @@ static BcStatus bc_parse_expr_err(BcParse *p, uint8_t flags, BcParseNext next) {
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);
@@ -4536,7 +4266,7 @@ static BcStatus bc_parse_expr_err(BcParse *p, uint8_t flags, BcParseNext next) {
return s;
}
-BcStatus bc_parse_expr_status(BcParse *p, uint8_t flags, BcParseNext next) {
+BcStatus bc_parse_expr_status(BcParse *p, char flags, BcParseNext next) {
BcStatus s = bc_parse_expr_err(p, flags, next);
@@ -4571,12 +4301,11 @@ static char *bc_program_str(BcProgram *p, size_t idx, int str) {
}
static size_t bc_program_index(char *code, size_t *bgn) {
-
- char amt = (char) code[(*bgn)++], i = 0;
+ char amt = code[(*bgn)++], i = 0;
size_t res = 0;
for (; i < amt; ++i, ++(*bgn)) {
- size_t temp = ((size_t) ((int) (char) code[*bgn]) & UCHAR_MAX);
+ size_t temp = code[*bgn] & 255;
res |= (temp << (i * CHAR_BIT));
}
@@ -4584,16 +4313,15 @@ static size_t bc_program_index(char *code, size_t *bgn) {
}
static char *bc_program_name(char *code, size_t *bgn) {
-
size_t i;
char c;
char *s;
- char *str = code + *bgn, *ptr = strchr(str, UCHAR_MAX);
+ char *str = code + *bgn, *ptr = strchr(str, 255);
s = xmalloc(((unsigned long) ptr) - ((unsigned long) str) + 1);
- for (i = 0; (c = (char) code[(*bgn)++]) && c != UCHAR_MAX; ++i)
- s[i] = (char) c;
+ for (i = 0; (c = code[(*bgn)++]) && c != 255; ++i)
+ s[i] = c;
s[i] = '\0';
@@ -4601,7 +4329,6 @@ static char *bc_program_name(char *code, size_t *bgn) {
}
static BcVec* bc_program_search(BcProgram *p, char *id, BcType type) {
-
struct str_len e, *ptr;
BcVec *v, *map;
size_t i;
@@ -4627,7 +4354,6 @@ static BcVec* bc_program_search(BcProgram *p, char *id, BcType type) {
}
static BcStatus bc_program_num(BcProgram *p, BcResult *r, BcNum **num) {
-
BcStatus s = BC_STATUS_SUCCESS;
BcNum *n = &r->d.n;
@@ -4655,15 +4381,12 @@ static BcStatus bc_program_num(BcProgram *p, BcResult *r, BcNum **num) {
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;
@@ -4681,25 +4404,18 @@ static BcStatus bc_program_num(BcProgram *p, BcResult *r, BcNum **num) {
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;
@@ -4708,7 +4424,6 @@ static BcStatus bc_program_num(BcProgram *p, BcResult *r, BcNum **num) {
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);
@@ -4781,7 +4496,6 @@ static void bc_program_binOpRetire(BcProgram *p, BcResult *r) {
}
static BcStatus bc_program_prep(BcProgram *p, BcResult **r, BcNum **n) {
-
BcStatus s;
s = bc_program_operand(p, r, n, 0);
@@ -4797,7 +4511,6 @@ static void bc_program_retire(BcProgram *p, BcResult *r, BcResultType t) {
}
static BcStatus bc_program_op(BcProgram *p, char inst) {
-
BcStatus s;
BcResult *opd1, *opd2, res;
BcNum *n1 = NULL, *n2 = NULL;
@@ -4837,7 +4550,7 @@ static BcStatus bc_program_read(BcProgram *p) {
file = TT.file;
bc_lex_file(&parse.l, "<stdin>");
bc_vec_npop(&f->code, f->code.len);
- bc_vec_init(&buf, sizeof(char), NULL);
+ bc_vec_init(&buf, 1, NULL);
s = bc_read_line(&buf, "read> ");
if (s) {
@@ -4902,7 +4615,6 @@ static void bc_program_printString(char *str)
}
static BcStatus bc_program_print(BcProgram *p, char inst, size_t idx) {
-
BcStatus s = BC_STATUS_SUCCESS;
BcResult *r;
char *str;
@@ -4995,46 +4707,14 @@ static BcStatus bc_program_logical(BcProgram *p, char inst) {
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;
- }
+ 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;
}
}
@@ -5111,7 +4791,7 @@ static BcStatus bc_program_assign(BcProgram *p, char inst) {
size_t *ptr;
unsigned long val, max, min;
- BcError e;
+ enum BcError e;
s = bc_num_ulong(l, &val);
if (s) return s;
@@ -5123,7 +4803,7 @@ static BcStatus bc_program_assign(BcProgram *p, char inst) {
ptr = &p->scale;
}
else {
- max = ib ? TT.max_ibase : BC_MAX_OBASE;
+ max = ib ? 36 : BC_MAX_OBASE;
min = 2;
ptr = ib ? &p->ib_t : &p->ob_t;
}
@@ -5389,18 +5069,6 @@ static void bc_program_pushGlobal(BcProgram *p, char inst) {
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;
@@ -5480,7 +5148,7 @@ BcStatus bc_program_reset(BcProgram *p, BcStatus s) {
TT.sig = 0;
if (!s || s == BC_STATUS_SIGNAL) {
- if (BC_TTYIN) {
+ if (FLAG(i)) {
fputs(bc_program_ready_msg, stderr);
fflush(stderr);
s = BC_STATUS_SUCCESS;
@@ -5504,62 +5172,48 @@ BcStatus bc_program_exec(BcProgram *p) {
while (!s && ip->idx < func->code.len) {
- char inst = (char) code[(ip->idx)++];
+ char inst = 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:
@@ -5569,76 +5223,56 @@ BcStatus bc_program_exec(BcProgram *p) {
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:
@@ -5646,17 +5280,13 @@ BcStatus bc_program_exec(BcProgram *p) {
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:
@@ -5665,10 +5295,8 @@ BcStatus bc_program_exec(BcProgram *p) {
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);
@@ -5682,9 +5310,9 @@ BcStatus bc_program_exec(BcProgram *p) {
return s;
}
-static void bc_vm_sig(int sig) {
+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);
@@ -5694,25 +5322,20 @@ static void bc_vm_sig(int 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,
+static void bc_vm_printError(enum 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]]);
+ fprintf(stderr, fmt, bc_errs[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);
+ fprintf(stderr, ":%zu", line);
}
else {
BcInstPtr *ip = bc_vec_item_rev(&BC_VM->prog.stack, 0);
@@ -5724,30 +5347,17 @@ static void bc_vm_printError(BcError e, char *fmt,
fflush(stderr);
}
-BcStatus bc_vm_error(BcError e, size_t line, ...) {
-
+BcStatus bc_vm_error(enum BcError e, size_t line, ...)
+{
va_list args;
va_start(args, line);
- bc_vm_printError(e, bc_err_fmt, line, args);
+ bc_vm_printError(e, "\n%s error:", 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;
@@ -5768,7 +5378,6 @@ static void bc_vm_clean()
}
static BcStatus bc_vm_process(char *text, int is_stdin) {
-
BcStatus s;
uint16_t *flags;
@@ -5817,7 +5426,6 @@ err:
}
static BcStatus bc_vm_stdin(void) {
-
BcStatus s = BC_STATUS_SUCCESS;
BcVec buf, buffer;
size_t string = 0;
@@ -5825,8 +5433,8 @@ static BcStatus bc_vm_stdin(void) {
bc_lex_file(&BC_VM->prs.l, "<stdin>");
- bc_vec_init(&buffer, sizeof(char), NULL);
- bc_vec_init(&buf, sizeof(char), NULL);
+ bc_vec_init(&buffer, 1, NULL);
+ bc_vec_init(&buf, 1, NULL);
bc_vec_pushByte(&buffer, '\0');
// This loop is complex because the vm tries not to send any lines that end
@@ -5849,7 +5457,7 @@ static BcStatus bc_vm_stdin(void) {
for (i = 0; i < len; ++i) {
int notend = len > i + 1;
- char c = (char) str[i];
+ char c = str[i];
if (!comment && (i - 1 > len || str[i - 1] != '\\')) string ^= c == '"';
@@ -5909,8 +5517,7 @@ void bc_main(void)
sigaction(SIGQUIT, &sa, NULL);
TT.line_len = 69;
- ss = getenv("BC_LINE_LENGTH");
- if (ss) {
+ if ((ss = getenv("BC_LINE_LENGTH"))) {
int len = atoi(ss);
if (len>=2 && len <= UINT16_MAX) TT.line_len = len;
}
@@ -5919,17 +5526,19 @@ void bc_main(void)
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;
+ toys.optflags |= isatty(0) ? FLAG_i : 0;
+ toys.optflags |= FLAG(i) && isatty(1) ? FLAG_i : 0;
- TT.max_ibase = !FLAG(s) && !FLAG(w) ? 16 : 36;
-
- if (FLAG(i) && !(toys.optflags & FLAG_q)) bc_vm_info();
+ if (FLAG(i) && !(toys.optflags & FLAG_q)) {
+ printf("%s 1.1.0\n", toys.which->name);
+ puts("Copyright (c) 2018 Gavin D. Howard and contributors\n"
+ "Report bugs at: https://github.com/gavinhoward/bc\n";
+ "This is free software with ABSOLUTELY NO WARRANTY.");
+ }
// load -l library (if any)
if (FLAG(l)) {
- bc_lex_file(&BC_VM->prs.l, bc_lib_name);
+ bc_lex_file(&BC_VM->prs.l, "");
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);
@@ -5944,7 +5553,15 @@ void bc_main(void)
}
if (CFG_TOYBOX_FREE) {
- bc_program_free(&BC_VM->prog);
+ bc_vec_free(&BC_VM->prog.fns);
+ bc_vec_free(&BC_VM->prog.fn_map);
+ bc_vec_free(&BC_VM->prog.vars);
+ bc_vec_free(&BC_VM->prog.var_map);
+ bc_vec_free(&BC_VM->prog.arrs);
+ bc_vec_free(&BC_VM->prog.arr_map);
+ bc_vec_free(&BC_VM->prog.results);
+ bc_vec_free(&BC_VM->prog.stack);
+ bc_num_free(&BC_VM->prog.last);
bc_parse_free(&BC_VM->prs);
free(TT.vm);
}
--
2.44.0
_______________________________________________
Toybox mailing list
Toybox@lists.landley.net
http://lists.landley.net/listinfo.cgi/toybox-landley.net
