}
#define zbc_num_parse(...) (zbc_num_parse(__VA_ARGS__) COMMA_SUCCESS)
-static void bc_lex_lineComment(BcLex *l)
+static void bc_lex_lineComment(void)
{
+ BcLex *l = &G.prs.l;
// Try: echo -n '#foo' | bc
size_t i;
l->lex = XC_LEX_WHITESPACE;
l->i = i;
}
-static void bc_lex_whitespace(BcLex *l)
+static void bc_lex_whitespace(void)
{
+ BcLex *l = &G.prs.l;
l->lex = XC_LEX_WHITESPACE;
for (;;) {
char c = l->buf[l->i];
}
}
-static BC_STATUS zbc_lex_number(BcLex *l, char start)
+static BC_STATUS zbc_lex_number(char start)
{
+ BcLex *l = &G.prs.l;
const char *buf = l->buf + l->i;
size_t len, i, ccnt;
bool pt;
}
#define zbc_lex_number(...) (zbc_lex_number(__VA_ARGS__) COMMA_SUCCESS)
-static void bc_lex_name(BcLex *l)
+static void bc_lex_name(void)
{
+ BcLex *l = &G.prs.l;
size_t i;
const char *buf;
//return BC_STATUS_SUCCESS;
}
-static void bc_lex_init(BcLex *l)
+static void bc_lex_init(void)
{
- bc_char_vec_init(&l->lex_buf);
+ bc_char_vec_init(&G.prs.l.lex_buf);
}
-static void bc_lex_free(BcLex *l)
+static void bc_lex_free(void)
{
- bc_vec_free(&l->lex_buf);
+ bc_vec_free(&G.prs.l.lex_buf);
}
-static void bc_lex_file(BcLex *l)
+static void bc_lex_file(void)
{
- G.err_line = l->line = 1;
- l->newline = false;
+ G.err_line = G.prs.l.line = 1;
+ G.prs.l.newline = false;
}
-static bool bc_lex_more_input(BcLex *l)
+static bool bc_lex_more_input(void)
{
+ BcLex *l = &G.prs.l;
size_t str;
bool comment;
return l->len != 0;
}
-IF_BC(static BC_STATUS zbc_lex_token(BcLex *l);)
-IF_DC(static BC_STATUS zdc_lex_token(BcLex *l);)
+IF_BC(static BC_STATUS zbc_lex_token(void);)
+IF_DC(static BC_STATUS zdc_lex_token(void);)
#define zbc_lex_token(...) (zbc_lex_token(__VA_ARGS__) COMMA_SUCCESS)
#define zdc_lex_token(...) (zdc_lex_token(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_lex_next(BcLex *l)
+static BC_STATUS zbc_lex_next(void)
{
+ BcLex *l = &G.prs.l;
BcStatus s;
l->lex_last = l->lex;
l->lex = XC_LEX_EOF;
if (!G.prs.input_fp)
RETURN_STATUS(BC_STATUS_SUCCESS);
- if (!bc_lex_more_input(l)) {
+ if (!bc_lex_more_input()) {
G.prs.input_fp = NULL;
RETURN_STATUS(BC_STATUS_SUCCESS);
}
l->lex_next_at
);
if (IS_BC) {
- IF_BC(s = zbc_lex_token(l));
+ IF_BC(s = zbc_lex_token());
} else {
- IF_DC(s = zdc_lex_token(l));
+ IF_DC(s = zdc_lex_token());
}
} while (!s && l->lex == XC_LEX_WHITESPACE);
dbg_lex("l->lex from string:%d", l->lex);
#define zbc_lex_next(...) (zbc_lex_next(__VA_ARGS__) COMMA_SUCCESS)
#if ENABLE_BC
-static BC_STATUS zbc_lex_skip_if_at_NLINE(BcLex *l)
+static BC_STATUS zbc_lex_skip_if_at_NLINE(void)
{
- if (l->lex == XC_LEX_NLINE)
- RETURN_STATUS(zbc_lex_next(l));
+ if (G.prs.l.lex == XC_LEX_NLINE)
+ RETURN_STATUS(zbc_lex_next());
RETURN_STATUS(BC_STATUS_SUCCESS);
}
#define zbc_lex_skip_if_at_NLINE(...) (zbc_lex_skip_if_at_NLINE(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_lex_next_and_skip_NLINE(BcLex *l)
+static BC_STATUS zbc_lex_next_and_skip_NLINE(void)
{
BcStatus s;
- s = zbc_lex_next(l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
// if(cond)<newline>stmt is accepted too (but not 2+ newlines)
- s = zbc_lex_skip_if_at_NLINE(l);
+ s = zbc_lex_skip_if_at_NLINE();
RETURN_STATUS(s);
}
#define zbc_lex_next_and_skip_NLINE(...) (zbc_lex_next_and_skip_NLINE(__VA_ARGS__) COMMA_SUCCESS)
#endif
-static BC_STATUS zbc_lex_text_init(BcLex *l, const char *text)
+static BC_STATUS zbc_lex_text_init(const char *text)
{
- l->buf = text;
- l->i = 0;
- l->len = strlen(text);
- l->lex = l->lex_last = XC_LEX_INVALID;
- RETURN_STATUS(zbc_lex_next(l));
+ G.prs.l.buf = text;
+ G.prs.l.i = 0;
+ G.prs.l.len = strlen(text);
+ G.prs.l.lex = G.prs.l.lex_last = XC_LEX_INVALID;
+ RETURN_STATUS(zbc_lex_next());
}
#define zbc_lex_text_init(...) (zbc_lex_text_init(__VA_ARGS__) COMMA_SUCCESS)
#if ENABLE_BC
-static BC_STATUS zbc_lex_identifier(BcLex *l)
+static BC_STATUS zbc_lex_identifier(void)
{
+ BcLex *l = &G.prs.l;
BcStatus s;
unsigned i;
const char *buf = l->buf + l->i - 1;
RETURN_STATUS(BC_STATUS_SUCCESS);
}
- bc_lex_name(l);
+ bc_lex_name();
s = BC_STATUS_SUCCESS;
if (l->lex_buf.len > 2) {
}
#define zbc_lex_identifier(...) (zbc_lex_identifier(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_lex_string(BcLex *l)
+static BC_STATUS zbc_lex_string(void)
{
+ BcLex *l = &G.prs.l;
size_t len, nls, i;
l->lex = XC_LEX_STR;
}
#define zbc_lex_string(...) (zbc_lex_string(__VA_ARGS__) COMMA_SUCCESS)
-static void bc_lex_assign(BcLex *l, unsigned with_and_without)
+static void bc_lex_assign(unsigned with_and_without)
{
+ BcLex *l = &G.prs.l;
if (l->buf[l->i] == '=') {
++l->i;
with_and_without >>= 8; // store "with" value
} // else store "without" value
l->lex = (with_and_without & 0xff);
}
-#define bc_lex_assign(l, with, without) \
- bc_lex_assign(l, ((with)<<8)|(without))
+#define bc_lex_assign(with, without) \
+ bc_lex_assign(((with)<<8)|(without))
-static BC_STATUS zbc_lex_comment(BcLex *l)
+static BC_STATUS zbc_lex_comment(void)
{
+ BcLex *l = &G.prs.l;
size_t i, nls = 0;
const char *buf = l->buf;
#define zbc_lex_comment(...) (zbc_lex_comment(__VA_ARGS__) COMMA_SUCCESS)
#undef zbc_lex_token
-static BC_STATUS zbc_lex_token(BcLex *l)
+static BC_STATUS zbc_lex_token(void)
{
+ BcLex *l = &G.prs.l;
BcStatus s = BC_STATUS_SUCCESS;
char c = l->buf[l->i++], c2;
case '\f':
case '\r':
case ' ':
- bc_lex_whitespace(l);
+ bc_lex_whitespace();
break;
case '!':
- bc_lex_assign(l, XC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT);
+ bc_lex_assign(XC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT);
if (l->lex == BC_LEX_OP_BOOL_NOT) {
s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("!");
if (s) RETURN_STATUS(s);
}
break;
case '"':
- s = zbc_lex_string(l);
+ s = zbc_lex_string();
break;
case '#':
s = zbc_POSIX_does_not_allow("'#' script comments");
if (s) RETURN_STATUS(s);
- bc_lex_lineComment(l);
+ bc_lex_lineComment();
break;
case '%':
- bc_lex_assign(l, BC_LEX_OP_ASSIGN_MODULUS, XC_LEX_OP_MODULUS);
+ bc_lex_assign(BC_LEX_OP_ASSIGN_MODULUS, XC_LEX_OP_MODULUS);
break;
case '&':
c2 = l->buf[l->i];
l->lex = (BcLexType)(c - '(' + BC_LEX_LPAREN);
break;
case '*':
- bc_lex_assign(l, BC_LEX_OP_ASSIGN_MULTIPLY, XC_LEX_OP_MULTIPLY);
+ bc_lex_assign(BC_LEX_OP_ASSIGN_MULTIPLY, XC_LEX_OP_MULTIPLY);
break;
case '+':
c2 = l->buf[l->i];
++l->i;
l->lex = BC_LEX_OP_INC;
} else
- bc_lex_assign(l, BC_LEX_OP_ASSIGN_PLUS, XC_LEX_OP_PLUS);
+ bc_lex_assign(BC_LEX_OP_ASSIGN_PLUS, XC_LEX_OP_PLUS);
break;
case ',':
l->lex = BC_LEX_COMMA;
++l->i;
l->lex = BC_LEX_OP_DEC;
} else
- bc_lex_assign(l, BC_LEX_OP_ASSIGN_MINUS, XC_LEX_OP_MINUS);
+ bc_lex_assign(BC_LEX_OP_ASSIGN_MINUS, XC_LEX_OP_MINUS);
break;
case '.':
if (isdigit(l->buf[l->i]))
- s = zbc_lex_number(l, c);
+ s = zbc_lex_number(c);
else {
l->lex = BC_LEX_KEY_LAST;
s = zbc_POSIX_does_not_allow("a period ('.') as a shortcut for the last result");
case '/':
c2 = l->buf[l->i];
if (c2 == '*')
- s = zbc_lex_comment(l);
+ s = zbc_lex_comment();
else
- bc_lex_assign(l, BC_LEX_OP_ASSIGN_DIVIDE, XC_LEX_OP_DIVIDE);
+ bc_lex_assign(BC_LEX_OP_ASSIGN_DIVIDE, XC_LEX_OP_DIVIDE);
break;
case '0':
case '1':
case 'D':
case 'E':
case 'F':
- s = zbc_lex_number(l, c);
+ s = zbc_lex_number(c);
break;
case ';':
l->lex = BC_LEX_SCOLON;
break;
case '<':
- bc_lex_assign(l, XC_LEX_OP_REL_LE, XC_LEX_OP_REL_LT);
+ bc_lex_assign(XC_LEX_OP_REL_LE, XC_LEX_OP_REL_LT);
break;
case '=':
- bc_lex_assign(l, XC_LEX_OP_REL_EQ, BC_LEX_OP_ASSIGN);
+ bc_lex_assign(XC_LEX_OP_REL_EQ, BC_LEX_OP_ASSIGN);
break;
case '>':
- bc_lex_assign(l, XC_LEX_OP_REL_GE, XC_LEX_OP_REL_GT);
+ bc_lex_assign(XC_LEX_OP_REL_GE, XC_LEX_OP_REL_GT);
break;
case '[':
case ']':
s = bc_error_bad_character(c);
break;
case '^':
- bc_lex_assign(l, BC_LEX_OP_ASSIGN_POWER, XC_LEX_OP_POWER);
+ bc_lex_assign(BC_LEX_OP_ASSIGN_POWER, XC_LEX_OP_POWER);
break;
case 'a':
case 'b':
case 'x':
case 'y':
case 'z':
- s = zbc_lex_identifier(l);
+ s = zbc_lex_identifier();
break;
case '{':
case '}':
#endif // ENABLE_BC
#if ENABLE_DC
-static BC_STATUS zdc_lex_register(BcLex *l)
+static BC_STATUS zdc_lex_register(void)
{
+ BcLex *l = &G.prs.l;
if (G_exreg && isspace(l->buf[l->i])) {
- bc_lex_whitespace(l); // eats whitespace (but not newline)
+ bc_lex_whitespace(); // eats whitespace (but not newline)
l->i++; // bc_lex_name() expects this
- bc_lex_name(l);
+ bc_lex_name();
} else {
bc_vec_pop_all(&l->lex_buf);
bc_vec_push(&l->lex_buf, &l->buf[l->i++]);
}
#define zdc_lex_register(...) (zdc_lex_register(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zdc_lex_string(BcLex *l)
+static BC_STATUS zdc_lex_string(void)
{
+ BcLex *l = &G.prs.l;
size_t depth, nls, i;
l->lex = XC_LEX_STR;
#define zdc_lex_string(...) (zdc_lex_string(__VA_ARGS__) COMMA_SUCCESS)
#undef zdc_lex_token
-static BC_STATUS zdc_lex_token(BcLex *l)
+static BC_STATUS zdc_lex_token(void)
{
+ BcLex *l = &G.prs.l;
static const //BcLexType - should be this type, but narrower type saves size:
uint8_t
dc_lex_regs[] = {
for (i = 0; i < ARRAY_SIZE(dc_lex_regs); ++i) {
if (l->lex_last == dc_lex_regs[i])
- RETURN_STATUS(zdc_lex_register(l));
+ RETURN_STATUS(zdc_lex_register());
}
s = BC_STATUS_SUCCESS;
case '\r':
case ' ':
l->newline = 0; // was (c == '\n')
- bc_lex_whitespace(l);
+ bc_lex_whitespace();
break;
case '!':
c2 = l->buf[l->i];
++l->i;
break;
case '#':
- bc_lex_lineComment(l);
+ bc_lex_lineComment();
break;
case '.':
if (isdigit(l->buf[l->i]))
- s = zbc_lex_number(l, c);
+ s = zbc_lex_number(c);
else
s = bc_error_bad_character(c);
break;
case 'D':
case 'E':
case 'F':
- s = zbc_lex_number(l, c);
+ s = zbc_lex_number(c);
break;
case '[':
- s = zdc_lex_string(l);
+ s = zdc_lex_string();
break;
default:
l->lex = XC_LEX_INVALID;
#define zdc_lex_token(...) (zdc_lex_token(__VA_ARGS__) COMMA_SUCCESS)
#endif // ENABLE_DC
-static void bc_parse_push(BcParse *p, char i)
+static void bc_parse_push(char i)
{
+ BcParse *p = &G.prs;
dbg_compile("%s:%d pushing bytecode %zd:%d", __func__, __LINE__, p->func->code.len, i);
bc_vec_pushByte(&p->func->code, i);
}
-static void bc_parse_pushName(BcParse *p, char *name)
+static void bc_parse_pushName(char *name)
{
while (*name)
- bc_parse_push(p, *name++);
- bc_parse_push(p, BC_PARSE_STREND);
+ bc_parse_push(*name++);
+ bc_parse_push(BC_PARSE_STREND);
}
-static void bc_parse_pushIndex(BcParse *p, size_t idx)
+static void bc_parse_pushIndex(size_t idx)
{
size_t mask;
unsigned amt;
amt--;
} while (amt != 0);
- bc_parse_push(p, amt);
+ bc_parse_push(amt);
while (idx != 0) {
- bc_parse_push(p, (unsigned char)idx);
+ bc_parse_push((unsigned char)idx);
idx >>= 8;
}
}
#if ENABLE_BC
-static void bc_parse_pushJUMP(BcParse *p, size_t idx)
+static void bc_parse_pushJUMP(size_t idx)
{
- bc_parse_push(p, BC_INST_JUMP);
- bc_parse_pushIndex(p, idx);
+ bc_parse_push(BC_INST_JUMP);
+ bc_parse_pushIndex(idx);
}
-static void bc_parse_pushJUMP_ZERO(BcParse *p, size_t idx)
+static void bc_parse_pushJUMP_ZERO(size_t idx)
{
- bc_parse_push(p, BC_INST_JUMP_ZERO);
- bc_parse_pushIndex(p, idx);
+ bc_parse_push(BC_INST_JUMP_ZERO);
+ bc_parse_pushIndex(idx);
}
-static BC_STATUS zbc_parse_pushSTR(BcParse *p)
+static BC_STATUS zbc_parse_pushSTR(void)
{
+ BcParse *p = &G.prs;
char *str = xstrdup(p->l.lex_buf.v);
- bc_parse_push(p, XC_INST_STR);
- bc_parse_pushIndex(p, p->func->strs.len);
+ bc_parse_push(XC_INST_STR);
+ bc_parse_pushIndex(p->func->strs.len);
bc_vec_push(&p->func->strs, &str);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ RETURN_STATUS(zbc_lex_next());
}
#define zbc_parse_pushSTR(...) (zbc_parse_pushSTR(__VA_ARGS__) COMMA_SUCCESS)
#endif
-static void bc_parse_pushNUM(BcParse *p)
+static void bc_parse_pushNUM(void)
{
+ BcParse *p = &G.prs;
char *num = xstrdup(p->l.lex_buf.v);
#if ENABLE_BC && ENABLE_DC
size_t idx = bc_vec_push(IS_BC ? &p->func->consts : &G.prog.consts, &num);
#else // DC
size_t idx = bc_vec_push(&G.prog.consts, &num);
#endif
- bc_parse_push(p, XC_INST_NUM);
- bc_parse_pushIndex(p, idx);
+ bc_parse_push(XC_INST_NUM);
+ bc_parse_pushIndex(idx);
}
-static BC_STATUS zbc_parse_text_init(BcParse *p, const char *text)
+static BC_STATUS zbc_parse_text_init(const char *text)
{
+ BcParse *p = &G.prs;
p->func = bc_program_func(p->fidx);
- RETURN_STATUS(zbc_lex_text_init(&p->l, text));
+ RETURN_STATUS(zbc_lex_text_init(text));
}
#define zbc_parse_text_init(...) (zbc_parse_text_init(__VA_ARGS__) COMMA_SUCCESS)
// Called when parsing code detects a failure,
// resets parsing structures.
-static void bc_parse_reset(BcParse *p)
+static void bc_parse_reset(void)
{
+ BcParse *p = &G.prs;
if (p->fidx != BC_PROG_MAIN) {
bc_func_free(p->func);
bc_func_init(p->func);
bc_program_reset();
}
-static void bc_parse_free(BcParse *p)
+static void bc_parse_free(void)
{
+ BcParse *p = &G.prs;
IF_BC(bc_vec_free(&p->exits);)
IF_BC(bc_vec_free(&p->conds);)
IF_BC(bc_vec_free(&p->ops);)
- bc_lex_free(&p->l);
+ bc_lex_free();
}
-static void bc_parse_create(BcParse *p, size_t fidx)
+static void bc_parse_create(size_t fidx)
{
+ BcParse *p = &G.prs;
memset(p, 0, sizeof(BcParse));
- bc_lex_init(&p->l);
+ bc_lex_init();
IF_BC(bc_vec_init(&p->exits, sizeof(size_t), NULL);)
IF_BC(bc_vec_init(&p->conds, sizeof(size_t), NULL);)
IF_BC(bc_vec_init(&p->ops, sizeof(BcLexType), NULL);)
// first in the expr enum. Note: This only works for binary operators.
#define BC_TOKEN_2_INST(t) ((char) ((t) - XC_LEX_OP_POWER + XC_INST_POWER))
-static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags);
+static BcStatus bc_parse_expr_empty_ok(uint8_t flags);
-static BC_STATUS zbc_parse_expr(BcParse *p, uint8_t flags)
+static BC_STATUS zbc_parse_expr(uint8_t flags)
{
BcStatus s;
- s = bc_parse_expr_empty_ok(p, flags);
+ s = bc_parse_expr_empty_ok(flags);
if (s == BC_STATUS_PARSE_EMPTY_EXP)
RETURN_STATUS(bc_error("empty expression"));
RETURN_STATUS(s);
}
#define zbc_parse_expr(...) (zbc_parse_expr(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_stmt_possibly_auto(BcParse *p, bool auto_allowed);
+static BC_STATUS zbc_parse_stmt_possibly_auto(bool auto_allowed);
#define zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_stmt(BcParse *p)
+static BC_STATUS zbc_parse_stmt(void)
{
- RETURN_STATUS(zbc_parse_stmt_possibly_auto(p, false));
+ RETURN_STATUS(zbc_parse_stmt_possibly_auto(false));
}
#define zbc_parse_stmt(...) (zbc_parse_stmt(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_stmt_allow_NLINE_before(BcParse *p, const char *after_X)
+static BC_STATUS zbc_parse_stmt_allow_NLINE_before(const char *after_X)
{
+ BcParse *p = &G.prs;
// "if(cond)<newline>stmt" is accepted too, but not 2+ newlines.
// Same for "else", "while()", "for()".
- BcStatus s = zbc_lex_next_and_skip_NLINE(&p->l);
+ BcStatus s = zbc_lex_next_and_skip_NLINE();
if (s) RETURN_STATUS(s);
if (p->l.lex == XC_LEX_NLINE)
RETURN_STATUS(bc_error_fmt("no statement after '%s'", after_X));
- RETURN_STATUS(zbc_parse_stmt(p));
+ RETURN_STATUS(zbc_parse_stmt());
}
#define zbc_parse_stmt_allow_NLINE_before(...) (zbc_parse_stmt_allow_NLINE_before(__VA_ARGS__) COMMA_SUCCESS)
-static void bc_parse_operator(BcParse *p, BcLexType type, size_t start,
- size_t *nexprs)
+static void bc_parse_operator(BcLexType type, size_t start, size_t *nexprs)
{
+ BcParse *p = &G.prs;
char l, r = bc_parse_op_PREC(type - XC_LEX_1st_op);
bool left = bc_parse_op_LEFT(type - XC_LEX_1st_op);
l = bc_parse_op_PREC(t - XC_LEX_1st_op);
if (l >= r && (l != r || !left)) break;
- bc_parse_push(p, BC_TOKEN_2_INST(t));
+ bc_parse_push(BC_TOKEN_2_INST(t));
bc_vec_pop(&p->ops);
*nexprs -= (t != BC_LEX_OP_BOOL_NOT && t != XC_LEX_NEG);
}
bc_vec_push(&p->ops, &type);
}
-static BC_STATUS zbc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs)
+static BC_STATUS zbc_parse_rightParen(size_t ops_bgn, size_t *nexs)
{
+ BcParse *p = &G.prs;
BcLexType top;
if (p->ops.len <= ops_bgn)
top = BC_PARSE_TOP_OP(p);
while (top != BC_LEX_LPAREN) {
- bc_parse_push(p, BC_TOKEN_2_INST(top));
+ bc_parse_push(BC_TOKEN_2_INST(top));
bc_vec_pop(&p->ops);
*nexs -= (top != BC_LEX_OP_BOOL_NOT && top != XC_LEX_NEG);
}
#define zbc_parse_rightParen(...) (zbc_parse_rightParen(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_params(BcParse *p, uint8_t flags)
+static BC_STATUS zbc_parse_params(uint8_t flags)
{
+ BcParse *p = &G.prs;
BcStatus s;
size_t nparams;
dbg_lex("%s:%d p->l.lex:%d", __func__, __LINE__, p->l.lex);
flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
nparams = 0;
if (p->l.lex != BC_LEX_RPAREN) {
for (;;) {
- s = zbc_parse_expr(p, flags);
+ s = zbc_parse_expr(flags);
if (s) RETURN_STATUS(s);
nparams++;
if (p->l.lex != BC_LEX_COMMA) {
break;
RETURN_STATUS(bc_error_bad_token());
}
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
}
}
- bc_parse_push(p, BC_INST_CALL);
- bc_parse_pushIndex(p, nparams);
+ bc_parse_push(BC_INST_CALL);
+ bc_parse_pushIndex(nparams);
RETURN_STATUS(BC_STATUS_SUCCESS);
}
#define zbc_parse_params(...) (zbc_parse_params(__VA_ARGS__) COMMA_SUCCESS)
// Note: takes ownership of 'name' (must be malloced)
-static BC_STATUS zbc_parse_call(BcParse *p, char *name, uint8_t flags)
+static BC_STATUS zbc_parse_call(char *name, uint8_t flags)
{
+ BcParse *p = &G.prs;
BcStatus s;
BcId entry, *entry_ptr;
size_t idx;
entry.name = name;
- s = zbc_parse_params(p, flags);
+ s = zbc_parse_params(flags);
if (s) goto err;
if (p->l.lex != BC_LEX_RPAREN) {
free(name);
entry_ptr = bc_vec_item(&G.prog.fn_map, idx);
- bc_parse_pushIndex(p, entry_ptr->idx);
+ bc_parse_pushIndex(entry_ptr->idx);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ RETURN_STATUS(zbc_lex_next());
err:
free(name);
RETURN_STATUS(s);
}
#define zbc_parse_call(...) (zbc_parse_call(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_name(BcParse *p, BcInst *type, uint8_t flags)
+static BC_STATUS zbc_parse_name(BcInst *type, uint8_t flags)
{
+ BcParse *p = &G.prs;
BcStatus s;
char *name;
name = xstrdup(p->l.lex_buf.v);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
if (p->l.lex == BC_LEX_LBRACKET) {
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
if (p->l.lex == BC_LEX_RBRACKET) {
} else {
*type = XC_INST_ARRAY_ELEM;
flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
- s = zbc_parse_expr(p, flags);
+ s = zbc_parse_expr(flags);
if (s) goto err;
}
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
- bc_parse_push(p, *type);
- bc_parse_pushName(p, name);
+ bc_parse_push(*type);
+ bc_parse_pushName(name);
free(name);
} else if (p->l.lex == BC_LEX_LPAREN) {
if (flags & BC_PARSE_NOCALL) {
goto err;
}
*type = BC_INST_CALL;
- s = zbc_parse_call(p, name, flags);
+ s = zbc_parse_call(name, flags);
} else {
*type = XC_INST_VAR;
- bc_parse_push(p, XC_INST_VAR);
- bc_parse_pushName(p, name);
+ bc_parse_push(XC_INST_VAR);
+ bc_parse_pushName(name);
free(name);
}
}
#define zbc_parse_name(...) (zbc_parse_name(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_read(BcParse *p)
+static BC_STATUS zbc_parse_read(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
- bc_parse_push(p, XC_INST_READ);
+ bc_parse_push(XC_INST_READ);
RETURN_STATUS(s);
}
#define zbc_parse_read(...) (zbc_parse_read(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_builtin(BcParse *p, BcLexType type, uint8_t flags,
- BcInst *prev)
+static BC_STATUS zbc_parse_builtin(BcLexType type, uint8_t flags, BcInst *prev)
{
+ BcParse *p = &G.prs;
BcStatus s;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != 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);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
- s = zbc_parse_expr(p, flags);
+ s = zbc_parse_expr(flags);
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
*prev = (type == BC_LEX_KEY_LENGTH) ? XC_INST_LENGTH : XC_INST_SQRT;
- bc_parse_push(p, *prev);
+ bc_parse_push(*prev);
RETURN_STATUS(s);
}
#define zbc_parse_builtin(...) (zbc_parse_builtin(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_scale(BcParse *p, BcInst *type, uint8_t flags)
+static BC_STATUS zbc_parse_scale(BcInst *type, uint8_t flags)
{
+ BcParse *p = &G.prs;
BcStatus s;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_LPAREN) {
*type = XC_INST_SCALE;
- bc_parse_push(p, XC_INST_SCALE);
+ bc_parse_push(XC_INST_SCALE);
RETURN_STATUS(BC_STATUS_SUCCESS);
}
*type = XC_INST_SCALE_FUNC;
flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
- s = zbc_parse_expr(p, flags);
+ s = zbc_parse_expr(flags);
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_RPAREN)
RETURN_STATUS(bc_error_bad_token());
- bc_parse_push(p, XC_INST_SCALE_FUNC);
+ bc_parse_push(XC_INST_SCALE_FUNC);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ RETURN_STATUS(zbc_lex_next());
}
#define zbc_parse_scale(...) (zbc_parse_scale(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
- size_t *nexprs, uint8_t flags)
+static BC_STATUS zbc_parse_incdec(BcInst *prev, bool *paren_expr,
+ size_t *nexprs, uint8_t flags)
{
+ BcParse *p = &G.prs;
BcStatus s;
BcLexType type;
char inst;
|| etype == XC_INST_IBASE || etype == XC_INST_OBASE
) {
*prev = inst = BC_INST_INC_POST + (p->l.lex != BC_LEX_OP_INC);
- bc_parse_push(p, inst);
- s = zbc_lex_next(&p->l);
+ bc_parse_push(inst);
+ s = zbc_lex_next();
} else {
*prev = inst = BC_INST_INC_PRE + (p->l.lex != BC_LEX_OP_INC);
*paren_expr = true;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
type = p->l.lex;
switch (type) {
case XC_LEX_NAME:
- s = zbc_parse_name(p, prev, flags | BC_PARSE_NOCALL);
+ s = zbc_parse_name(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 + XC_INST_IBASE);
- s = zbc_lex_next(&p->l);
+ bc_parse_push(type - BC_LEX_KEY_IBASE + XC_INST_IBASE);
+ s = zbc_lex_next();
break;
case BC_LEX_KEY_SCALE:
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex == BC_LEX_LPAREN)
s = bc_error_bad_token();
else
- bc_parse_push(p, XC_INST_SCALE);
+ bc_parse_push(XC_INST_SCALE);
break;
default:
s = bc_error_bad_token();
break;
}
- if (!s) bc_parse_push(p, inst);
+ if (!s) bc_parse_push(inst);
}
RETURN_STATUS(s);
#define BC_PARSE_LEAF(p, rparen) ((rparen) || ok_in_expr(p))
#endif
-static BC_STATUS zbc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
- bool rparen, size_t *nexprs)
+static BC_STATUS zbc_parse_minus(BcInst *prev, size_t ops_bgn,
+ bool rparen, size_t *nexprs)
{
+ BcParse *p = &G.prs;
BcStatus s;
BcLexType type;
BcInst etype = *prev;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
type = BC_PARSE_LEAF(etype, rparen) ? XC_LEX_OP_MINUS : XC_LEX_NEG;
if (type != XC_LEX_OP_MINUS)
bc_vec_push(&p->ops, &type);
else
- bc_parse_operator(p, type, ops_bgn, nexprs);
+ bc_parse_operator(type, ops_bgn, nexprs);
RETURN_STATUS(s);
}
#define zbc_parse_minus(...) (zbc_parse_minus(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_print(BcParse *p)
+static BC_STATUS zbc_parse_print(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
BcLexType type;
for (;;) {
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
type = p->l.lex;
if (type == XC_LEX_STR) {
- s = zbc_parse_pushSTR(p);
+ s = zbc_parse_pushSTR();
} else {
- s = zbc_parse_expr(p, 0);
+ s = zbc_parse_expr(0);
}
if (s) RETURN_STATUS(s);
- bc_parse_push(p, XC_INST_PRINT_POP);
+ bc_parse_push(XC_INST_PRINT_POP);
if (p->l.lex != BC_LEX_COMMA)
break;
}
}
#define zbc_parse_print(...) (zbc_parse_print(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_return(BcParse *p)
+static BC_STATUS zbc_parse_return(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
BcLexType t;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
t = p->l.lex;
if (t == XC_LEX_NLINE || t == BC_LEX_SCOLON)
- bc_parse_push(p, BC_INST_RET0);
+ bc_parse_push(BC_INST_RET0);
else {
bool paren = (t == BC_LEX_LPAREN);
- s = bc_parse_expr_empty_ok(p, 0);
+ s = bc_parse_expr_empty_ok(0);
if (s == BC_STATUS_PARSE_EMPTY_EXP) {
- bc_parse_push(p, BC_INST_RET0);
- s = zbc_lex_next(&p->l);
+ bc_parse_push(BC_INST_RET0);
+ s = zbc_lex_next();
}
if (s) RETURN_STATUS(s);
if (s) RETURN_STATUS(s);
}
- bc_parse_push(p, XC_INST_RET);
+ bc_parse_push(XC_INST_RET);
}
dbg_lex_done("%s:%d done", __func__, __LINE__);
}
#define zbc_parse_return(...) (zbc_parse_return(__VA_ARGS__) COMMA_SUCCESS)
-static void rewrite_label_to_current(BcParse *p, size_t idx)
+static void rewrite_label_to_current(size_t idx)
{
+ BcParse *p = &G.prs;
size_t *label = bc_vec_item(&p->func->labels, idx);
*label = p->func->code.len;
}
-static BC_STATUS zbc_parse_if(BcParse *p)
+static BC_STATUS zbc_parse_if(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
size_t ip_idx;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
- s = zbc_parse_expr(p, BC_PARSE_REL);
+ s = zbc_parse_expr(BC_PARSE_REL);
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
// Pushed value (destination of the jump) is uninitialized,
// will be rewritten to be address of "end of if()" or of "else".
ip_idx = bc_vec_push(&p->func->labels, &ip_idx);
- bc_parse_pushJUMP_ZERO(p, ip_idx);
+ bc_parse_pushJUMP_ZERO(ip_idx);
- s = zbc_parse_stmt_allow_NLINE_before(p, STRING_if);
+ s = zbc_parse_stmt_allow_NLINE_before(STRING_if);
if (s) RETURN_STATUS(s);
dbg_lex("%s:%d in if after stmt: p->l.lex:%d", __func__, __LINE__, p->l.lex);
// Encode "after then_stmt, jump to end of if()"
ip2_idx = bc_vec_push(&p->func->labels, &ip2_idx);
dbg_lex("%s:%d after if() then_stmt: BC_INST_JUMP to %zd", __func__, __LINE__, ip2_idx);
- bc_parse_pushJUMP(p, ip2_idx);
+ bc_parse_pushJUMP(ip2_idx);
dbg_lex("%s:%d rewriting 'if_zero' label to jump to 'else'-> %zd", __func__, __LINE__, p->func->code.len);
- rewrite_label_to_current(p, ip_idx);
+ rewrite_label_to_current(ip_idx);
ip_idx = ip2_idx;
- s = zbc_parse_stmt_allow_NLINE_before(p, STRING_else);
+ s = zbc_parse_stmt_allow_NLINE_before(STRING_else);
if (s) RETURN_STATUS(s);
}
dbg_lex("%s:%d rewriting label to jump after 'if' body-> %zd", __func__, __LINE__, p->func->code.len);
- rewrite_label_to_current(p, ip_idx);
+ rewrite_label_to_current(ip_idx);
dbg_lex_done("%s:%d done", __func__, __LINE__);
RETURN_STATUS(s);
}
#define zbc_parse_if(...) (zbc_parse_if(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_while(BcParse *p)
+static BC_STATUS zbc_parse_while(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
size_t cond_idx;
size_t ip_idx;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
cond_idx = bc_vec_push(&p->func->labels, &p->func->code.len);
bc_vec_push(&p->exits, &ip_idx);
bc_vec_push(&p->func->labels, &ip_idx);
- s = zbc_parse_expr(p, BC_PARSE_REL);
+ s = zbc_parse_expr(BC_PARSE_REL);
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
- bc_parse_pushJUMP_ZERO(p, ip_idx);
+ bc_parse_pushJUMP_ZERO(ip_idx);
- s = zbc_parse_stmt_allow_NLINE_before(p, STRING_while);
+ s = zbc_parse_stmt_allow_NLINE_before(STRING_while);
if (s) RETURN_STATUS(s);
dbg_lex("%s:%d BC_INST_JUMP to %zd", __func__, __LINE__, cond_idx);
- bc_parse_pushJUMP(p, cond_idx);
+ bc_parse_pushJUMP(cond_idx);
dbg_lex("%s:%d rewriting label-> %zd", __func__, __LINE__, p->func->code.len);
- rewrite_label_to_current(p, ip_idx);
+ rewrite_label_to_current(ip_idx);
bc_vec_pop(&p->exits);
bc_vec_pop(&p->conds);
}
#define zbc_parse_while(...) (zbc_parse_while(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_for(BcParse *p)
+static BC_STATUS zbc_parse_for(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
size_t cond_idx, exit_idx, body_idx, update_idx;
dbg_lex("%s:%d p->l.lex:%d", __func__, __LINE__, p->l.lex);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_SCOLON) {
- s = zbc_parse_expr(p, 0);
- bc_parse_push(p, XC_INST_POP);
+ s = zbc_parse_expr(0);
+ bc_parse_push(XC_INST_POP);
if (s) RETURN_STATUS(s);
} else {
s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("init");
}
if (p->l.lex != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
cond_idx = bc_vec_push(&p->func->labels, &p->func->code.len);
exit_idx = body_idx + 1;
if (p->l.lex != BC_LEX_SCOLON)
- s = zbc_parse_expr(p, BC_PARSE_REL);
+ s = zbc_parse_expr(BC_PARSE_REL);
else {
// Set this for the next call to bc_parse_pushNUM().
// This is safe to set because the current token is a semicolon,
// which has no string requirement.
bc_vec_string(&p->l.lex_buf, 1, "1");
- bc_parse_pushNUM(p);
+ bc_parse_pushNUM();
s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("condition");
}
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
- bc_parse_pushJUMP_ZERO(p, exit_idx);
- bc_parse_pushJUMP(p, body_idx);
+ bc_parse_pushJUMP_ZERO(exit_idx);
+ bc_parse_pushJUMP(body_idx);
bc_vec_push(&p->conds, &update_idx);
bc_vec_push(&p->func->labels, &p->func->code.len);
if (p->l.lex != BC_LEX_RPAREN) {
- s = zbc_parse_expr(p, 0);
+ s = zbc_parse_expr(0);
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
- bc_parse_push(p, XC_INST_POP);
+ bc_parse_push(XC_INST_POP);
} else {
s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("update");
if (s) RETURN_STATUS(s);
}
- bc_parse_pushJUMP(p, cond_idx);
+ bc_parse_pushJUMP(cond_idx);
bc_vec_push(&p->func->labels, &p->func->code.len);
bc_vec_push(&p->exits, &exit_idx);
bc_vec_push(&p->func->labels, &exit_idx);
- s = zbc_parse_stmt_allow_NLINE_before(p, STRING_for);
+ s = zbc_parse_stmt_allow_NLINE_before(STRING_for);
if (s) RETURN_STATUS(s);
dbg_lex("%s:%d BC_INST_JUMP to %zd", __func__, __LINE__, update_idx);
- bc_parse_pushJUMP(p, update_idx);
+ bc_parse_pushJUMP(update_idx);
dbg_lex("%s:%d rewriting label-> %zd", __func__, __LINE__, p->func->code.len);
- rewrite_label_to_current(p, exit_idx);
+ rewrite_label_to_current(exit_idx);
bc_vec_pop(&p->exits);
bc_vec_pop(&p->conds);
}
#define zbc_parse_for(...) (zbc_parse_for(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_break_or_continue(BcParse *p, BcLexType type)
+static BC_STATUS zbc_parse_break_or_continue(BcLexType type)
{
+ BcParse *p = &G.prs;
size_t i;
if (type == BC_LEX_KEY_BREAK) {
} else {
i = *(size_t*)bc_vec_top(&p->conds);
}
- bc_parse_pushJUMP(p, i);
+ bc_parse_pushJUMP(i);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ RETURN_STATUS(zbc_lex_next());
}
#define zbc_parse_break_or_continue(...) (zbc_parse_break_or_continue(__VA_ARGS__) COMMA_SUCCESS)
}
#define zbc_func_insert(...) (zbc_func_insert(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_funcdef(BcParse *p)
+static BC_STATUS zbc_parse_funcdef(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
bool var, comma = false;
char *name;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != XC_LEX_NAME)
RETURN_STATUS(bc_error("bad function definition"));
p->fidx = bc_program_addFunc(name);
p->func = bc_program_func(p->fidx);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_LPAREN)
RETURN_STATUS(bc_error("bad function definition"));
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
while (p->l.lex != BC_LEX_RPAREN) {
++p->func->nparams;
name = xstrdup(p->l.lex_buf.v);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
var = p->l.lex != BC_LEX_LBRACKET;
if (!var) {
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
if (p->l.lex != BC_LEX_RBRACKET) {
goto err;
}
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
}
comma = p->l.lex == BC_LEX_COMMA;
if (comma) {
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
}
if (comma) RETURN_STATUS(bc_error("bad function definition"));
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != BC_LEX_LBRACE) {
}
// Prevent "define z()<newline>" from being interpreted as function with empty stmt as body
- s = zbc_lex_skip_if_at_NLINE(&p->l);
+ s = zbc_lex_skip_if_at_NLINE();
if (s) RETURN_STATUS(s);
//GNU bc requires a {} block even if function body has single stmt, enforce this?
if (p->l.lex != BC_LEX_LBRACE)
RETURN_STATUS(bc_error("function { body } expected"));
p->in_funcdef++; // to determine whether "return" stmt is allowed, and such
- s = zbc_parse_stmt_possibly_auto(p, true);
+ s = zbc_parse_stmt_possibly_auto(true);
p->in_funcdef--;
if (s) RETURN_STATUS(s);
- bc_parse_push(p, BC_INST_RET0);
+ bc_parse_push(BC_INST_RET0);
// Subsequent code generation is into main program
p->fidx = BC_PROG_MAIN;
}
#define zbc_parse_funcdef(...) (zbc_parse_funcdef(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_auto(BcParse *p)
+static BC_STATUS zbc_parse_auto(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
char *name;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
for (;;) {
RETURN_STATUS(bc_error("bad 'auto' syntax"));
name = xstrdup(p->l.lex_buf.v);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
var = (p->l.lex != BC_LEX_LBRACKET);
if (!var) {
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
if (p->l.lex != BC_LEX_RBRACKET) {
s = bc_error("bad 'auto' syntax");
goto err;
}
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) goto err;
}
}
if (p->l.lex != BC_LEX_COMMA)
RETURN_STATUS(bc_error("bad 'auto' syntax"));
- s = zbc_lex_next(&p->l); // skip comma
+ s = zbc_lex_next(); // skip comma
if (s) RETURN_STATUS(s);
}
#define zbc_parse_auto(...) (zbc_parse_auto(__VA_ARGS__) COMMA_SUCCESS)
#undef zbc_parse_stmt_possibly_auto
-static BC_STATUS zbc_parse_stmt_possibly_auto(BcParse *p, bool auto_allowed)
+static BC_STATUS zbc_parse_stmt_possibly_auto(bool auto_allowed)
{
+ BcParse *p = &G.prs;
BcStatus s = BC_STATUS_SUCCESS;
dbg_lex_enter("%s:%d entered, p->l.lex:%d", __func__, __LINE__, p->l.lex);
if (p->l.lex == XC_LEX_NLINE) {
dbg_lex_done("%s:%d done (seen XC_LEX_NLINE)", __func__, __LINE__);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ RETURN_STATUS(zbc_lex_next());
}
if (p->l.lex == BC_LEX_SCOLON) {
dbg_lex_done("%s:%d done (seen BC_LEX_SCOLON)", __func__, __LINE__);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ RETURN_STATUS(zbc_lex_next());
}
if (p->l.lex == BC_LEX_LBRACE) {
dbg_lex("%s:%d BC_LEX_LBRACE: (auto_allowed:%d)", __func__, __LINE__, auto_allowed);
do {
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
} while (p->l.lex == XC_LEX_NLINE);
if (auto_allowed && p->l.lex == BC_LEX_KEY_AUTO) {
dbg_lex("%s:%d calling zbc_parse_auto()", __func__, __LINE__);
- s = zbc_parse_auto(p);
+ s = zbc_parse_auto();
if (s) RETURN_STATUS(s);
}
while (p->l.lex != BC_LEX_RBRACE) {
dbg_lex("%s:%d block parsing loop", __func__, __LINE__);
- s = zbc_parse_stmt(p);
+ s = zbc_parse_stmt();
if (s) RETURN_STATUS(s);
}
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
dbg_lex_done("%s:%d done (seen BC_LEX_RBRACE)", __func__, __LINE__);
RETURN_STATUS(s);
}
case BC_LEX_KEY_READ:
case BC_LEX_KEY_SCALE:
case BC_LEX_KEY_SQRT:
- s = zbc_parse_expr(p, BC_PARSE_PRINT);
+ s = zbc_parse_expr(BC_PARSE_PRINT);
break;
case XC_LEX_STR:
- s = zbc_parse_pushSTR(p);
- bc_parse_push(p, XC_INST_PRINT_STR);
+ s = zbc_parse_pushSTR();
+ bc_parse_push(XC_INST_PRINT_STR);
break;
case BC_LEX_KEY_BREAK:
case BC_LEX_KEY_CONTINUE:
- s = zbc_parse_break_or_continue(p, p->l.lex);
+ s = zbc_parse_break_or_continue(p->l.lex);
break;
case BC_LEX_KEY_FOR:
- s = zbc_parse_for(p);
+ s = zbc_parse_for();
break;
case BC_LEX_KEY_HALT:
- bc_parse_push(p, BC_INST_HALT);
- s = zbc_lex_next(&p->l);
+ bc_parse_push(BC_INST_HALT);
+ s = zbc_lex_next();
break;
case BC_LEX_KEY_IF:
- s = zbc_parse_if(p);
+ s = zbc_parse_if();
break;
case BC_LEX_KEY_LIMITS:
// "limits" is a compile-time command,
"MAX Exponent = "BC_MAX_EXP_STR "\n"
"Number of vars = "BC_MAX_VARS_STR "\n"
);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
break;
case BC_LEX_KEY_PRINT:
- s = zbc_parse_print(p);
+ s = zbc_parse_print();
break;
case BC_LEX_KEY_QUIT:
// "quit" is a compile-time command. For example,
case BC_LEX_KEY_RETURN:
if (!p->in_funcdef)
RETURN_STATUS(bc_error("'return' not in a function"));
- s = zbc_parse_return(p);
+ s = zbc_parse_return();
break;
case BC_LEX_KEY_WHILE:
- s = zbc_parse_while(p);
+ s = zbc_parse_while();
break;
default:
s = bc_error_bad_token();
}
#define zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zbc_parse_stmt_or_funcdef(BcParse *p)
+static BC_STATUS zbc_parse_stmt_or_funcdef(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
s = bc_error("end of file");
else if (p->l.lex == BC_LEX_KEY_DEFINE) {
dbg_lex("%s:%d p->l.lex:BC_LEX_KEY_DEFINE", __func__, __LINE__);
- s = zbc_parse_funcdef(p);
+ s = zbc_parse_funcdef();
} else {
dbg_lex("%s:%d p->l.lex:%d (not BC_LEX_KEY_DEFINE)", __func__, __LINE__, p->l.lex);
- s = zbc_parse_stmt(p);
+ s = zbc_parse_stmt();
}
dbg_lex_done("%s:%d done", __func__, __LINE__);
#define zbc_parse_stmt_or_funcdef(...) (zbc_parse_stmt_or_funcdef(__VA_ARGS__) COMMA_SUCCESS)
// 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)
+static BcStatus bc_parse_expr_empty_ok(uint8_t flags)
{
+ BcParse *p = &G.prs;
BcInst prev = XC_INST_PRINT;
size_t nexprs = 0, ops_bgn = p->ops.len;
unsigned nparens, nrelops;
switch (t) {
case BC_LEX_OP_INC:
case BC_LEX_OP_DEC:
- s = zbc_parse_incdec(p, &prev, &paren_expr, &nexprs, flags);
+ s = zbc_parse_incdec(&prev, &paren_expr, &nexprs, flags);
rprn = bin_last = false;
//get_token = false; - already is
break;
case XC_LEX_OP_MINUS:
- s = zbc_parse_minus(p, &prev, ops_bgn, rprn, &nexprs);
+ s = zbc_parse_minus(&prev, ops_bgn, rprn, &nexprs);
rprn = false;
//get_token = false; - already is
bin_last = (prev == XC_INST_MINUS);
}
nrelops += (t >= XC_LEX_OP_REL_EQ && t <= XC_LEX_OP_REL_GT);
prev = BC_TOKEN_2_INST(t);
- bc_parse_operator(p, t, ops_bgn, &nexprs);
- s = zbc_lex_next(&p->l);
+ bc_parse_operator(t, ops_bgn, &nexprs);
+ s = zbc_lex_next();
rprn = false;
//get_token = false; - already is
bin_last = (t != BC_LEX_OP_BOOL_NOT);
dbg_lex_done("%s:%d done (returning EMPTY_EXP)", __func__, __LINE__);
return BC_STATUS_PARSE_EMPTY_EXP;
}
- s = zbc_parse_rightParen(p, ops_bgn, &nexprs);
+ s = zbc_parse_rightParen(ops_bgn, &nexprs);
nparens--;
get_token = true;
paren_expr = rprn = true;
case XC_LEX_NAME:
if (BC_PARSE_LEAF(prev, rprn))
return bc_error_bad_expression();
- s = zbc_parse_name(p, &prev, flags & ~BC_PARSE_NOCALL);
+ s = zbc_parse_name(&prev, flags & ~BC_PARSE_NOCALL);
paren_expr = true;
rprn = bin_last = false;
//get_token = false; - already is
case XC_LEX_NUMBER:
if (BC_PARSE_LEAF(prev, rprn))
return bc_error_bad_expression();
- bc_parse_pushNUM(p);
+ bc_parse_pushNUM();
prev = XC_INST_NUM;
get_token = true;
paren_expr = true;
if (BC_PARSE_LEAF(prev, rprn))
return bc_error_bad_expression();
prev = (char) (t - BC_LEX_KEY_IBASE + XC_INST_IBASE);
- bc_parse_push(p, (char) prev);
+ bc_parse_push((char) prev);
get_token = true;
paren_expr = true;
rprn = bin_last = false;
case BC_LEX_KEY_SQRT:
if (BC_PARSE_LEAF(prev, rprn))
return bc_error_bad_expression();
- s = zbc_parse_builtin(p, t, flags, &prev);
+ s = zbc_parse_builtin(t, flags, &prev);
get_token = true;
paren_expr = true;
rprn = bin_last = false;
case BC_LEX_KEY_READ:
if (BC_PARSE_LEAF(prev, rprn))
return bc_error_bad_expression();
- s = zbc_parse_read(p);
+ s = zbc_parse_read();
prev = XC_INST_READ;
get_token = true;
paren_expr = true;
case BC_LEX_KEY_SCALE:
if (BC_PARSE_LEAF(prev, rprn))
return bc_error_bad_expression();
- s = zbc_parse_scale(p, &prev, flags);
+ s = zbc_parse_scale(&prev, flags);
prev = XC_INST_SCALE;
//get_token = false; - already is
paren_expr = true;
if (s || G_interrupt) // error, or ^C: stop parsing
return BC_STATUS_FAILURE;
if (get_token) {
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) return s;
}
}
if (top == BC_LEX_LPAREN || top == BC_LEX_RPAREN)
return bc_error_bad_expression();
- bc_parse_push(p, BC_TOKEN_2_INST(top));
+ bc_parse_push(BC_TOKEN_2_INST(top));
nexprs -= (top != BC_LEX_OP_BOOL_NOT && top != XC_LEX_NEG);
bc_vec_pop(&p->ops);
if (flags & BC_PARSE_PRINT) {
if (paren_first || !assign)
- bc_parse_push(p, XC_INST_PRINT);
- bc_parse_push(p, XC_INST_POP);
+ bc_parse_push(XC_INST_PRINT);
+ bc_parse_push(XC_INST_POP);
}
dbg_lex_done("%s:%d done", __func__, __LINE__);
#if ENABLE_DC
-static BC_STATUS zdc_parse_register(BcParse *p)
+static BC_STATUS zdc_parse_register(void)
{
+ BcParse *p = &G.prs;
BcStatus s;
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
if (p->l.lex != XC_LEX_NAME) RETURN_STATUS(bc_error_bad_token());
- bc_parse_pushName(p, p->l.lex_buf.v);
+ bc_parse_pushName(p->l.lex_buf.v);
RETURN_STATUS(s);
}
#define zdc_parse_register(...) (zdc_parse_register(__VA_ARGS__) COMMA_SUCCESS)
-static void dc_parse_string(BcParse *p)
+static void dc_parse_string(void)
{
+ BcParse *p = &G.prs;
char *str;
size_t len = G.prog.strs.len;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
str = xstrdup(p->l.lex_buf.v);
- bc_parse_push(p, XC_INST_STR);
- bc_parse_pushIndex(p, len);
+ bc_parse_push(XC_INST_STR);
+ bc_parse_pushIndex(len);
bc_vec_push(&G.prog.strs, &str);
// Explanation needed here
dbg_lex_done("%s:%d done", __func__, __LINE__);
}
-static BC_STATUS zdc_parse_mem(BcParse *p, uint8_t inst, bool name, bool store)
+static BC_STATUS zdc_parse_mem(uint8_t inst, bool name, bool store)
{
BcStatus s;
- bc_parse_push(p, inst);
+ bc_parse_push(inst);
if (name) {
- s = zdc_parse_register(p);
+ s = zdc_parse_register();
if (s) RETURN_STATUS(s);
}
if (store) {
- bc_parse_push(p, DC_INST_SWAP);
- bc_parse_push(p, XC_INST_ASSIGN);
- bc_parse_push(p, XC_INST_POP);
+ bc_parse_push(DC_INST_SWAP);
+ bc_parse_push(XC_INST_ASSIGN);
+ bc_parse_push(XC_INST_POP);
}
RETURN_STATUS(BC_STATUS_SUCCESS);
}
#define zdc_parse_mem(...) (zdc_parse_mem(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zdc_parse_cond(BcParse *p, uint8_t inst)
+static BC_STATUS zdc_parse_cond(uint8_t inst)
{
+ BcParse *p = &G.prs;
BcStatus s;
- bc_parse_push(p, inst);
- bc_parse_push(p, DC_INST_EXEC_COND);
+ bc_parse_push(inst);
+ bc_parse_push(DC_INST_EXEC_COND);
- s = zdc_parse_register(p);
+ s = zdc_parse_register();
if (s) RETURN_STATUS(s);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
// Note that 'else' part can not be on the next line:
// echo -e '[1p]sa [2p]sb 2 1>a eb' | dc - OK, prints "2"
// echo -e '[1p]sa [2p]sb 2 1>a\neb' | dc - parse error
if (p->l.lex == DC_LEX_ELSE) {
- s = zdc_parse_register(p);
+ s = zdc_parse_register();
if (s) RETURN_STATUS(s);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
} else {
- bc_parse_push(p, BC_PARSE_STREND);
+ bc_parse_push(BC_PARSE_STREND);
}
RETURN_STATUS(s);
}
#define zdc_parse_cond(...) (zdc_parse_cond(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zdc_parse_token(BcParse *p, BcLexType t)
+static BC_STATUS zdc_parse_token(BcLexType t)
{
BcStatus s;
uint8_t inst;
case XC_LEX_OP_REL_LT:
case XC_LEX_OP_REL_GT:
dbg_lex("%s:%d LEX_OP_REL_xyz", __func__, __LINE__);
- s = zdc_parse_cond(p, t - XC_LEX_OP_REL_EQ + XC_INST_REL_EQ);
+ s = zdc_parse_cond(t - XC_LEX_OP_REL_EQ + XC_INST_REL_EQ);
get_token = false;
break;
case DC_LEX_SCOLON:
case DC_LEX_COLON:
dbg_lex("%s:%d LEX_[S]COLON", __func__, __LINE__);
- s = zdc_parse_mem(p, XC_INST_ARRAY_ELEM, true, t == DC_LEX_COLON);
+ s = zdc_parse_mem(XC_INST_ARRAY_ELEM, true, t == DC_LEX_COLON);
break;
case XC_LEX_STR:
dbg_lex("%s:%d LEX_STR", __func__, __LINE__);
- dc_parse_string(p);
+ dc_parse_string();
break;
case XC_LEX_NEG:
dbg_lex("%s:%d LEX_NEG", __func__, __LINE__);
- s = zbc_lex_next(&p->l);
+ s = zbc_lex_next();
if (s) RETURN_STATUS(s);
- if (p->l.lex != XC_LEX_NUMBER)
+ if (G.prs.l.lex != XC_LEX_NUMBER)
RETURN_STATUS(bc_error_bad_token());
- bc_parse_pushNUM(p);
- bc_parse_push(p, XC_INST_NEG);
+ bc_parse_pushNUM();
+ bc_parse_push(XC_INST_NEG);
break;
case XC_LEX_NUMBER:
dbg_lex("%s:%d LEX_NUMBER", __func__, __LINE__);
- bc_parse_pushNUM(p);
+ bc_parse_pushNUM();
break;
case DC_LEX_READ:
dbg_lex("%s:%d LEX_KEY_READ", __func__, __LINE__);
- bc_parse_push(p, XC_INST_READ);
+ bc_parse_push(XC_INST_READ);
break;
case DC_LEX_OP_ASSIGN:
case DC_LEX_STORE_PUSH:
dbg_lex("%s:%d LEX_OP_ASSIGN/STORE_PUSH", __func__, __LINE__);
assign = (t == DC_LEX_OP_ASSIGN);
inst = assign ? XC_INST_VAR : DC_INST_PUSH_TO_VAR;
- s = zdc_parse_mem(p, inst, true, assign);
+ s = zdc_parse_mem(inst, true, assign);
break;
case DC_LEX_LOAD:
case DC_LEX_LOAD_POP:
dbg_lex("%s:%d LEX_OP_LOAD[_POP]", __func__, __LINE__);
inst = t == DC_LEX_LOAD_POP ? DC_INST_PUSH_VAR : DC_INST_LOAD;
- s = zdc_parse_mem(p, inst, true, false);
+ s = zdc_parse_mem(inst, true, false);
break;
case DC_LEX_STORE_IBASE:
case DC_LEX_STORE_SCALE:
case DC_LEX_STORE_OBASE:
dbg_lex("%s:%d LEX_OP_STORE_I/OBASE/SCALE", __func__, __LINE__);
inst = t - DC_LEX_STORE_IBASE + XC_INST_IBASE;
- s = zdc_parse_mem(p, inst, false, true);
+ s = zdc_parse_mem(inst, false, true);
break;
default:
dbg_lex_done("%s:%d done (bad token)", __func__, __LINE__);
RETURN_STATUS(bc_error_bad_token());
}
- if (!s && get_token) s = zbc_lex_next(&p->l);
+ if (!s && get_token) s = zbc_lex_next();
dbg_lex_done("%s:%d done", __func__, __LINE__);
RETURN_STATUS(s);
}
#define zdc_parse_token(...) (zdc_parse_token(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zdc_parse_expr(BcParse *p)
+static BC_STATUS zdc_parse_expr(void)
{
+ BcParse *p = &G.prs;
int i;
i = (int)p->l.lex - (int)XC_LEX_OP_POWER;
if (i >= 0) {
BcInst inst = dc_LEX_to_INST[i];
if (inst != DC_INST_INVALID) {
- bc_parse_push(p, inst);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ bc_parse_push(inst);
+ RETURN_STATUS(zbc_lex_next());
}
}
- RETURN_STATUS(zdc_parse_token(p, p->l.lex));
+ RETURN_STATUS(zdc_parse_token(p->l.lex));
}
#define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__) COMMA_SUCCESS)
-static BC_STATUS zdc_parse_exprs_until_eof(BcParse *p)
+static BC_STATUS zdc_parse_exprs_until_eof(void)
{
+ BcParse *p = &G.prs;
dbg_lex_enter("%s:%d entered, p->l.lex:%d", __func__, __LINE__, p->l.lex);
while (p->l.lex != XC_LEX_EOF) {
- BcStatus s = zdc_parse_expr(p);
+ BcStatus s = zdc_parse_expr();
if (s) RETURN_STATUS(s);
}
bc_vec_pop_all(&f->code);
sv_parse = G.prs; // struct copy
- bc_parse_create(&G.prs, BC_PROG_READ);
+ bc_parse_create(BC_PROG_READ);
//bc_lex_file(&G.prs.l); - not needed, error line info is not printed for read()
- s = zbc_parse_text_init(&G.prs, buf.v);
+ s = zbc_parse_text_init(buf.v);
if (s) goto exec_err;
if (IS_BC) {
- IF_BC(s = zbc_parse_expr(&G.prs, 0));
+ IF_BC(s = zbc_parse_expr(0));
} else {
- IF_DC(s = zdc_parse_exprs_until_eof(&G.prs));
+ IF_DC(s = zdc_parse_exprs_until_eof());
}
if (s) goto exec_err;
ip.inst_idx = 0;
IF_BC(ip.results_len_before_call = G.prog.results.len;)
- bc_parse_push(&G.prs, XC_INST_RET);
+ bc_parse_push(XC_INST_RET);
bc_vec_push(&G.prog.exestack, &ip);
exec_err:
- bc_parse_free(&G.prs);
+ bc_parse_free();
G.prs = sv_parse; // struct copy
bc_vec_free(&buf);
RETURN_STATUS(s);
char *str;
sv_parse = G.prs; // struct copy
- bc_parse_create(&G.prs, fidx);
+ bc_parse_create(fidx);
str = *bc_program_str(sidx);
- s = zbc_parse_text_init(&G.prs, str);
+ s = zbc_parse_text_init(str);
if (s) goto err;
- s = zdc_parse_exprs_until_eof(&G.prs);
+ s = zdc_parse_exprs_until_eof();
if (s) goto err;
- bc_parse_push(&G.prs, DC_INST_POP_EXEC);
+ bc_parse_push(DC_INST_POP_EXEC);
if (G.prs.l.lex != XC_LEX_EOF)
s = bc_error_bad_expression();
- bc_parse_free(&G.prs);
+ bc_parse_free();
G.prs = sv_parse; // struct copy
if (s) {
err:
BcStatus s;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- s = zbc_parse_text_init(&G.prs, text); // does the first zbc_lex_next()
+ s = zbc_parse_text_init(text); // does the first zbc_lex_next()
if (s) RETURN_STATUS(s);
IF_BC(check_eof:)
if (G.prs.l.lex == BC_LEX_SCOLON
|| G.prs.l.lex == XC_LEX_NLINE
) {
- s = zbc_lex_next(&G.prs.l);
+ s = zbc_lex_next();
if (s) goto err;
goto check_eof;
}
- s = zbc_parse_stmt_or_funcdef(&G.prs);
+ s = zbc_parse_stmt_or_funcdef();
if (s) goto err;
// Check that next token is a correct stmt delimiter -
// Most of dc parsing assumes all whitespace,
// including '\n', is eaten.
while (G.prs.l.lex == XC_LEX_NLINE) {
- s = zbc_lex_next(&G.prs.l);
+ s = zbc_lex_next();
if (s) goto err;
if (G.prs.l.lex == XC_LEX_EOF)
goto done;
}
- s = zdc_parse_expr(&G.prs);
+ s = zdc_parse_expr();
#endif
}
if (s || G_interrupt) {
err:
- bc_parse_reset(&G.prs); // includes bc_program_reset()
+ bc_parse_reset(); // includes bc_program_reset()
RETURN_STATUS(BC_STATUS_FAILURE);
}
G.prs.filename = filename;
G.prs.input_fp = fp;
- bc_lex_file(&G.prs.l);
+ bc_lex_file();
do {
s = zbc_vm_process("");
// We know that internal library is not buggy,
// thus error checking is normally disabled.
# define DEBUG_LIB 0
- bc_lex_file(&G.prs.l);
+ bc_lex_file();
s = zbc_vm_process(bc_lib);
if (DEBUG_LIB && s) RETURN_STATUS(s);
}
{
bc_vec_free(&G.files);
bc_program_free();
- bc_parse_free(&G.prs);
+ bc_parse_free();
free(G.env_args);
}
#endif
bc_vec_init(&G.files, sizeof(char *), NULL);
IF_BC(if (IS_BC) bc_vm_envArgs();)
bc_program_init();
- bc_parse_create(&G.prs, BC_PROG_MAIN);
+ bc_parse_create(BC_PROG_MAIN);
//TODO: in GNU bc, the check is (isatty(0) && isatty(1)),
//-i option unconditionally enables this regardless of isatty():
projects / oweals / busybox.git / commitdiff