dc: unbreak interactive mode - was trying to get next tokens instead of executing

function                                             old     new   delta
zbc_program_read                                       -     268    +268
zdc_program_printStream                                -     146    +146
zbc_program_exec                                    4046    4182    +136
zdc_program_execStr                                  472     512     +40
zdc_parse_exprs_until_eof                              -      26     +26
zbc_vm_process                                       740     765     +25
zbc_lex_next                                        2225    2240     +15
zdc_parse_expr                                       569     535     -34
zbc_program_pushArray                                147       -    -147
zdc_program_asciify                                  370       -    -370
------------------------------------------------------------------------------
(add/remove: 3/2 grow/shrink: 4/1 up/down: 656/-551)          Total: 105 bytes

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 66 insertions, 30 deletions

diff --git a/miscutils/bc.c b/miscutils/bc.c
index 5d5449efa..d8fbb6ed7 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -3431,6 +3431,17 @@ static BC_STATUS zdc_lex_token(BcLex *l)
 //                      l->t.t = BC_LEX_EOF;
 //                      break;
                 case '\n':
+                        // '\n' is BC_LEX_NLINE, not BC_LEX_WHITESPACE
+                        // (and "case '\n'" is not just empty here)
+                        // only to allow interactive dc have a way to exit
+                        // "parse" stage of "parse,execute" loop
+                        // on '\n', not on _next_ token (which would mean
+                        // command are not executed on pressing <enter>).
+                        // IOW: typing "1p<enter>" should print "1" _at once_,
+                        // not after some more input.
+                        l->t.t = BC_LEX_NLINE;
+                        l->newline = true;
+                        break;
                 case '\t':
                 case '\v':
                 case '\f':
@@ -4861,12 +4872,16 @@ static BC_STATUS zdc_parse_cond(BcParse *p, uint8_t inst)
         s = zbc_lex_next(&p->l);
         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.t.t == BC_LEX_ELSE) {
                 s = zdc_parse_register(p);
                 if (s) RETURN_STATUS(s);
                 s = zbc_lex_next(&p->l);
-        } else
+        } else {
                 bc_parse_push(p, BC_PARSE_STREND);
+        }
 
         RETURN_STATUS(s);
 }
