bc: convert even more of lexer functions to "z" convention
function old new delta bc_parse_name 416 - -416 zbc_parse_name - 414 +414 bc_parse_parse 305 - -305 zbc_parse_parse - 311 +311 bc_program_read 271 - -271 zbc_program_read - 261 +261 bc_parse_text 129 - -129 zbc_parse_text - 122 +122 dc_parse_parse 26 - -26 zdc_parse_parse - 23 +23 bc_program_index 66 64 -2 bc_vm_process 92 74 -18 bc_program_execStr 460 429 -31 bc_parse_expr_empty_ok 1939 1882 -57 ------------------------------------------------------------------------------ (add/remove: 5/5 grow/shrink: 0/4 up/down: 1131/-1255) Total: -124 bytes text data bss dec hex filename 981058 485 7296 988839 f16a7 busybox_old 980934 485 7296 988715 f162b busybox_unstripped Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
This commit is contained in:
Denys Vlasenko
parent
ae0faf91d0
commit
26819db9a3
226
miscutils/bc.c
226
miscutils/bc.c
@ -618,7 +618,7 @@ struct BcParse;
|
||||
|
||||
struct BcProgram;
|
||||
|
||||
typedef BcStatus (*BcParseParse)(struct BcParse *) FAST_FUNC;
|
||||
typedef BC_STATUS (*BcParseParse)(struct BcParse *) FAST_FUNC;
|
||||
|
||||
typedef struct BcParse {
|
||||
|
||||
@ -1364,8 +1364,8 @@ static int push_input_byte(BcVec *vec, char c)
|
||||
return 0;
|
||||
}
|
||||
|
||||
// This is not a "z" function: can also return BC_STATUS_EOF
|
||||
// Can return success (0) or BC_STATUS_EOF.
|
||||
// This is not a "z" function:
|
||||
// can return success (0) or BC_STATUS_EOF.
|
||||
// Exits with error message if read error is detected.
|
||||
static BcStatus bc_read_line(BcVec *vec)
|
||||
{
|
||||
@ -2305,12 +2305,8 @@ static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
|
||||
else
|
||||
bc_num_expand(c, req);
|
||||
|
||||
#if !ERRORS_ARE_FATAL
|
||||
s = op(ptr_a, ptr_b, c, scale);
|
||||
#else
|
||||
op(ptr_a, ptr_b, c, scale);
|
||||
s = BC_STATUS_SUCCESS;
|
||||
#endif
|
||||
ERROR_RETURN(s =) op(ptr_a, ptr_b, c, scale);
|
||||
|
||||
if (init) bc_num_free(&num2);
|
||||
|
||||
@ -3032,25 +3028,26 @@ static BC_STATUS zbc_lex_identifier(BcLex *l)
|
||||
# define zbc_lex_identifier(...) (zbc_lex_identifier(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_lex_string(BcLex *l)
|
||||
static BC_STATUS zbc_lex_string(BcLex *l)
|
||||
{
|
||||
size_t len, nls = 0, i = l->i;
|
||||
char c;
|
||||
|
||||
l->t.t = BC_LEX_STR;
|
||||
|
||||
for (c = l->buf[i]; c != 0 && c != '"'; c = l->buf[++i]) nls += (c == '\n');
|
||||
for (c = l->buf[i]; c != 0 && c != '"'; c = l->buf[++i])
|
||||
nls += (c == '\n');
|
||||
|
||||
if (c == '\0') {
|
||||
l->i = i;
|
||||
return bc_error("string end could not be found");
|
||||
RETURN_STATUS(bc_error("string end could not be found"));
|
||||
}
|
||||
|
||||
len = i - l->i;
|
||||
// This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
|
||||
if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
|
||||
if (len > BC_MAX_STRING)
|
||||
return bc_error("string too long: must be [1,"BC_MAX_STRING_STR"]");
|
||||
RETURN_STATUS(("string too long: must be [1,"BC_MAX_STRING_STR"]"));
|
||||
}
|
||||
bc_vec_string(&l->t.v, len, l->buf + l->i);
|
||||
|
||||
@ -3058,8 +3055,11 @@ static BcStatus bc_lex_string(BcLex *l)
|
||||
l->line += nls;
|
||||
G.err_line = l->line;
|
||||
|
||||
return BC_STATUS_SUCCESS;
|
||||
RETURN_STATUS(BC_STATUS_SUCCESS);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_lex_string(...) (zbc_lex_string(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static void bc_lex_assign(BcLex *l, BcLexType with, BcLexType without)
|
||||
{
|
||||
@ -3132,7 +3132,7 @@ static FAST_FUNC BC_STATUS zbc_lex_token(BcLex *l)
|
||||
}
|
||||
break;
|
||||
case '"':
|
||||
s = bc_lex_string(l);
|
||||
s = zbc_lex_string(l);
|
||||
break;
|
||||
case '#':
|
||||
s = bc_POSIX_does_not_allow("'#' script comments");
|
||||
@ -3462,6 +3462,7 @@ static void bc_parse_pushIndex(BcParse *p, size_t idx)
|
||||
{
|
||||
unsigned char amt, i, nums[sizeof(size_t)];
|
||||
|
||||
///oh boy
|
||||
for (amt = 0; idx; ++amt) {
|
||||
nums[amt] = (char) idx;
|
||||
idx = (idx & ((unsigned long) ~(UCHAR_MAX))) >> sizeof(char) * CHAR_BIT;
|
||||
@ -3485,7 +3486,7 @@ static void bc_parse_number(BcParse *p, BcInst *prev, size_t *nexs)
|
||||
(*prev) = BC_INST_NUM;
|
||||
}
|
||||
|
||||
static BcStatus bc_parse_text(BcParse *p, const char *text)
|
||||
static BC_STATUS zbc_parse_text(BcParse *p, const char *text)
|
||||
{
|
||||
BcStatus s;
|
||||
|
||||
@ -3493,14 +3494,18 @@ static BcStatus bc_parse_text(BcParse *p, const char *text)
|
||||
|
||||
if (!text[0] && !BC_PARSE_CAN_EXEC(p)) {
|
||||
p->l.t.t = BC_LEX_INVALID;
|
||||
s = p->parse(p);
|
||||
if (s) return s;
|
||||
s = BC_STATUS_SUCCESS;
|
||||
ERROR_RETURN(s =) p->parse(p);
|
||||
if (s) RETURN_STATUS(s);
|
||||
if (!BC_PARSE_CAN_EXEC(p))
|
||||
return bc_error("file is not executable");
|
||||
RETURN_STATUS(bc_error("file is not executable"));
|
||||
}
|
||||
|
||||
return zbc_lex_text(&p->l, text);
|
||||
RETURN_STATUS(zbc_lex_text(&p->l, text));
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_text(...) (zbc_parse_text(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
// Called when parsing or execution detects a failure,
|
||||
// resets execution structures.
|
||||
@ -3520,7 +3525,7 @@ static void bc_program_reset(void)
|
||||
#define bc_parse_updateFunc(p, f) \
|
||||
((p)->func = bc_program_func((p)->fidx = (f)))
|
||||
|
||||
// Called when bc/dc_parse_parse() detects a failure,
|
||||
// Called when zbc/zdc_parse_parse() detects a failure,
|
||||
// resets parsing structures.
|
||||
static void bc_parse_reset(BcParse *p)
|
||||
{
|
||||
@ -3650,36 +3655,38 @@ static BC_STATUS zbc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs)
|
||||
# define zbc_parse_rightParen(...) (zbc_parse_rightParen(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_parse_params(BcParse *p, uint8_t flags)
|
||||
static BC_STATUS zbc_parse_params(BcParse *p, uint8_t flags)
|
||||
{
|
||||
BcStatus s;
|
||||
bool comma = false;
|
||||
size_t nparams;
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
|
||||
for (nparams = 0; p->l.t.t != BC_LEX_RPAREN; ++nparams) {
|
||||
|
||||
flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
|
||||
s = zbc_parse_expr(p, flags, bc_parse_next_param);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
|
||||
comma = p->l.t.t == BC_LEX_COMMA;
|
||||
if (comma) {
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
}
|
||||
}
|
||||
|
||||
if (comma) return bc_error_bad_token();
|
||||
if (comma) RETURN_STATUS(bc_error_bad_token());
|
||||
bc_parse_push(p, BC_INST_CALL);
|
||||
bc_parse_pushIndex(p, nparams);
|
||||
|
||||
return BC_STATUS_SUCCESS;
|
||||
RETURN_STATUS(BC_STATUS_SUCCESS);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_params(...) (zbc_parse_params(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_parse_call(BcParse *p, char *name, uint8_t flags)
|
||||
static BC_STATUS zbc_parse_call(BcParse *p, char *name, uint8_t flags)
|
||||
{
|
||||
BcStatus s;
|
||||
BcId entry, *entry_ptr;
|
||||
@ -3687,7 +3694,7 @@ static BcStatus bc_parse_call(BcParse *p, char *name, uint8_t flags)
|
||||
|
||||
entry.name = name;
|
||||
|
||||
s = bc_parse_params(p, flags);
|
||||
s = zbc_parse_params(p, flags);
|
||||
if (s) goto err;
|
||||
|
||||
if (p->l.t.t != BC_LEX_RPAREN) {
|
||||
@ -3702,21 +3709,23 @@ static BcStatus bc_parse_call(BcParse *p, char *name, uint8_t flags)
|
||||
bc_parse_addFunc(p, name, &idx);
|
||||
idx = bc_map_index(&G.prog.fn_map, &entry);
|
||||
free(entry.name);
|
||||
}
|
||||
else
|
||||
} else
|
||||
free(name);
|
||||
|
||||
entry_ptr = bc_vec_item(&G.prog.fn_map, idx);
|
||||
bc_parse_pushIndex(p, entry_ptr->idx);
|
||||
|
||||
return zbc_lex_next(&p->l);
|
||||
RETURN_STATUS(zbc_lex_next(&p->l));
|
||||
|
||||
err:
|
||||
free(name);
|
||||
return s;
|
||||
RETURN_STATUS(s);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_call(...) (zbc_parse_call(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_parse_name(BcParse *p, BcInst *type, uint8_t flags)
|
||||
static BC_STATUS zbc_parse_name(BcParse *p, BcInst *type, uint8_t flags)
|
||||
{
|
||||
BcStatus s;
|
||||
char *name;
|
||||
@ -3726,55 +3735,48 @@ static BcStatus bc_parse_name(BcParse *p, BcInst *type, uint8_t flags)
|
||||
if (s) goto err;
|
||||
|
||||
if (p->l.t.t == BC_LEX_LBRACKET) {
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) goto err;
|
||||
|
||||
if (p->l.t.t == BC_LEX_RBRACKET) {
|
||||
|
||||
if (!(flags & BC_PARSE_ARRAY)) {
|
||||
s = bc_error_bad_expression();
|
||||
goto err;
|
||||
}
|
||||
|
||||
*type = BC_INST_ARRAY;
|
||||
}
|
||||
else {
|
||||
|
||||
} else {
|
||||
*type = BC_INST_ARRAY_ELEM;
|
||||
|
||||
flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
|
||||
s = zbc_parse_expr(p, flags, bc_parse_next_elem);
|
||||
if (s) goto err;
|
||||
}
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) goto err;
|
||||
bc_parse_push(p, *type);
|
||||
bc_parse_pushName(p, name);
|
||||
}
|
||||
else if (p->l.t.t == BC_LEX_LPAREN) {
|
||||
|
||||
if (flags & BC_PARSE_NOCALL) {
|
||||
s = bc_error_bad_token();
|
||||
goto err;
|
||||
}
|
||||
|
||||
*type = BC_INST_CALL;
|
||||
s = bc_parse_call(p, name, flags);
|
||||
}
|
||||
else {
|
||||
s = zbc_parse_call(p, name, flags);
|
||||
} else {
|
||||
*type = BC_INST_VAR;
|
||||
bc_parse_push(p, BC_INST_VAR);
|
||||
bc_parse_pushName(p, name);
|
||||
}
|
||||
|
||||
return s;
|
||||
RETURN_STATUS(s);
|
||||
|
||||
err:
|
||||
free(name);
|
||||
return s;
|
||||
RETURN_STATUS(s);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_name(...) (zbc_parse_name(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BC_STATUS zbc_parse_read(BcParse *p)
|
||||
{
|
||||
@ -3796,59 +3798,66 @@ static BC_STATUS zbc_parse_read(BcParse *p)
|
||||
# define zbc_parse_read(...) (zbc_parse_read(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_parse_builtin(BcParse *p, BcLexType type, uint8_t flags,
|
||||
static BC_STATUS zbc_parse_builtin(BcParse *p, BcLexType type, uint8_t flags,
|
||||
BcInst *prev)
|
||||
{
|
||||
BcStatus s;
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (p->l.t.t != BC_LEX_LPAREN) return bc_error_bad_token();
|
||||
if (s) RETURN_STATUS(s);
|
||||
if (p->l.t.t != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
|
||||
|
||||
flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
|
||||
s = zbc_parse_expr(p, flags, bc_parse_next_rel);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
|
||||
if (p->l.t.t != BC_LEX_RPAREN) return bc_error_bad_token();
|
||||
if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
|
||||
|
||||
*prev = (type == BC_LEX_KEY_LENGTH) ? BC_INST_LENGTH : BC_INST_SQRT;
|
||||
bc_parse_push(p, *prev);
|
||||
|
||||
return zbc_lex_next(&p->l);
|
||||
RETURN_STATUS(zbc_lex_next(&p->l));
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_builtin(...) (zbc_parse_builtin(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_parse_scale(BcParse *p, BcInst *type, uint8_t flags)
|
||||
static BC_STATUS zbc_parse_scale(BcParse *p, BcInst *type, uint8_t flags)
|
||||
{
|
||||
BcStatus s;
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
|
||||
if (p->l.t.t != BC_LEX_LPAREN) {
|
||||
*type = BC_INST_SCALE;
|
||||
bc_parse_push(p, BC_INST_SCALE);
|
||||
return BC_STATUS_SUCCESS;
|
||||
RETURN_STATUS(BC_STATUS_SUCCESS);
|
||||
}
|
||||
|
||||
*type = BC_INST_SCALE_FUNC;
|
||||
flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
|
||||
s = zbc_parse_expr(p, flags, bc_parse_next_rel);
|
||||
if (s) return s;
|
||||
if (p->l.t.t != BC_LEX_RPAREN) return bc_error_bad_token();
|
||||
if (s) RETURN_STATUS(s);
|
||||
if (p->l.t.t != BC_LEX_RPAREN)
|
||||
RETURN_STATUS(bc_error_bad_token());
|
||||
bc_parse_push(p, BC_INST_SCALE_FUNC);
|
||||
|
||||
return zbc_lex_next(&p->l);
|
||||
RETURN_STATUS(zbc_lex_next(&p->l));
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_scale(...) (zbc_parse_scale(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
|
||||
static BC_STATUS zbc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
|
||||
size_t *nexprs, uint8_t flags)
|
||||
{
|
||||
BcStatus s;
|
||||
@ -3865,12 +3874,11 @@ static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
|
||||
s = zbc_lex_next(&p->l);
|
||||
}
|
||||
else {
|
||||
|
||||
*prev = inst = BC_INST_INC_PRE + (p->l.t.t != BC_LEX_OP_INC);
|
||||
*paren_expr = true;
|
||||
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
type = p->l.t.t;
|
||||
|
||||
// Because we parse the next part of the expression
|
||||
@ -3878,45 +3886,36 @@ static BcStatus bc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
|
||||
*nexprs = *nexprs + 1;
|
||||
|
||||
switch (type) {
|
||||
|
||||
case BC_LEX_NAME:
|
||||
{
|
||||
s = bc_parse_name(p, prev, flags | BC_PARSE_NOCALL);
|
||||
s = zbc_parse_name(p, prev, flags | BC_PARSE_NOCALL);
|
||||
break;
|
||||
}
|
||||
|
||||
case BC_LEX_KEY_IBASE:
|
||||
case BC_LEX_KEY_LAST:
|
||||
case BC_LEX_KEY_OBASE:
|
||||
{
|
||||
bc_parse_push(p, type - BC_LEX_KEY_IBASE + BC_INST_IBASE);
|
||||
s = zbc_lex_next(&p->l);
|
||||
break;
|
||||
}
|
||||
|
||||
case BC_LEX_KEY_SCALE:
|
||||
{
|
||||
s = zbc_lex_next(&p->l);
|
||||
if (s) return s;
|
||||
if (s) RETURN_STATUS(s);
|
||||
if (p->l.t.t == BC_LEX_LPAREN)
|
||||
s = bc_error_bad_token();
|
||||
else
|
||||
bc_parse_push(p, BC_INST_SCALE);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
s = bc_error_bad_token();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!s) bc_parse_push(p, inst);
|
||||
}
|
||||
|
||||
return s;
|
||||
RETURN_STATUS(s);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_incdec(...) (zbc_parse_incdec(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BC_STATUS zbc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
|
||||
bool rparen, size_t *nexprs)
|
||||
@ -4634,17 +4633,17 @@ static BC_STATUS zbc_parse_stmt(BcParse *p)
|
||||
# define zbc_parse_stmt(...) (zbc_parse_stmt(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static FAST_FUNC BcStatus bc_parse_parse(BcParse *p)
|
||||
static FAST_FUNC BC_STATUS zbc_parse_parse(BcParse *p)
|
||||
{
|
||||
BcStatus s;
|
||||
|
||||
if (p->l.t.t == BC_LEX_EOF)
|
||||
s = p->flags.len > 0 ? bc_error("block end could not be found") : bc_error("end of file");
|
||||
else if (p->l.t.t == BC_LEX_KEY_DEFINE) {
|
||||
if (!BC_PARSE_CAN_EXEC(p)) return bc_error_bad_token();
|
||||
if (!BC_PARSE_CAN_EXEC(p))
|
||||
RETURN_STATUS(bc_error_bad_token());
|
||||
s = zbc_parse_func(p);
|
||||
}
|
||||
else
|
||||
} else
|
||||
s = zbc_parse_stmt(p);
|
||||
|
||||
if (s || G_interrupt) {
|
||||
@ -4652,8 +4651,11 @@ static FAST_FUNC BcStatus bc_parse_parse(BcParse *p)
|
||||
s = BC_STATUS_FAILURE;
|
||||
}
|
||||
|
||||
return s;
|
||||
RETURN_STATUS(s);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_parse_parse(...) (zbc_parse_parse(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
// This is not a "z" function: can also return BC_STATUS_PARSE_EMPTY_EXP
|
||||
static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext next)
|
||||
@ -4676,7 +4678,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
|
||||
case BC_LEX_OP_INC:
|
||||
case BC_LEX_OP_DEC:
|
||||
{
|
||||
s = bc_parse_incdec(p, &prev, &paren_expr, &nexprs, flags);
|
||||
s = zbc_parse_incdec(p, &prev, &paren_expr, &nexprs, flags);
|
||||
rprn = get_token = bin_last = false;
|
||||
break;
|
||||
}
|
||||
@ -4781,7 +4783,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
|
||||
return bc_error_bad_expression();
|
||||
paren_expr = true;
|
||||
rprn = get_token = bin_last = false;
|
||||
s = bc_parse_name(p, &prev, flags & ~BC_PARSE_NOCALL);
|
||||
s = zbc_parse_name(p, &prev, flags & ~BC_PARSE_NOCALL);
|
||||
++nexprs;
|
||||
|
||||
break;
|
||||
@ -4819,7 +4821,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
|
||||
{
|
||||
if (BC_PARSE_LEAF(prev, rprn))
|
||||
return bc_error_bad_expression();
|
||||
s = bc_parse_builtin(p, t, flags, &prev);
|
||||
s = zbc_parse_builtin(p, t, flags, &prev);
|
||||
paren_expr = true;
|
||||
rprn = get_token = bin_last = false;
|
||||
++nexprs;
|
||||
@ -4848,7 +4850,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
|
||||
{
|
||||
if (BC_PARSE_LEAF(prev, rprn))
|
||||
return bc_error_bad_expression();
|
||||
s = bc_parse_scale(p, &prev, flags);
|
||||
s = zbc_parse_scale(p, &prev, flags);
|
||||
paren_expr = true;
|
||||
rprn = get_token = bin_last = false;
|
||||
++nexprs;
|
||||
@ -4931,7 +4933,7 @@ static BC_STATUS zbc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
|
||||
|
||||
static void bc_parse_init(BcParse *p, size_t func)
|
||||
{
|
||||
bc_parse_create(p, func, bc_parse_parse, zbc_lex_token);
|
||||
bc_parse_create(p, func, zbc_parse_parse, zbc_lex_token);
|
||||
}
|
||||
|
||||
static BC_STATUS zbc_parse_expression(BcParse *p, uint8_t flags)
|
||||
@ -5135,7 +5137,7 @@ static BC_STATUS zdc_parse_expr(BcParse *p, uint8_t flags)
|
||||
# define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static FAST_FUNC BcStatus dc_parse_parse(BcParse *p)
|
||||
static FAST_FUNC BC_STATUS zdc_parse_parse(BcParse *p)
|
||||
{
|
||||
BcStatus s;
|
||||
|
||||
@ -5149,12 +5151,15 @@ static FAST_FUNC BcStatus dc_parse_parse(BcParse *p)
|
||||
s = BC_STATUS_FAILURE;
|
||||
}
|
||||
|
||||
return s;
|
||||
RETURN_STATUS(s);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zdc_parse_parse(...) (zdc_parse_parse(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static void dc_parse_init(BcParse *p, size_t func)
|
||||
{
|
||||
bc_parse_create(p, func, dc_parse_parse, zdc_lex_token);
|
||||
bc_parse_create(p, func, zdc_parse_parse, zdc_lex_token);
|
||||
}
|
||||
|
||||
#endif // ENABLE_DC
|
||||
@ -5368,10 +5373,7 @@ static BC_STATUS zbc_program_op(char inst)
|
||||
bc_num_init_DEF_SIZE(&res.d.n);
|
||||
|
||||
s = BC_STATUS_SUCCESS;
|
||||
#if !ERRORS_ARE_FATAL
|
||||
s =
|
||||
#endif
|
||||
zbc_program_ops[inst - BC_INST_POWER](n1, n2, &res.d.n, G.prog.scale);
|
||||
ERROR_RETURN(s =) zbc_program_ops[inst - BC_INST_POWER](n1, n2, &res.d.n, G.prog.scale);
|
||||
if (s) goto err;
|
||||
bc_program_binOpRetire(&res);
|
||||
|
||||
@ -5385,7 +5387,7 @@ err:
|
||||
# define zbc_program_op(...) (zbc_program_op(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static BcStatus bc_program_read(void)
|
||||
static BC_STATUS zbc_program_read(void)
|
||||
{
|
||||
const char *sv_file;
|
||||
BcStatus s;
|
||||
@ -5395,7 +5397,7 @@ static BcStatus bc_program_read(void)
|
||||
BcFunc *f;
|
||||
|
||||
if (G.in_read)
|
||||
return bc_error_nested_read_call();
|
||||
RETURN_STATUS(bc_error_nested_read_call());
|
||||
|
||||
f = bc_program_func(BC_PROG_READ);
|
||||
bc_vec_pop_all(&f->code);
|
||||
@ -5411,7 +5413,7 @@ static BcStatus bc_program_read(void)
|
||||
common_parse_init(&parse, BC_PROG_READ);
|
||||
bc_lex_file(&parse.l);
|
||||
|
||||
s = bc_parse_text(&parse, buf.v);
|
||||
s = zbc_parse_text(&parse, buf.v);
|
||||
if (s) goto exec_err;
|
||||
s = zcommon_parse_expr(&parse, BC_PARSE_NOREAD);
|
||||
if (s) goto exec_err;
|
||||
@ -5437,8 +5439,11 @@ exec_err:
|
||||
G.in_read = 0;
|
||||
G.prog.file = sv_file;
|
||||
bc_vec_free(&buf);
|
||||
return s;
|
||||
RETURN_STATUS(s);
|
||||
}
|
||||
#if ERRORS_ARE_FATAL
|
||||
# define zbc_program_read(...) (zbc_program_read(__VA_ARGS__), BC_STATUS_SUCCESS)
|
||||
#endif
|
||||
|
||||
static size_t bc_program_index(char *code, size_t *bgn)
|
||||
{
|
||||
@ -5958,10 +5963,7 @@ static BC_STATUS zbc_program_assign(char inst)
|
||||
bc_num_copy(l, r);
|
||||
else {
|
||||
s = BC_STATUS_SUCCESS;
|
||||
#if !ERRORS_ARE_FATAL
|
||||
s =
|
||||
#endif
|
||||
zbc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, G.prog.scale);
|
||||
ERROR_RETURN(s =) zbc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, G.prog.scale);
|
||||
}
|
||||
if (s) RETURN_STATUS(s);
|
||||
#else
|
||||
@ -6610,7 +6612,7 @@ static BcStatus bc_program_execStr(char *code, size_t *bgn,
|
||||
|
||||
if (f->code.len == 0) {
|
||||
common_parse_init(&prs, fidx);
|
||||
s = bc_parse_text(&prs, *str);
|
||||
s = zbc_parse_text(&prs, *str);
|
||||
if (s) goto err;
|
||||
s = zcommon_parse_expr(&prs, BC_PARSE_NOCALL);
|
||||
if (s) goto err;
|
||||
@ -6747,7 +6749,7 @@ static BcStatus bc_program_exec(void)
|
||||
s = zbc_program_logical(inst);
|
||||
break;
|
||||
case BC_INST_READ:
|
||||
s = bc_program_read();
|
||||
s = zbc_program_read();
|
||||
break;
|
||||
case BC_INST_VAR:
|
||||
s = zbc_program_pushVar(code, &ip->idx, false, false);
|
||||
@ -7002,12 +7004,12 @@ static unsigned bc_vm_envLen(const char *var)
|
||||
|
||||
static BcStatus bc_vm_process(const char *text)
|
||||
{
|
||||
BcStatus s = bc_parse_text(&G.prs, text);
|
||||
BcStatus s = zbc_parse_text(&G.prs, text);
|
||||
|
||||
if (s) return s;
|
||||
|
||||
while (G.prs.l.t.t != BC_LEX_EOF) {
|
||||
s = G.prs.parse(&G.prs);
|
||||
ERROR_RETURN(s =) G.prs.parse(&G.prs);
|
||||
if (s) return s;
|
||||
}
|
||||
|
||||
@ -7327,11 +7329,11 @@ static BcStatus bc_vm_exec(void)
|
||||
// thus error checking is normally disabled.
|
||||
# define DEBUG_LIB 0
|
||||
bc_lex_file(&G.prs.l);
|
||||
s = bc_parse_text(&G.prs, bc_lib);
|
||||
s = zbc_parse_text(&G.prs, bc_lib);
|
||||
if (DEBUG_LIB && s) return s;
|
||||
|
||||
while (G.prs.l.t.t != BC_LEX_EOF) {
|
||||
s = G.prs.parse(&G.prs);
|
||||
ERROR_RETURN(s =) G.prs.parse(&G.prs);
|
||||
if (DEBUG_LIB && s) return s;
|
||||
}
|
||||
s = bc_program_exec();
|
||||
|
||||
Loading…
Reference in New Issue
Block a user