aboutsummaryrefslogtreecommitdiff
path: root/miscutils
diff options
context:
space:
mode:
Diffstat (limited to 'miscutils')
-rw-r--r--miscutils/bc.c631
1 files changed, 260 insertions, 371 deletions
diff --git a/miscutils/bc.c b/miscutils/bc.c
index 374279889..95ba8b094 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -171,7 +171,7 @@
#define DEBUG_EXEC 0
#if DEBUG_LEXER
-static unsigned lex_indent;
+static uint8_t lex_indent;
#define dbg_lex(...) \
do { \
fprintf(stderr, "%*s", lex_indent, ""); \
@@ -558,19 +558,16 @@ enum {
#endif
typedef struct BcLex {
-
const char *buf;
size_t i;
size_t line;
size_t len;
bool newline;
-
struct {
BcLexType t;
BcLexType last;
BcVec v;
} t;
-
} BcLex;
#define BC_PARSE_STREND ((char) UCHAR_MAX)
@@ -581,37 +578,9 @@ typedef struct BcLex {
#define BC_PARSE_NOREAD (1 << 3)
#define BC_PARSE_ARRAY (1 << 4)
-#define BC_PARSE_TOP_FLAG_PTR(parse) ((parse)->bf_top)
-#define BC_PARSE_TOP_FLAG(parse) (*(BC_PARSE_TOP_FLAG_PTR(parse)))
-#define BC_PARSE_FLAG_STACK_EMPTY(p) ((p)->bf_top == (p)->bf_base)
-
-#define BC_PARSE_FLAG_FUNC_INNER (1 << 0)
-#define BC_PARSE_FLAG_FUNC (1 << 1)
-#define BC_PARSE_FLAG_BODY (1 << 2)
-#define BC_PARSE_FLAG_LOOP (1 << 3)
-#define BC_PARSE_FLAG_LOOP_INNER (1 << 4)
-#define BC_PARSE_FLAG_IF (1 << 5)
-#define BC_PARSE_FLAG_ELSE (1 << 6)
-#define BC_PARSE_FLAG_IF_END (1 << 7)
-
-// If we have none of the above bits, we can stop parsing and execute already parsed chunk
-#define BC_PARSE_CAN_EXEC(parse) (BC_PARSE_TOP_FLAG(parse) == 0)
-
-#define BC_PARSE_FUNC_INNER(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_FUNC_INNER)
-#define BC_PARSE_FUNC(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_FUNC)
-#define BC_PARSE_BODY(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_BODY)
-#define BC_PARSE_LOOP(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_LOOP)
-#define BC_PARSE_LOOP_INNER(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_LOOP_INNER)
-#define BC_PARSE_IF(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_IF)
-#define BC_PARSE_ELSE(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_ELSE)
-#define BC_PARSE_IF_END(parse) (BC_PARSE_TOP_FLAG(parse) & BC_PARSE_FLAG_IF_END)
-
typedef struct BcParse {
BcLex l;
- uint8_t *bf_base;
- uint8_t *bf_top;
-
BcVec exits;
BcVec conds;
@@ -620,9 +589,8 @@ typedef struct BcParse {
BcFunc *func;
size_t fidx;
+//TODO: needed? Example?
size_t nbraces;
-//FIXME: "define w(x) { auto z; return 1; }" fails to parse
- bool auto_part;
} BcParse;
typedef struct BcProgram {
@@ -666,26 +634,6 @@ typedef struct BcProgram {
} BcProgram;
-static void bc_parse_push_block_flag(BcParse *p, uint8_t flags)
-{
- size_t size;
- uint8_t *flag_ptr = BC_PARSE_TOP_FLAG_PTR(p);
- flags |= (*flag_ptr & (BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_LOOP));
- flags |= BC_PARSE_FLAG_BODY;
-
- size = p->bf_top - p->bf_base;
- p->bf_base = xrealloc(p->bf_base, size + 2);
- p->bf_top = p->bf_base + size + 1;
- dbg_lex("%s:%d pushed block flag lvl:%d bits:0x%02x", __func__, __LINE__, size + 1, flags);
- *p->bf_top = flags;
-}
-
-static ALWAYS_INLINE void bc_parse_pop_block_flag(BcParse *p)
-{
- p->bf_top--;
- dbg_lex("%s:%d popped block flag lvl:%d bits:0x%02x", __func__, __LINE__, p->bf_top - p->bf_base, *p->bf_top);
-}
-
#define BC_PROG_STACK(s, n) ((s)->len >= ((size_t) n))
#define BC_PROG_MAIN (0)
@@ -747,6 +695,7 @@ struct globals {
IF_FEATURE_BC_SIGNALS(smallint ttyin;)
IF_FEATURE_CLEAN_UP(smallint exiting;)
smallint in_read;
+ smallint use_stdin;
BcParse prs;
BcProgram prog;
@@ -756,6 +705,7 @@ struct globals {
unsigned err_line;
BcVec files;
+ BcVec stdin_buffer;
char *env_args;
@@ -1052,6 +1002,7 @@ static void quit(void)
if (ferror(stdin))
bb_perror_msg_and_die("input error");
fflush_and_check();
+ dbg_exec("quit(): exiting with exitcode SUCCESS");
exit(0);
}
@@ -2955,6 +2906,79 @@ static BC_STATUS zcommon_lex_token(BcLex *l)
IF_DC(RETURN_STATUS(zdc_lex_token(l));)
}
+static bool bc_lex_more_input(BcLex *l)
+{
+ size_t str;
+ bool comment;
+
+ bc_vec_pop_all(&G.stdin_buffer);
+
+ // This loop is complex because the vm tries not to send any lines that end
+ // with a backslash to the parser. The reason for that is because the parser
+ // treats a backslash+newline combo as whitespace, per the bc spec. In that
+ // case, and for strings and comments, the parser will expect more stuff.
+ comment = false;
+ str = 0;
+ for (;;) {
+ size_t prevlen = G.stdin_buffer.len;
+ char *string;
+
+ bc_read_line(&G.stdin_buffer);
+ // No more input means EOF
+ if (G.stdin_buffer.len <= prevlen + 1) // (we expect +1 for NUL byte)
+ break;
+
+ string = G.stdin_buffer.v + prevlen;
+ while (*string) {
+ char c = *string;
+ if (string == G.stdin_buffer.v || string[-1] != '\\') {
+ if (IS_BC)
+ str ^= (c == '"');
+ else {
+ if (c == ']')
+ str -= 1;
+ else if (c == '[')
+ str += 1;
+ }
+ }
+ string++;
+ if (c == '/' && *string == '*') {
+ comment = true;
+ string++;
+ continue;
+ }
+ if (c == '*' && *string == '/') {
+ comment = false;
+ string++;
+ }
+ }
+ if (str != 0 || comment) {
+ G.stdin_buffer.len--; // backstep over the trailing NUL byte
+ continue;
+ }
+
+ // Check for backslash+newline.
+ // we do not check that last char is '\n' -
+ // if it is not, then it's EOF, and looping back
+ // to bc_read_line() will detect it:
+ string -= 2;
+ if (string >= G.stdin_buffer.v && *string == '\\') {
+ G.stdin_buffer.len--;
+ continue;
+ }
+
+ break;
+ }
+
+ l->buf = G.stdin_buffer.v;
+ l->i = 0;
+//bb_error_msg("G.stdin_buffer.len:%d '%s'", G.stdin_buffer.len, G.stdin_buffer.v);
+ l->len = G.stdin_buffer.len - 1; // do not include NUL
+
+ G.use_stdin = (l->len != 0);
+ return G.use_stdin;
+}
+
static BC_STATUS zbc_lex_next(BcLex *l)
{
BcStatus s;
@@ -2964,10 +2988,16 @@ static BC_STATUS zbc_lex_next(BcLex *l)
l->line += l->newline;
G.err_line = l->line;
- l->t.t = BC_LEX_EOF;
+ l->t.t = BC_LEX_EOF;
+//this NL handling is bogus
l->newline = (l->i == l->len);
- if (l->newline) RETURN_STATUS(BC_STATUS_SUCCESS);
+ if (l->newline) {
+ if (!G.use_stdin || !bc_lex_more_input(l))
+ RETURN_STATUS(BC_STATUS_SUCCESS);
+ // here it's guaranteed that l->i is below l->len
+ l->newline = false;
+ }
// Loop until failure or we don't have whitespace. This
// is so the parser doesn't get inundated with whitespace.
@@ -3528,19 +3558,8 @@ static BC_STATUS zcommon_parse(BcParse *p)
static BC_STATUS zbc_parse_text_init(BcParse *p, const char *text)
{
- BcStatus s;
-
p->func = bc_program_func(p->fidx);
- if (!text[0] && !BC_PARSE_CAN_EXEC(p)) {
- p->l.t.t = BC_LEX_INVALID;
- s = BC_STATUS_SUCCESS;
- ERROR_RETURN(s =) zcommon_parse(p);
- if (s) RETURN_STATUS(s);
- if (!BC_PARSE_CAN_EXEC(p))
- RETURN_STATUS(bc_error("file is not executable"));
- }
-
RETURN_STATUS(zbc_lex_text_init(&p->l, text));
}
#if ERRORS_ARE_FATAL
@@ -3580,9 +3599,8 @@ static void bc_parse_reset(BcParse *p)
p->l.i = p->l.len;
p->l.t.t = BC_LEX_EOF;
- p->auto_part = (p->nbraces = 0);
+ p->nbraces = 0;
- p->bf_top = p->bf_base; // pop all flags
bc_vec_pop_all(&p->exits);
bc_vec_pop_all(&p->conds);
bc_vec_pop_all(&p->ops);
@@ -3592,7 +3610,6 @@ static void bc_parse_reset(BcParse *p)
static void bc_parse_free(BcParse *p)
{
- free(p->bf_base);
bc_vec_free(&p->exits);
bc_vec_free(&p->conds);
bc_vec_free(&p->ops);
@@ -3604,12 +3621,11 @@ static void bc_parse_create(BcParse *p, size_t func)
memset(p, 0, sizeof(BcParse));
bc_lex_init(&p->l);
- p->bf_top = p->bf_base = xzalloc(1);
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);
- // p->auto_part = p->nbraces = 0; - already is
+ // p->nbraces = 0; - already is
bc_parse_updateFunc(p, func);
}
@@ -3625,14 +3641,20 @@ static void bc_parse_create(BcParse *p, size_t func)
// first in the expr enum. Note: This only works for binary operators.
#define BC_TOKEN_2_INST(t) ((char) ((t) - BC_LEX_NEG + BC_INST_NEG))
-static BC_STATUS zbc_parse_else(BcParse *p);
-static BC_STATUS zbc_parse_stmt(BcParse *p);
+static BC_STATUS zbc_parse_stmt_possibly_auto(BcParse *p, bool auto_allowed);
static BC_STATUS zbc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next);
static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext next);
#if ERRORS_ARE_FATAL
-# define zbc_parse_else(...) (zbc_parse_else(__VA_ARGS__), BC_STATUS_SUCCESS)
-# define zbc_parse_stmt(...) (zbc_parse_stmt(__VA_ARGS__), BC_STATUS_SUCCESS)
# define zbc_parse_expr(...) (zbc_parse_expr(__VA_ARGS__), BC_STATUS_SUCCESS)
+# defone zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__), BC_STATUS_SUCCESS)
+#endif
+
+static BC_STATUS zbc_parse_stmt(BcParse *p)
+{
+ RETURN_STATUS(zbc_parse_stmt_possibly_auto(p, false));
+}
+#if ERRORS_ARE_FATAL
+# define zbc_parse_stmt(...) (zbc_parse_stmt(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
static void bc_parse_operator(BcParse *p, BcLexType type, size_t start,
@@ -4037,7 +4059,7 @@ static BC_STATUS zbc_parse_return(BcParse *p)
BcLexType t;
bool paren;
- if (!BC_PARSE_FUNC(p)) RETURN_STATUS(bc_error_bad_token());
+ dbg_lex_enter("%s:%d entered", __func__, __LINE__);
s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s);
@@ -4063,97 +4085,62 @@ static BC_STATUS zbc_parse_return(BcParse *p)
bc_parse_push(p, BC_INST_RET);
}
+ dbg_lex_done("%s:%d done", __func__, __LINE__);
RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
# define zbc_parse_return(...) (zbc_parse_return(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
-static BC_STATUS zbc_parse_endBody(BcParse *p)
+static void bc_parse_noElse(BcParse *p)
{
- BcStatus s = BC_STATUS_SUCCESS;
-
- if (BC_PARSE_FLAG_STACK_EMPTY(p))
- RETURN_STATUS(bc_error_bad_token());
-
- if (BC_PARSE_IF(p)) {
- uint8_t *flag_ptr;
+ BcInstPtr *ip;
+ size_t *label;
- while (p->l.t.t == BC_LEX_NLINE) {
- s = zbc_lex_next(&p->l);
- if (s) RETURN_STATUS(s);
- }
+ ip = bc_vec_top(&p->exits);
+ label = bc_vec_item(&p->func->labels, ip->idx);
+ dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
+ *label = p->func->code.len;
- bc_parse_pop_block_flag(p);
+ bc_vec_pop(&p->exits);
+}
- flag_ptr = BC_PARSE_TOP_FLAG_PTR(p);
- dbg_lex("%s:%d setting BC_PARSE_FLAG_IF_END bit", __func__, __LINE__);
- *flag_ptr = (*flag_ptr | BC_PARSE_FLAG_IF_END);
+static BC_STATUS zbc_parse_else(BcParse *p)
+{
+ BcStatus s;
+ BcInstPtr ip;
- if (p->l.t.t == BC_LEX_KEY_ELSE)
- s = zbc_parse_else(p);
- }
- else if (BC_PARSE_ELSE(p)) {
- BcInstPtr *ip;
- size_t *label;
+ dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- ip = bc_vec_top(&p->exits);
- label = bc_vec_item(&p->func->labels, ip->idx);
- dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
- *label = p->func->code.len;
+ ip.idx = p->func->labels.len;
+ ip.func = ip.len = 0;
- bc_vec_pop(&p->exits);
- bc_parse_pop_block_flag(p);
- }
- else if (BC_PARSE_FUNC_INNER(p)) {
- bc_parse_push(p, BC_INST_RET0);
- bc_parse_updateFunc(p, BC_PROG_MAIN);
- bc_parse_pop_block_flag(p);
- }
- else {
- BcInstPtr *ip = bc_vec_top(&p->exits);
- size_t *label = bc_vec_top(&p->conds);
+ dbg_lex("%s:%d after if() body: BC_INST_JUMP to %d", __func__, __LINE__, ip.idx);
+ bc_parse_push(p, BC_INST_JUMP);
+ bc_parse_pushIndex(p, ip.idx);
- dbg_lex("%s:%d BC_INST_JUMP to %d", __func__, __LINE__, *label);
- bc_parse_push(p, BC_INST_JUMP);
- bc_parse_pushIndex(p, *label);
+ dbg_lex("%s:%d calling bc_parse_noElse()", __func__, __LINE__);
+ bc_parse_noElse(p);
- label = bc_vec_item(&p->func->labels, ip->idx);
- dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
- *label = p->func->code.len;
+ bc_vec_push(&p->exits, &ip);
+ bc_vec_push(&p->func->labels, &ip.idx);
- bc_vec_pop(&p->exits);
- bc_vec_pop(&p->conds);
- bc_parse_pop_block_flag(p);
- }
+ s = zbc_parse_stmt(p);
+ if (s) RETURN_STATUS(s);
+ dbg_lex_done("%s:%d done", __func__, __LINE__);
RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
-# define zbc_parse_endBody(...) (zbc_parse_endBody(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_parse_else(...) (zbc_parse_else(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
-static void bc_parse_noElse(BcParse *p)
-{
- BcInstPtr *ip;
- size_t *label;
- uint8_t *flag_ptr = BC_PARSE_TOP_FLAG_PTR(p);
-
- dbg_lex("%s:%d clearing BC_PARSE_FLAG_IF_END bit", __func__, __LINE__);
- *flag_ptr = (*flag_ptr & ~(BC_PARSE_FLAG_IF_END));
-
- ip = bc_vec_top(&p->exits);
- label = bc_vec_item(&p->func->labels, ip->idx);
- dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
- *label = p->func->code.len;
-
- bc_vec_pop(&p->exits);
-}
-
static BC_STATUS zbc_parse_if(BcParse *p)
{
BcStatus s;
BcInstPtr ip;
+ BcInstPtr *ipp;
+ size_t *label;
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
s = zbc_lex_next(&p->l);
@@ -4164,60 +4151,50 @@ static BC_STATUS zbc_parse_if(BcParse *p)
if (s) RETURN_STATUS(s);
s = zbc_parse_expr(p, BC_PARSE_REL, bc_parse_next_rel);
if (s) RETURN_STATUS(s);
- if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
+ if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s);
- bc_parse_push(p, BC_INST_JUMP_ZERO);
+ bc_parse_push(p, BC_INST_JUMP_ZERO);
ip.idx = p->func->labels.len;
ip.func = ip.len = 0;
-
bc_parse_pushIndex(p, ip.idx);
+//TODO: can get rid of p->exits stack?
bc_vec_push(&p->exits, &ip);
bc_vec_push(&p->func->labels, &ip.idx);
- bc_parse_push_block_flag(p, BC_PARSE_FLAG_IF);
- dbg_lex_done("%s:%d done", __func__, __LINE__);
- RETURN_STATUS(BC_STATUS_SUCCESS);
-}
-#if ERRORS_ARE_FATAL
-# define zbc_parse_if(...) (zbc_parse_if(__VA_ARGS__), BC_STATUS_SUCCESS)
-#endif
-
-#undef zbc_parse_else
-static BC_STATUS zbc_parse_else(BcParse *p)
-{
- BcInstPtr ip;
-
- dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- if (!BC_PARSE_IF_END(p)) RETURN_STATUS(bc_error_bad_token());
-
- ip.idx = p->func->labels.len;
- ip.func = ip.len = 0;
-
- dbg_lex("%s:%d after if() body: BC_INST_JUMP to %d", __func__, __LINE__, ip.idx);
- bc_parse_push(p, BC_INST_JUMP);
- bc_parse_pushIndex(p, ip.idx);
+ s = zbc_parse_stmt(p);
+ if (s) RETURN_STATUS(s);
+ dbg_lex("%s:%d in if after stmt: p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
+ if (p->l.t.t == BC_LEX_KEY_ELSE) {
+ s = zbc_lex_next(&p->l);
+ if (s) RETURN_STATUS(s);
+ dbg_lex("%s:%d calling zbc_parse_else(), p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
+ s = zbc_parse_else(p);
+ }
- dbg_lex("%s:%d calling bc_parse_noElse()", __func__, __LINE__);
- bc_parse_noElse(p);
+ ipp = bc_vec_top(&p->exits);
+ label = bc_vec_item(&p->func->labels, ipp->idx);
+ dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
+ *label = p->func->code.len;
- bc_vec_push(&p->exits, &ip);
- bc_vec_push(&p->func->labels, &ip.idx);
- bc_parse_push_block_flag(p, BC_PARSE_FLAG_ELSE);
+ bc_vec_pop(&p->exits);
dbg_lex_done("%s:%d done", __func__, __LINE__);
- RETURN_STATUS(zbc_lex_next(&p->l));
+ RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
-# define zbc_parse_else(...) (zbc_parse_else(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_parse_if(...) (zbc_parse_if(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
static BC_STATUS zbc_parse_while(BcParse *p)
{
BcStatus s;
BcInstPtr ip;
+ BcInstPtr *ipp;
+ size_t *label;
+ size_t n;
s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s);
@@ -4245,9 +4222,29 @@ static BC_STATUS zbc_parse_while(BcParse *p)
bc_parse_push(p, BC_INST_JUMP_ZERO);
bc_parse_pushIndex(p, ip.idx);
- bc_parse_push_block_flag(p, BC_PARSE_FLAG_LOOP | BC_PARSE_FLAG_LOOP_INNER);
- RETURN_STATUS(BC_STATUS_SUCCESS);
+ s = zbc_parse_stmt(p);
+ if (s) RETURN_STATUS(s);
+
+ n = *((size_t *) bc_vec_top(&p->conds));
+ bc_parse_push(p, BC_INST_JUMP);
+ bc_parse_pushIndex(p, n);
+
+ ipp = bc_vec_top(&p->exits);
+ label = bc_vec_top(&p->conds);
+
+ dbg_lex("%s:%d BC_INST_JUMP to %d", __func__, __LINE__, *label);
+ bc_parse_push(p, BC_INST_JUMP);
+ bc_parse_pushIndex(p, *label);
+
+ label = bc_vec_item(&p->func->labels, ipp->idx);
+ dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
+ *label = p->func->code.len;
+
+ bc_vec_pop(&p->exits);
+ bc_vec_pop(&p->conds);
+
+ RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
# define zbc_parse_while(...) (zbc_parse_while(__VA_ARGS__), BC_STATUS_SUCCESS)
@@ -4257,7 +4254,10 @@ static BC_STATUS zbc_parse_for(BcParse *p)
{
BcStatus s;
BcInstPtr ip;
+ BcInstPtr *ipp;
+ size_t *label;
size_t cond_idx, exit_idx, body_idx, update_idx;
+ size_t n;
dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
s = zbc_lex_next(&p->l);
@@ -4324,7 +4324,28 @@ static BC_STATUS zbc_parse_for(BcParse *p)
bc_vec_push(&p->func->labels, &ip.idx);
s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s);
- bc_parse_push_block_flag(p, BC_PARSE_FLAG_LOOP | BC_PARSE_FLAG_LOOP_INNER);
+
+ s = zbc_parse_stmt(p);
+ if (s) RETURN_STATUS(s);
+
+ n = *((size_t *) bc_vec_top(&p->conds));
+ bc_parse_push(p, BC_INST_JUMP);
+ bc_parse_pushIndex(p, n);
+
+ ipp = bc_vec_top(&p->exits);
+ label = bc_vec_top(&p->conds);
+
+//TODO: commonalize?
+ dbg_lex("%s:%d BC_INST_JUMP to %d", __func__, __LINE__, *label);
+ bc_parse_push(p, BC_INST_JUMP);
+ bc_parse_pushIndex(p, *label);
+
+ label = bc_vec_item(&p->func->labels, ipp->idx);
+ dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
+ *label = p->func->code.len;
+
+ bc_vec_pop(&p->exits);
+ bc_vec_pop(&p->conds);
RETURN_STATUS(BC_STATUS_SUCCESS);
}
@@ -4332,14 +4353,12 @@ static BC_STATUS zbc_parse_for(BcParse *p)
# define zbc_parse_for(...) (zbc_parse_for(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
-static BC_STATUS zbc_parse_loopExit(BcParse *p, BcLexType type)
+static BC_STATUS zbc_parse_break_or_continue(BcParse *p, BcLexType type)
{
BcStatus s;
size_t i;
BcInstPtr *ip;
- if (!BC_PARSE_LOOP(p)) RETURN_STATUS(bc_error_bad_token());
-
if (type == BC_LEX_KEY_BREAK) {
if (p->exits.len == 0) RETURN_STATUS(bc_error_bad_token());
@@ -4368,14 +4387,13 @@ static BC_STATUS zbc_parse_loopExit(BcParse *p, BcLexType type)
RETURN_STATUS(zbc_lex_next(&p->l));
}
#if ERRORS_ARE_FATAL
-# define zbc_parse_loopExit(...) (zbc_parse_loopExit(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_parse_break_or_continue(...) (zbc_parse_break_or_continue(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
static BC_STATUS zbc_parse_func(BcParse *p)
{
BcStatus s;
bool var, comma = false;
- uint8_t flags;
char *name;
s = zbc_lex_next(&p->l);
@@ -4430,15 +4448,18 @@ static BC_STATUS zbc_parse_func(BcParse *p)
if (comma) RETURN_STATUS(bc_error("bad function definition"));
- flags = BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_FUNC_INNER | BC_PARSE_FLAG_BODY;
- bc_parse_push_block_flag(p, flags);
-
s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s);
if (p->l.t.t != BC_LEX_LBRACE)
s = bc_POSIX_requires("the left brace be on the same line as the function header");
+ s = zbc_parse_stmt_possibly_auto(p, true);
+ if (s) RETURN_STATUS(s);
+
+ bc_parse_push(p, BC_INST_RET0);
+ bc_parse_updateFunc(p, BC_PROG_MAIN);
+
RETURN_STATUS(s);
err:
@@ -4455,12 +4476,11 @@ static BC_STATUS zbc_parse_auto(BcParse *p)
bool comma, var, one;
char *name;
- if (!p->auto_part) RETURN_STATUS(bc_error_bad_token());
-
+ dbg_lex_enter("%s:%d entered", __func__, __LINE__);
s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s);
- p->auto_part = comma = false;
+ comma = false;
one = p->l.t.t == BC_LEX_NAME;
while (p->l.t.t == BC_LEX_NAME) {
@@ -4498,91 +4518,53 @@ static BC_STATUS zbc_parse_auto(BcParse *p)
if (p->l.t.t != BC_LEX_NLINE && p->l.t.t != BC_LEX_SCOLON)
RETURN_STATUS(bc_error_bad_token());
+ dbg_lex_done("%s:%d done", __func__, __LINE__);
RETURN_STATUS(zbc_lex_next(&p->l));
err:
free(name);
+ dbg_lex_done("%s:%d done (ERROR)", __func__, __LINE__);
RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
# define zbc_parse_auto(...) (zbc_parse_auto(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
-static BC_STATUS zbc_parse_body(BcParse *p, bool brace)
+#undef zbc_parse_stmt_possibly_auto
+static BC_STATUS zbc_parse_stmt_possibly_auto(BcParse *p, bool auto_allowed)
{
BcStatus s = BC_STATUS_SUCCESS;
- uint8_t *flag_ptr = BC_PARSE_TOP_FLAG_PTR(p);
-
- dbg_lex_enter("%s:%d entered", __func__, __LINE__);
- *flag_ptr &= ~(BC_PARSE_FLAG_BODY);
- if (*flag_ptr & BC_PARSE_FLAG_FUNC_INNER) {
- dbg_lex("%s:%d BC_PARSE_FLAG_FUNC_INNER", __func__, __LINE__);
- if (!brace) RETURN_STATUS(bc_error_bad_token());
-
- p->auto_part = p->l.t.t != BC_LEX_KEY_AUTO;
-
- if (!p->auto_part) {
- s = zbc_parse_auto(p);
- if (s) RETURN_STATUS(s);
- }
+ dbg_lex_enter("%s:%d entered, p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
- if (p->l.t.t == BC_LEX_NLINE) s = zbc_lex_next(&p->l);
+ if (p->l.t.t == BC_LEX_NLINE) {
+ dbg_lex_done("%s:%d done (seen BC_LEX_NLINE)", __func__, __LINE__);
+ RETURN_STATUS(zbc_lex_next(&p->l));
}
- else {
- dbg_lex("%s:%d !BC_PARSE_FLAG_FUNC_INNER", __func__, __LINE__);
- s = zbc_parse_stmt(p);
- if (!s && !brace && !BC_PARSE_BODY(p)) s = zbc_parse_endBody(p);
+ if (p->l.t.t == BC_LEX_SCOLON) {
+ dbg_lex_done("%s:%d done (seen BC_LEX_SCOLON)", __func__, __LINE__);
+ RETURN_STATUS(zbc_lex_next(&p->l));
}
- dbg_lex_done("%s:%d done", __func__, __LINE__);
- RETURN_STATUS(s);
-}
-#if ERRORS_ARE_FATAL
-# define zbc_parse_body(...) (zbc_parse_body(__VA_ARGS__), BC_STATUS_SUCCESS)
-#endif
-
-#undef zbc_parse_stmt
-static BC_STATUS zbc_parse_stmt(BcParse *p)
-{
- BcStatus s = BC_STATUS_SUCCESS;
-
- dbg_lex_enter("%s:%d entered, p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
- switch (p->l.t.t) {
- case BC_LEX_NLINE:
- dbg_lex_done("%s:%d done (seen BC_LEX_NLINE)", __func__, __LINE__);
- RETURN_STATUS(zbc_lex_next(&p->l));
-
- case BC_LEX_KEY_ELSE:
- dbg_lex("%s:%d BC_LEX_KEY_ELSE:", __func__, __LINE__);
- p->auto_part = false;
- break;
-
- case BC_LEX_LBRACE:
- dbg_lex("%s:%d BC_LEX_LBRACE:", __func__, __LINE__);
- if (!BC_PARSE_BODY(p)) RETURN_STATUS(bc_error_bad_token());
- ++p->nbraces;
+ if (p->l.t.t == BC_LEX_LBRACE) {
+ dbg_lex("%s:%d BC_LEX_LBRACE: (auto_allowed:%d)", __func__, __LINE__, auto_allowed);
+ do {
s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s);
- dbg_lex_done("%s:%d done (returning zbc_parse_body())", __func__, __LINE__);
- RETURN_STATUS(zbc_parse_body(p, true));
-
- case BC_LEX_KEY_AUTO:
- dbg_lex("%s:%d BC_LEX_KEY_AUTO:", __func__, __LINE__);
- RETURN_STATUS(zbc_parse_auto(p));
-
- default:
- p->auto_part = false;
- if (BC_PARSE_IF_END(p)) {
- bc_parse_noElse(p);
- dbg_lex_done("%s:%d done (BC_PARSE_IF_END is true)", __func__, __LINE__);
- RETURN_STATUS(BC_STATUS_SUCCESS);
- }
- if (BC_PARSE_BODY(p)) {
- dbg_lex_done("%s:%d done (returning zbc_parse_body())", __func__, __LINE__);
- RETURN_STATUS(zbc_parse_body(p, false));
- }
- break;
+ } while (p->l.t.t == BC_LEX_NLINE);
+ if (auto_allowed && p->l.t.t == BC_LEX_KEY_AUTO) {
+ dbg_lex("%s:%d calling zbc_parse_auto()", __func__, __LINE__);
+ s = zbc_parse_auto(p);
+ if (s) RETURN_STATUS(s);
+ }
+ while (p->l.t.t != BC_LEX_RBRACE) {
+ dbg_lex("%s:%d block parsing loop", __func__, __LINE__);
+ s = zbc_parse_stmt(p);
+ if (s) RETURN_STATUS(s);
+ }
+ s = zbc_lex_next(&p->l);
+ dbg_lex_done("%s:%d done (seen BC_LEX_RBRACE)", __func__, __LINE__);
+ RETURN_STATUS(s);
}
dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
@@ -4603,26 +4585,12 @@ static BC_STATUS zbc_parse_stmt(BcParse *p)
case BC_LEX_KEY_SQRT:
s = zbc_parse_expr(p, BC_PARSE_PRINT, bc_parse_next_expr);
break;
- case BC_LEX_KEY_ELSE:
- s = zbc_parse_else(p);
- break;
- case BC_LEX_SCOLON:
- while (!s && p->l.t.t == BC_LEX_SCOLON) s = zbc_lex_next(&p->l);
- break;
- case BC_LEX_RBRACE:
- if (p->nbraces == 0)
- RETURN_STATUS(bc_error_bad_token());
- --p->nbraces;
- s = zbc_lex_next(&p->l);
- if (!s)
- s = zbc_parse_endBody(p);
- break;
case BC_LEX_STR:
s = zbc_parse_string(p, BC_INST_PRINT_STR);
break;
case BC_LEX_KEY_BREAK:
case BC_LEX_KEY_CONTINUE:
- s = zbc_parse_loopExit(p, p->l.t.t);
+ s = zbc_parse_break_or_continue(p, p->l.t.t);
break;
case BC_LEX_KEY_FOR:
s = zbc_parse_for(p);
@@ -4637,8 +4605,6 @@ static BC_STATUS zbc_parse_stmt(BcParse *p)
case BC_LEX_KEY_LIMITS:
// "limits" is a compile-time command,
// the output is produced at _parse time_.
- s = zbc_lex_next(&p->l);
- if (s) RETURN_STATUS(s);
printf(
"BC_BASE_MAX = "BC_MAX_OBASE_STR "\n"
"BC_DIM_MAX = "BC_MAX_DIM_STR "\n"
@@ -4649,6 +4615,7 @@ static BC_STATUS zbc_parse_stmt(BcParse *p)
"MAX Exponent = "BC_MAX_EXP_STR "\n"
"Number of vars = "BC_MAX_VARS_STR "\n"
);
+ s = zbc_lex_next(&p->l);
break;
case BC_LEX_KEY_PRINT:
s = zbc_parse_print(p);
@@ -4669,11 +4636,16 @@ static BC_STATUS zbc_parse_stmt(BcParse *p)
break;
}
+ if (s || G_interrupt) {
+ bc_parse_reset(p);
+ s = BC_STATUS_FAILURE;
+ }
+
dbg_lex_done("%s:%d done", __func__, __LINE__);
RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
-# define zbc_parse_stmt(...) (zbc_parse_stmt(__VA_ARGS__), BC_STATUS_SUCCESS)
+# define zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__), BC_STATUS_SUCCESS)
#endif
static BC_STATUS zbc_parse_stmt_or_funcdef(BcParse *p)
@@ -4682,22 +4654,15 @@ static BC_STATUS zbc_parse_stmt_or_funcdef(BcParse *p)
dbg_lex_enter("%s:%d entered", __func__, __LINE__);
if (p->l.t.t == BC_LEX_EOF)
- s = BC_PARSE_FLAG_STACK_EMPTY(p) ? bc_error("end of file") : bc_error("block end could not be found");
+ s = bc_error("end of file");
else if (p->l.t.t == BC_LEX_KEY_DEFINE) {
dbg_lex("%s:%d p->l.t.t:BC_LEX_KEY_DEFINE", __func__, __LINE__);
- if (!BC_PARSE_CAN_EXEC(p))
- RETURN_STATUS(bc_error_bad_token());
s = zbc_parse_func(p);
} else {
dbg_lex("%s:%d p->l.t.t:%d (not BC_LEX_KEY_DEFINE)", __func__, __LINE__, p->l.t.t);
s = zbc_parse_stmt(p);
}
- if (s || G_interrupt) {
- bc_parse_reset(p);
- s = BC_STATUS_FAILURE;
- }
-
dbg_lex_done("%s:%d done", __func__, __LINE__);
RETURN_STATUS(s);
}
@@ -4940,6 +4905,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
if (prev == BC_INST_BOOL_NOT || nexprs != 1)
return bc_error_bad_expression();
+//TODO: why is this needed at all?
// next is BcParseNext, byte array of up to 4 BC_LEX's, packed into 32-bit word
for (;;) {
if (t == (next & 0x7f))
@@ -4948,7 +4914,8 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext ne
break;
next >>= 8;
}
- return bc_error_bad_expression();
+ if (t != BC_LEX_KEY_ELSE)
+ return bc_error_bad_expression();
ok:
if (!(flags & BC_PARSE_REL) && nrelops) {
@@ -6766,6 +6733,7 @@ static BC_STATUS zbc_program_exec(void)
s = zbc_program_incdec(inst);
break;
case BC_INST_HALT:
+ dbg_exec("BC_INST_HALT:");
QUIT_OR_RETURN_TO_MAIN;
break;
case BC_INST_RET:
@@ -6939,6 +6907,7 @@ static BC_STATUS zbc_program_exec(void)
break;
}
case BC_INST_QUIT:
+ dbg_exec("BC_INST_NEG:");
if (G.prog.stack.len <= 2)
QUIT_OR_RETURN_TO_MAIN;
bc_vec_npop(&G.prog.stack, 2);
@@ -6994,14 +6963,12 @@ static BC_STATUS zbc_vm_process(const char *text)
dbg_lex("%s:%d G.prs.l.t.t:%d", __func__, __LINE__, G.prs.l.t.t);
ERROR_RETURN(s =) zcommon_parse(&G.prs);
if (s) RETURN_STATUS(s);
- }
- dbg_lex("%s:%d G.prs.l.t.t:BC_LEX_EOF", __func__, __LINE__);
-
- if (BC_PARSE_CAN_EXEC(&G.prs)) {
s = zbc_program_exec();
- fflush_and_check();
- if (s)
+ if (s) {
bc_program_reset();
+ break;
+ }
+ fflush_and_check();
}
dbg_lex_done("%s:%d done", __func__, __LINE__);
@@ -7049,91 +7016,12 @@ err:
static BC_STATUS zbc_vm_stdin(void)
{
BcStatus s;
- BcVec buffer;
- size_t str;
- bool comment;
//G.prog.file = NULL; - already is
bc_lex_file(&G.prs.l);
- bc_char_vec_init(&buffer);
-
- // This loop is complex because the vm tries not to send any lines that end
- // with a backslash to the parser. The reason for that is because the parser
- // treats a backslash+newline combo as whitespace, per the bc spec. In that
- // case, and for strings and comments, the parser will expect more stuff.
- s = BC_STATUS_SUCCESS;
- comment = false;
- str = 0;
- for (;;) {
- size_t prevlen = buffer.len;
- char *string;
-
- bc_read_line(&buffer);
- // No more input means EOF
- if (buffer.len <= prevlen + 1) // (we expect +1 for NUL byte)
- break;
-
- string = buffer.v + prevlen;
- while (*string) {
- char c = *string;
- if (string == buffer.v || string[-1] != '\\') {
- if (IS_BC)
- str ^= (c == '"');
- else {
- if (c == ']')
- str -= 1;
- else if (c == '[')
- str += 1;
- }
- }
- string++;
- if (c == '/' && *string == '*') {
- comment = true;
- string++;
- continue;
- }
- if (c == '*' && *string == '/') {
- comment = false;
- string++;
- }
- }
- if (str || comment) {
- buffer.len--; // backstep over the trailing NUL byte
- continue;
- }
-
- // Check for backslash+newline.
- // we do not check that last char is '\n' -
- // if it is not, then it's EOF, and looping back
- // to bc_read_line() will detect it:
- string -= 2;
- if (string >= buffer.v && *string == '\\') {
- buffer.len--;
- continue;
- }
-
- s = zbc_vm_process(buffer.v);
- if (s) {
- if (ENABLE_FEATURE_CLEAN_UP && !G_ttyin) {
- // Debug config, non-interactive mode:
- // return all the way back to main.
- // Non-debug builds do not come here, they exit.
- break;
- }
- }
-
- bc_vec_pop_all(&buffer);
- }
-
- if (str) {
- s = bc_error("string end could not be found");
- }
- else if (comment) {
- s = bc_error("comment end could not be found");
- }
-
- bc_vec_free(&buffer);
+ G.use_stdin = 1;
+ s = zbc_vm_process("");
RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
@@ -7412,9 +7300,6 @@ static BC_STATUS zbc_vm_exec(void)
if (IS_BC || (option_mask32 & BC_FLAG_I))
s = zbc_vm_stdin();
- if (!s && !BC_PARSE_CAN_EXEC(&G.prs))
- s = zbc_vm_process("");
-
RETURN_STATUS(s);
}
#if ERRORS_ARE_FATAL
@@ -7443,6 +7328,7 @@ static void bc_program_free(void)
bc_num_free(&G.prog.last);
bc_num_free(&G.prog.zero);
bc_num_free(&G.prog.one);
+ bc_vec_free(&G.stdin_buffer);
}
static void bc_vm_free(void)
@@ -7506,6 +7392,8 @@ static void bc_program_init(void)
bc_vec_init(&G.prog.results, sizeof(BcResult), bc_result_free);
bc_vec_init(&G.prog.stack, sizeof(BcInstPtr), NULL);
bc_vec_push(&G.prog.stack, &ip);
+
+ bc_char_vec_init(&G.stdin_buffer);
}
static int bc_vm_init(const char *env_len)
@@ -7562,6 +7450,7 @@ static BcStatus bc_vm_run(void)
# endif
FREE_G();
#endif
+ dbg_exec("exiting with exitcode %d", st);
return st;
}