@@ -4945,33 +4960,32 @@ static BC_STATUS zdc_parse_token(BcParse *p, BcLexType t)
 
 static BC_STATUS zdc_parse_expr(BcParse *p)
 {
-        BcLexType t;
-
-        dbg_lex_enter("%s:%d entered, p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
-        for (;;) {
-                BcInst inst;
-                BcStatus s;
+        BcInst inst;
+        BcStatus s;
 
-                t = p->l.t.t;
-                dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
-                if (t == BC_LEX_EOF) break;
+        inst = dc_parse_insts[p->l.t.t];
+        if (inst != BC_INST_INVALID) {
+                bc_parse_push(p, inst);
+                s = zbc_lex_next(&p->l);
+        } else {
+                s = zdc_parse_token(p, p->l.t.t);
+        }
+        RETURN_STATUS(s);
+}
+#define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__) COMMA_SUCCESS)
 
-                inst = dc_parse_insts[t];
-                if (inst != BC_INST_INVALID) {
-                        dbg_lex("%s:%d", __func__, __LINE__);
-                        bc_parse_push(p, inst);
-                        s = zbc_lex_next(&p->l);
-                } else {
-                        dbg_lex("%s:%d", __func__, __LINE__);
-                        s = zdc_parse_token(p, t);
-                }
+static BC_STATUS zdc_parse_exprs_until_eof(BcParse *p)
+{
+        dbg_lex_enter("%s:%d entered, p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
+        while (p->l.t.t != BC_LEX_EOF) {
+                BcStatus s = zdc_parse_expr(p);
                 if (s) RETURN_STATUS(s);
         }
 
         dbg_lex_done("%s:%d done", __func__, __LINE__);
         RETURN_STATUS(BC_STATUS_SUCCESS);
 }
-#define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__) COMMA_SUCCESS)
+#define zdc_parse_exprs_until_eof(...) (zdc_parse_exprs_until_eof(__VA_ARGS__) COMMA_SUCCESS)
 
 #endif // ENABLE_DC
 
@@ -5182,7 +5196,7 @@ static BC_STATUS zbc_program_read(void)
         if (IS_BC) {
                 IF_BC(s = zbc_parse_expr(&parse, 0));
         } else {
-                IF_DC(s = zdc_parse_expr(&parse));
+                IF_DC(s = zdc_parse_exprs_until_eof(&parse));
         }
         if (s) goto exec_err;
 
@@ -6304,6 +6318,7 @@ static BC_STATUS zdc_program_execStr(char *code, size_t *bgn, bool cond)
         f = bc_program_func(fidx);
 
         if (f->code.len == 0) {
+                FILE *sv_input_fp;
                 BcParse prs;
                 char *str;
 
@@ -6311,7 +6326,12 @@ static BC_STATUS zdc_program_execStr(char *code, size_t *bgn, bool cond)
                 str = *bc_program_str(sidx);
                 s = zbc_parse_text_init(&prs, str);
                 if (s) goto err;
-                s = zdc_parse_expr(&prs);
+
+                sv_input_fp = G.input_fp;
+                G.input_fp = NULL; // "do not read from input file when <EOL> reached"
+                s = zdc_parse_exprs_until_eof(&prs);
+                G.input_fp = sv_input_fp;
+
                 if (s) goto err;
                 if (prs.l.t.t != BC_LEX_EOF) {
                         s = bc_error_bad_expression();
@@ -6439,12 +6459,15 @@ static BC_STATUS zbc_program_exec(void)
                                 s = zbc_program_pushArray(code, &ip->inst_idx, inst);
                                 break;
                         case BC_INST_LAST:
+//TODO: this can't happen on dc, right?
+                                dbg_exec("BC_INST_LAST:");
                                 r.t = BC_RESULT_LAST;
                                 bc_vec_push(&G.prog.results, &r);
                                 break;
                         case BC_INST_IBASE:
                         case BC_INST_SCALE:
                         case BC_INST_OBASE:
+                                dbg_exec("BC_INST_internalvar:");
                                 bc_program_pushGlobal(inst);
                                 break;
                         case BC_INST_SCALE_FUNC:
@@ -6519,17 +6542,21 @@ static BC_STATUS zbc_program_exec(void)
                                 bc_vec_pop(&G.prog.exestack);
                                 goto read_updated_ip;
                         case BC_INST_MODEXP:
+                                dbg_exec("BC_INST_MODEXP:");
                                 s = zdc_program_modexp();
                                 break;
                         case BC_INST_DIVMOD:
+                                dbg_exec("BC_INST_DIVMOD:");
                                 s = zdc_program_divmod();
                                 break;
                         case BC_INST_EXECUTE:
                         case BC_INST_EXEC_COND:
+                                dbg_exec("BC_INST_EXEC[_COND]:");
                                 s = zdc_program_execStr(code, &ip->inst_idx, inst == BC_INST_EXEC_COND);
                                 goto read_updated_ip;
                         case BC_INST_PRINT_STACK: {
                                 size_t idx;
+                                dbg_exec("BC_INST_PRINT_STACK:");
                                 for (idx = 0; idx < G.prog.results.len; ++idx) {
                                         s = zbc_program_print(BC_INST_PRINT, idx);
                                         if (s) break;
@@ -6537,12 +6564,15 @@ static BC_STATUS zbc_program_exec(void)
                                 break;
                         }
                         case BC_INST_CLEAR_STACK:
+                                dbg_exec("BC_INST_CLEAR_STACK:");
                                 bc_vec_pop_all(&G.prog.results);
                                 break;
                         case BC_INST_STACK_LEN:
+                                dbg_exec("BC_INST_STACK_LEN:");
                                 dc_program_stackLen();
                                 break;
                         case BC_INST_DUPLICATE:
+                                dbg_exec("BC_INST_DUPLICATE:");
                                 if (!STACK_HAS_MORE_THAN(&G.prog.results, 0))
                                         RETURN_STATUS(bc_error_stack_has_too_few_elements());
                                 ptr = bc_vec_top(&G.prog.results);
@@ -6551,6 +6581,7 @@ static BC_STATUS zbc_program_exec(void)
                                 break;
                         case BC_INST_SWAP: {
                                 BcResult *ptr2;
+                                dbg_exec("BC_INST_SWAP:");
                                 if (!STACK_HAS_MORE_THAN(&G.prog.results, 1))
                                         RETURN_STATUS(bc_error_stack_has_too_few_elements());
                                 ptr = bc_vec_item_rev(&G.prog.results, 0);
@@ -6561,9 +6592,11 @@ static BC_STATUS zbc_program_exec(void)
                                 break;
                         }
                         case BC_INST_ASCIIFY:
+                                dbg_exec("BC_INST_ASCIIFY:");
                                 s = zdc_program_asciify();
                                 break;
                         case BC_INST_PRINT_STREAM:
+                                dbg_exec("BC_INST_STREAM:");
                                 s = zdc_program_printStream();
                                 break;
                         case BC_INST_LOAD:
@@ -6585,6 +6618,7 @@ static BC_STATUS zbc_program_exec(void)
                                 bc_vec_npop(&G.prog.exestack, 2);
                                 goto read_updated_ip;
                         case BC_INST_NQUIT:
+                                dbg_exec("BC_INST_NQUIT:");
                                 s = zdc_program_nquit();
                                 //goto read_updated_ip; - just fall through to it
 #endif // ENABLE_DC
@@ -6629,25 +6663,20 @@ static BC_STATUS zbc_vm_process(const char *text)
         BcStatus s;
 
         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
-        s = zbc_parse_text_init(&G.prs, text);
+        s = zbc_parse_text_init(&G.prs, text); // does the first zbc_lex_next()
         if (s) RETURN_STATUS(s);
 
         while (G.prs.l.t.t != BC_LEX_EOF) {
                 dbg_lex("%s:%d G.prs.l.t.t:%d, parsing...", __func__, __LINE__, G.prs.l.t.t);
                 if (IS_BC) {
-// FIXME: "eating" of stmt delemiters is coded inconsistently
+// FIXME: "eating" of stmt delimiters is coded inconsistently
 // (sometimes zbc_parse_stmt() eats the delimiter, sometimes don't),
 // which causes bugs such as "print 1 print 2" erroneously accepted,
 // or "print 1 else 2" detecting parse error only after executing
 // "print 1" part.
                         IF_BC(s = zbc_parse_stmt_or_funcdef(&G.prs));
                 } else {
-#if ENABLE_DC
-                        if (G.prs.l.t.t == BC_LEX_EOF)
-                                s = bc_error("end of file");
-                        else
-                                s = zdc_parse_expr(&G.prs);
-#endif
+                        IF_DC(s = zdc_parse_expr(&G.prs));
                 }
                 if (s || G_interrupt) {
                         bc_parse_reset(&G.prs); // includes bc_program_reset()
@@ -6689,6 +6718,13 @@ static BC_STATUS zbc_vm_process(const char *text)
                         ip->inst_idx = 0;
                         IF_BC(bc_vec_pop_all(&f->strs);)
                         IF_BC(bc_vec_pop_all(&f->consts);)
+                } else {
+                        // Most of dc parsing assumes all whitespace,
+                        // including '\n', is eaten.
+                        if (G.prs.l.t.t == BC_LEX_NLINE) {
+                                s = zbc_lex_next(&G.prs.l);
+                                if (s) RETURN_STATUS(s);
+                        }
                 }
         }