bc: fold struct BcLex into BcParse

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

1 files changed, 262 insertions, 267 deletions

diff --git a/miscutils/bc.c b/miscutils/bc.c
index 44d4976cc..61fb24304 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -710,7 +710,7 @@ dc_LEX_to_INST[] = { // starts at XC_LEX_OP_POWER       // corresponding XC/DC_L
 };
 #endif // ENABLE_DC
 
-typedef struct BcLex {
+typedef struct BcParse {
         smallint lex;      // was BcLexType // first member is most used
         smallint lex_last; // was BcLexType
         bool   lex_newline;
@@ -719,14 +719,9 @@ typedef struct BcLex {
         size_t lex_len;
         const char *lex_inbuf;
         const char *lex_next_at; // last lex_next() was called at this string
+        const char *lex_filename;
+        FILE *lex_input_fp;
         BcVec  lex_strnumbuf;
-} BcLex;
-
-typedef struct BcParse {
-        BcLex l; // first member is most used
-
-        const char *filename;
-        FILE *input_fp;
 
         BcFunc *func;
         size_t fidx;
@@ -937,12 +932,12 @@ static void quit(void)
 static void bc_verror_msg(const char *fmt, va_list p)
 {
         const char *sv = sv; // for compiler
-        if (G.prs.filename) {
+        if (G.prs.lex_filename) {
                 sv = applet_name;
-                applet_name = xasprintf("%s: %s:%u", applet_name, G.prs.filename, G.err_line);
+                applet_name = xasprintf("%s: %s:%u", applet_name, G.prs.lex_filename, G.err_line);
         }
         bb_verror_msg(fmt, p, NULL);
-        if (G.prs.filename) {
+        if (G.prs.lex_filename) {
                 free((char*)applet_name);
                 applet_name = sv;
         }
@@ -2582,12 +2577,12 @@ static void bc_read_line(BcVec *vec, FILE *fp)
 
                 if (bad_chars) {
                         // Bad chars on this line
-                        if (!G.prs.filename) { // stdin
+                        if (!G.prs.lex_filename) { // stdin
                                 // ignore entire line, get another one
                                 vec->len = len;
                                 goto again;
                         }
-                        bb_perror_msg_and_die("file '%s' is not text", G.prs.filename);
+                        bb_perror_msg_and_die("file '%s' is not text", G.prs.lex_filename);
                 }
                 bc_vec_pushZeroByte(vec);
         }
@@ -2751,39 +2746,39 @@ static BC_STATUS zbc_num_parse(BcNum *n, const char *val, unsigned base_t)
 
 static void bc_lex_lineComment(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         // Try: echo -n '#foo' | bc
         size_t i;
-        l->lex = XC_LEX_WHITESPACE;
-        i = l->lex_i;
-        while (i < l->lex_len && l->lex_inbuf[i] != '\n')
+        p->lex = XC_LEX_WHITESPACE;
+        i = p->lex_i;
+        while (i < p->lex_len && p->lex_inbuf[i] != '\n')
                 i++;
-        l->lex_i = i;
+        p->lex_i = i;
 }
 
 static void bc_lex_whitespace(void)
 {
-        BcLex *l = &G.prs.l;
-        l->lex = XC_LEX_WHITESPACE;
+        BcParse *p = &G.prs;
+        p->lex = XC_LEX_WHITESPACE;
         for (;;) {
-                char c = l->lex_inbuf[l->lex_i];
+                char c = p->lex_inbuf[p->lex_i];
                 if (c == '\n') // this is XC_LEX_NLINE, not XC_LEX_WHITESPACE
                         break;
                 if (!isspace(c))
                         break;
-                l->lex_i++;
+                p->lex_i++;
         }
 }
 
 static BC_STATUS zbc_lex_number(char start)
 {
-        BcLex *l = &G.prs.l;
-        const char *buf = l->lex_inbuf + l->lex_i;
+        BcParse *p = &G.prs;
+        const char *buf = p->lex_inbuf + p->lex_i;
         size_t len, i, ccnt;
         bool pt;
 
         pt = (start == '.');
-        l->lex = XC_LEX_NUMBER;
+        p->lex = XC_LEX_NUMBER;
         ccnt = i = 0;
         for (;;) {
                 char c = buf[i];
@@ -2808,7 +2803,7 @@ static BC_STATUS zbc_lex_number(char start)
         //ccnt is the number of chars in the number string, excluding possible
         //trailing "[\<newline>].[\<newline>]" (with any number of \<NL> repetitions).
         //i is buf[i] index of the first not-yet-parsed char after that.
-        l->lex_i += i;
+        p->lex_i += i;
 
         // This might overestimate the size, if there are "\<NL>"'s
         // in the number. Subtracting number_of_backslashes*2 correctly
@@ -2823,9 +2818,9 @@ static BC_STATUS zbc_lex_number(char start)
                         RETURN_STATUS(bc_error("number too long: must be [1,"BC_MAX_NUM_STR"]"));
         }
 
-        bc_vec_pop_all(&l->lex_strnumbuf);
-        bc_vec_expand(&l->lex_strnumbuf, 1 + len);
-        bc_vec_push(&l->lex_strnumbuf, &start);
+        bc_vec_pop_all(&p->lex_strnumbuf);
+        bc_vec_expand(&p->lex_strnumbuf, 1 + len);
+        bc_vec_push(&p->lex_strnumbuf, &start);
 
         while (ccnt != 0) {
                 // If we have hit a backslash, skip it. We don't have
@@ -2835,12 +2830,12 @@ static BC_STATUS zbc_lex_number(char start)
                         ccnt -= 2;
                         continue;
                 }
-                bc_vec_push(&l->lex_strnumbuf, buf);
+                bc_vec_push(&p->lex_strnumbuf, buf);
                 buf++;
                 ccnt--;
         }
 
-        bc_vec_pushZeroByte(&l->lex_strnumbuf);
+        bc_vec_pushZeroByte(&p->lex_strnumbuf);
 
         RETURN_STATUS(BC_STATUS_SUCCESS);
 }
@@ -2848,14 +2843,14 @@ static BC_STATUS zbc_lex_number(char start)
 
 static void bc_lex_name(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         size_t i;
         const char *buf;
 
-        l->lex = XC_LEX_NAME;
+        p->lex = XC_LEX_NAME;
 
         i = 0;
-        buf = l->lex_inbuf + l->lex_i - 1;
+        buf = p->lex_inbuf + p->lex_i - 1;
         for (;;) {
                 char c = buf[i];
                 if ((c < 'a' || c > 'z') && !isdigit(c) && c != '_') break;
@@ -2869,33 +2864,33 @@ static void bc_lex_name(void)
                         return bc_error("name too long: must be [1,"BC_MAX_STRING_STR"]");
         }
 #endif
-        bc_vec_string(&l->lex_strnumbuf, i, buf);
+        bc_vec_string(&p->lex_strnumbuf, i, buf);
 
         // Increment the index. We minus 1 because it has already been incremented.
-        l->lex_i += i - 1;
+        p->lex_i += i - 1;
 
         //return BC_STATUS_SUCCESS;
 }
 
 static void bc_lex_init(void)
 {
-        bc_char_vec_init(&G.prs.l.lex_strnumbuf);
+        bc_char_vec_init(&G.prs.lex_strnumbuf);
 }
 
 static void bc_lex_free(void)
 {
-        bc_vec_free(&G.prs.l.lex_strnumbuf);
+        bc_vec_free(&G.prs.lex_strnumbuf);
 }
 
 static void bc_lex_file(void)
 {
-        G.err_line = G.prs.l.lex_line = 1;
-        G.prs.l.lex_newline = false;
+        G.err_line = G.prs.lex_line = 1;
+        G.prs.lex_newline = false;
 }
 
 static bool bc_lex_more_input(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         size_t str;
         bool comment;
 
@@ -2911,7 +2906,7 @@ static bool bc_lex_more_input(void)
                 size_t prevlen = G.input_buffer.len;
                 char *string;
 
-                bc_read_line(&G.input_buffer, G.prs.input_fp);
+                bc_read_line(&G.input_buffer, G.prs.lex_input_fp);
                 // No more input means EOF
                 if (G.input_buffer.len <= prevlen + 1) // (we expect +1 for NUL byte)
                         break;
@@ -2958,12 +2953,12 @@ static bool bc_lex_more_input(void)
                 break;
         }
 
-        l->lex_inbuf = G.input_buffer.v;
-        l->lex_i = 0;
+        p->lex_inbuf = G.input_buffer.v;
+        p->lex_i = 0;
 //      bb_error_msg("G.input_buffer.len:%d '%s'", G.input_buffer.len, G.input_buffer.v);
-        l->lex_len = G.input_buffer.len - 1; // do not include NUL
+        p->lex_len = G.input_buffer.len - 1; // do not include NUL
 
-        return l->lex_len != 0;
+        return p->lex_len != 0;
 }
 
 IF_BC(static BC_STATUS zbc_lex_token(void);)
@@ -2973,43 +2968,43 @@ IF_DC(static BC_STATUS zdc_lex_token(void);)
 
 static BC_STATUS zbc_lex_next(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         BcStatus s;
 
-        l->lex_last = l->lex;
-        if (l->lex_last == XC_LEX_EOF) RETURN_STATUS(bc_error("end of file"));
+        p->lex_last = p->lex;
+        if (p->lex_last == XC_LEX_EOF) RETURN_STATUS(bc_error("end of file"));
 
-        l->lex_line += l->lex_newline;
-        G.err_line = l->lex_line;
-        l->lex_newline = false;
+        p->lex_line += p->lex_newline;
+        G.err_line = p->lex_line;
+        p->lex_newline = false;
 
         // Loop until failure or we don't have whitespace. This
         // is so the parser doesn't get inundated with whitespace.
         // Comments are also XC_LEX_WHITESPACE tokens and eaten here.
         s = BC_STATUS_SUCCESS;
         do {
-                if (l->lex_i == l->lex_len) {
-                        l->lex = XC_LEX_EOF;
-                        if (!G.prs.input_fp)
+                if (p->lex_i == p->lex_len) {
+                        p->lex = XC_LEX_EOF;
+                        if (!G.prs.lex_input_fp)
                                 RETURN_STATUS(BC_STATUS_SUCCESS);
                         if (!bc_lex_more_input()) {
-                                G.prs.input_fp = NULL;
+                                G.prs.lex_input_fp = NULL;
                                 RETURN_STATUS(BC_STATUS_SUCCESS);
                         }
-                        // here it's guaranteed that l->lex_i is below l->lex_len
+                        // here it's guaranteed that p->lex_i is below p->lex_len
                 }
-                l->lex_next_at = l->lex_inbuf + l->lex_i;
+                p->lex_next_at = p->lex_inbuf + p->lex_i;
                 dbg_lex("next string to parse:'%.*s'",
-                        (int)(strchrnul(l->lex_next_at, '\n') - l->lex_next_at),
-                        l->lex_next_at
+                        (int)(strchrnul(p->lex_next_at, '\n') - p->lex_next_at),
+                        p->lex_next_at
                 );
                 if (IS_BC) {
                         IF_BC(s = zbc_lex_token());
                 } else {
                         IF_DC(s = zdc_lex_token());
                 }
-        } while (!s && l->lex == XC_LEX_WHITESPACE);
-        dbg_lex("l->lex from string:%d", l->lex);
+        } while (!s && p->lex == XC_LEX_WHITESPACE);
+        dbg_lex("p->lex from string:%d", p->lex);
 
         RETURN_STATUS(s);
 }
@@ -3018,7 +3013,7 @@ static BC_STATUS zbc_lex_next(void)
 #if ENABLE_BC
 static BC_STATUS zbc_lex_skip_if_at_NLINE(void)
 {
-        if (G.prs.l.lex == XC_LEX_NLINE)
+        if (G.prs.lex == XC_LEX_NLINE)
                 RETURN_STATUS(zbc_lex_next());
         RETURN_STATUS(BC_STATUS_SUCCESS);
 }
@@ -3038,10 +3033,10 @@ static BC_STATUS zbc_lex_next_and_skip_NLINE(void)
 
 static BC_STATUS zbc_lex_text_init(const char *text)
 {
-        G.prs.l.lex_inbuf = text;
-        G.prs.l.lex_i = 0;
-        G.prs.l.lex_len = strlen(text);
-        G.prs.l.lex = G.prs.l.lex_last = XC_LEX_INVALID;
+        G.prs.lex_inbuf = text;
+        G.prs.lex_i = 0;
+        G.prs.lex_len = strlen(text);
+        G.prs.lex = G.prs.lex_last = XC_LEX_INVALID;
         RETURN_STATUS(zbc_lex_next());
 }
 #define zbc_lex_text_init(...) (zbc_lex_text_init(__VA_ARGS__) COMMA_SUCCESS)
@@ -3049,10 +3044,10 @@ static BC_STATUS zbc_lex_text_init(const char *text)
 #if ENABLE_BC
 static BC_STATUS zbc_lex_identifier(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         BcStatus s;
         unsigned i;
-        const char *buf = l->lex_inbuf + l->lex_i - 1;
+        const char *buf = p->lex_inbuf + p->lex_i - 1;
 
         for (i = 0; i < ARRAY_SIZE(bc_lex_kws); ++i) {
                 const char *keyword8 = bc_lex_kws[i].name8;
@@ -3067,21 +3062,21 @@ static BC_STATUS zbc_lex_identifier(void)
                 // buf starts with keyword bc_lex_kws[i]
                 if (isalnum(buf[j]) || buf[j]=='_')
                         continue; // "ifz" does not match "if" keyword, "if." does
-                l->lex = BC_LEX_KEY_1st_keyword + i;
+                p->lex = BC_LEX_KEY_1st_keyword + i;
                 if (!keyword_is_POSIX(i)) {
                         s = zbc_posix_error_fmt("%sthe '%.8s' keyword", "POSIX does not allow ", bc_lex_kws[i].name8);
                         if (s) RETURN_STATUS(s);
                 }
 
                 // We minus 1 because the index has already been incremented.
-                l->lex_i += j - 1;
+                p->lex_i += j - 1;
                 RETURN_STATUS(BC_STATUS_SUCCESS);
         }
 
         bc_lex_name();
         s = BC_STATUS_SUCCESS;
 
-        if (l->lex_strnumbuf.len > 2) {
+        if (p->lex_strnumbuf.len > 2) {
                 // Prevent this:
                 // >>> qwe=1
                 // bc: POSIX only allows one character names; this is bad: 'qwe=1
@@ -3096,17 +3091,17 @@ static BC_STATUS zbc_lex_identifier(void)
 
 static BC_STATUS zbc_lex_string(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         size_t len, nls, i;
 
-        l->lex = XC_LEX_STR;
+        p->lex = XC_LEX_STR;
 
         nls = 0;
-        i = l->lex_i;
+        i = p->lex_i;
         for (;;) {
-                char c = l->lex_inbuf[i];
+                char c = p->lex_inbuf[i];
                 if (c == '\0') {
-                        l->lex_i = i;
+                        p->lex_i = i;
                         RETURN_STATUS(bc_error("unterminated string"));
                 }
                 if (c == '"')
@@ -3115,17 +3110,17 @@ static BC_STATUS zbc_lex_string(void)
                 i++;
         }
 
-        len = i - l->lex_i;
+        len = i - p->lex_i;
         // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
         if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
                 if (len > BC_MAX_STRING)
                         RETURN_STATUS(bc_error("string too long: must be [1,"BC_MAX_STRING_STR"]"));
         }
-        bc_vec_string(&l->lex_strnumbuf, len, l->lex_inbuf + l->lex_i);
+        bc_vec_string(&p->lex_strnumbuf, len, p->lex_inbuf + p->lex_i);
 
-        l->lex_i = i + 1;
-        l->lex_line += nls;
-        G.err_line = l->lex_line;
+        p->lex_i = i + 1;
+        p->lex_line += nls;
+        G.err_line = p->lex_line;
 
         RETURN_STATUS(BC_STATUS_SUCCESS);
 }
@@ -3133,24 +3128,24 @@ static BC_STATUS zbc_lex_string(void)
 
 static void bc_lex_assign(unsigned with_and_without)
 {
-        BcLex *l = &G.prs.l;
-        if (l->lex_inbuf[l->lex_i] == '=') {
-                l->lex_i++;
+        BcParse *p = &G.prs;
+        if (p->lex_inbuf[p->lex_i] == '=') {
+                p->lex_i++;
                 with_and_without >>= 8; // store "with" value
         } // else store "without" value
-        l->lex = (with_and_without & 0xff);
+        p->lex = (with_and_without & 0xff);
 }
 #define bc_lex_assign(with, without) \
         bc_lex_assign(((with)<<8)|(without))
 
 static BC_STATUS zbc_lex_comment(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         size_t i, nls = 0;
-        const char *buf = l->lex_inbuf;
+        const char *buf = p->lex_inbuf;
 
-        l->lex = XC_LEX_WHITESPACE;
-        i = l->lex_i; /* here buf[l->lex_i] is the '*' of opening comment delimiter */
+        p->lex = XC_LEX_WHITESPACE;
+        i = p->lex_i; /* here buf[p->lex_i] is the '*' of opening comment delimiter */
         for (;;) {
                 char c = buf[++i];
  check_star:
@@ -3161,15 +3156,15 @@ static BC_STATUS zbc_lex_comment(void)
                         goto check_star;
                 }
                 if (c == '\0') {
-                        l->lex_i = i;
+                        p->lex_i = i;
                         RETURN_STATUS(bc_error("unterminated comment"));
                 }
                 nls += (c == '\n');
         }
 
-        l->lex_i = i + 1;
-        l->lex_line += nls;
-        G.err_line = l->lex_line;
+        p->lex_i = i + 1;
+        p->lex_line += nls;
+        G.err_line = p->lex_line;
 
         RETURN_STATUS(BC_STATUS_SUCCESS);
 }
@@ -3178,20 +3173,20 @@ static BC_STATUS zbc_lex_comment(void)
 #undef zbc_lex_token
 static BC_STATUS zbc_lex_token(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         BcStatus s = BC_STATUS_SUCCESS;
-        char c = l->lex_inbuf[l->lex_i++], c2;
+        char c = p->lex_inbuf[p->lex_i++], c2;
 
         // This is the workhorse of the lexer.
         switch (c) {
 //              case '\0': // probably never reached
-//                      l->lex_i--;
-//                      l->lex = XC_LEX_EOF;
-//                      l->lex_newline = true;
+//                      p->lex_i--;
+//                      p->lex = XC_LEX_EOF;
+//                      p->lex_newline = true;
 //                      break;
                 case '\n':
-                        l->lex = XC_LEX_NLINE;
-                        l->lex_newline = true;
+                        p->lex = XC_LEX_NLINE;
+                        p->lex_newline = true;
                         break;
                 case '\t':
                 case '\v':
@@ -3202,7 +3197,7 @@ static BC_STATUS zbc_lex_token(void)
                         break;
                 case '!':
                         bc_lex_assign(XC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT);
-                        if (l->lex == BC_LEX_OP_BOOL_NOT) {
+                        if (p->lex == BC_LEX_OP_BOOL_NOT) {
                                 s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("!");
                                 if (s) RETURN_STATUS(s);
                         }
@@ -3219,53 +3214,53 @@ static BC_STATUS zbc_lex_token(void)
                         bc_lex_assign(BC_LEX_OP_ASSIGN_MODULUS, XC_LEX_OP_MODULUS);
                         break;
                 case '&':
-                        c2 = l->lex_inbuf[l->lex_i];
+                        c2 = p->lex_inbuf[p->lex_i];
                         if (c2 == '&') {
                                 s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("&&");
                                 if (s) RETURN_STATUS(s);
-                                l->lex_i++;
-                                l->lex = BC_LEX_OP_BOOL_AND;
+                                p->lex_i++;
+                                p->lex = BC_LEX_OP_BOOL_AND;
                         } else {
-                                l->lex = XC_LEX_INVALID;
+                                p->lex = XC_LEX_INVALID;
                                 s = bc_error_bad_character('&');
                         }
                         break;
                 case '(':
                 case ')':
-                        l->lex = (BcLexType)(c - '(' + BC_LEX_LPAREN);
+                        p->lex = (BcLexType)(c - '(' + BC_LEX_LPAREN);
                         break;
                 case '*':
                         bc_lex_assign(BC_LEX_OP_ASSIGN_MULTIPLY, XC_LEX_OP_MULTIPLY);
                         break;
                 case '+':
-                        c2 = l->lex_inbuf[l->lex_i];
+                        c2 = p->lex_inbuf[p->lex_i];
                         if (c2 == '+') {
-                                l->lex_i++;
-                                l->lex = BC_LEX_OP_INC;
+                                p->lex_i++;
+                                p->lex = BC_LEX_OP_INC;
                         } else
                                 bc_lex_assign(BC_LEX_OP_ASSIGN_PLUS, XC_LEX_OP_PLUS);
                         break;
                 case ',':
-                        l->lex = BC_LEX_COMMA;
+                        p->lex = BC_LEX_COMMA;
                         break;
                 case '-':
-                        c2 = l->lex_inbuf[l->lex_i];
+                        c2 = p->lex_inbuf[p->lex_i];
                         if (c2 == '-') {
-                                l->lex_i++;
-                                l->lex = BC_LEX_OP_DEC;
+                                p->lex_i++;
+                                p->lex = BC_LEX_OP_DEC;
                         } else
                                 bc_lex_assign(BC_LEX_OP_ASSIGN_MINUS, XC_LEX_OP_MINUS);
                         break;
                 case '.':
-                        if (isdigit(l->lex_inbuf[l->lex_i]))
+                        if (isdigit(p->lex_inbuf[p->lex_i]))
                                 s = zbc_lex_number(c);
                         else {
-                                l->lex = BC_LEX_KEY_LAST;
+                                p->lex = BC_LEX_KEY_LAST;
                                 s = zbc_POSIX_does_not_allow("'.' as 'last'");
                         }
                         break;
                 case '/':
-                        c2 = l->lex_inbuf[l->lex_i];
+                        c2 = p->lex_inbuf[p->lex_i];
                         if (c2 == '*')
                                 s = zbc_lex_comment();
                         else
@@ -3290,7 +3285,7 @@ static BC_STATUS zbc_lex_token(void)
                         s = zbc_lex_number(c);
                         break;
                 case ';':
-                        l->lex = BC_LEX_SCOLON;
+                        p->lex = BC_LEX_SCOLON;
                         break;
                 case '<':
                         bc_lex_assign(XC_LEX_OP_REL_LE, XC_LEX_OP_REL_LT);
@@ -3303,12 +3298,12 @@ static BC_STATUS zbc_lex_token(void)
                         break;
                 case '[':
                 case ']':
-                        l->lex = (BcLexType)(c - '[' + BC_LEX_LBRACKET);
+                        p->lex = (BcLexType)(c - '[' + BC_LEX_LBRACKET);
                         break;
                 case '\\':
-                        if (l->lex_inbuf[l->lex_i] == '\n') {
-                                l->lex = XC_LEX_WHITESPACE;
-                                l->lex_i++;
+                        if (p->lex_inbuf[p->lex_i] == '\n') {
+                                p->lex = XC_LEX_WHITESPACE;
+                                p->lex_i++;
                         } else
                                 s = bc_error_bad_character(c);
                         break;
@@ -3345,22 +3340,22 @@ static BC_STATUS zbc_lex_token(void)
                         break;
                 case '{':
                 case '}':
-                        l->lex = (BcLexType)(c - '{' + BC_LEX_LBRACE);
+                        p->lex = (BcLexType)(c - '{' + BC_LEX_LBRACE);
                         break;
                 case '|':
-                        c2 = l->lex_inbuf[l->lex_i];
+                        c2 = p->lex_inbuf[p->lex_i];
                         if (c2 == '|') {
                                 s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("||");
                                 if (s) RETURN_STATUS(s);
-                                l->lex_i++;
-                                l->lex = BC_LEX_OP_BOOL_OR;
+                                p->lex_i++;
+                                p->lex = BC_LEX_OP_BOOL_OR;
                         } else {
-                                l->lex = XC_LEX_INVALID;
+                                p->lex = XC_LEX_INVALID;
                                 s = bc_error_bad_character(c);
                         }
                         break;
                 default:
-                        l->lex = XC_LEX_INVALID;
+                        p->lex = XC_LEX_INVALID;
                         s = bc_error_bad_character(c);
                         break;
         }
@@ -3373,16 +3368,16 @@ static BC_STATUS zbc_lex_token(void)
 #if ENABLE_DC
 static BC_STATUS zdc_lex_register(void)
 {
-        BcLex *l = &G.prs.l;
-        if (G_exreg && isspace(l->lex_inbuf[l->lex_i])) {
+        BcParse *p = &G.prs;
+        if (G_exreg && isspace(p->lex_inbuf[p->lex_i])) {
                 bc_lex_whitespace(); // eats whitespace (but not newline)
-                l->lex_i++; // bc_lex_name() expects this
+                p->lex_i++; // bc_lex_name() expects this
                 bc_lex_name();
         } else {
-                bc_vec_pop_all(&l->lex_strnumbuf);
-                bc_vec_push(&l->lex_strnumbuf, &l->lex_inbuf[l->lex_i++]);
-                bc_vec_pushZeroByte(&l->lex_strnumbuf);
-                l->lex = XC_LEX_NAME;
+                bc_vec_pop_all(&p->lex_strnumbuf);
+                bc_vec_push(&p->lex_strnumbuf, &p->lex_inbuf[p->lex_i++]);
+                bc_vec_pushZeroByte(&p->lex_strnumbuf);
+                p->lex = XC_LEX_NAME;
         }
 
         RETURN_STATUS(BC_STATUS_SUCCESS);
@@ -3391,43 +3386,43 @@ static BC_STATUS zdc_lex_register(void)
 
 static BC_STATUS zdc_lex_string(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         size_t depth, nls, i;
 
-        l->lex = XC_LEX_STR;
-        bc_vec_pop_all(&l->lex_strnumbuf);
+        p->lex = XC_LEX_STR;
+        bc_vec_pop_all(&p->lex_strnumbuf);
 
         nls = 0;
         depth = 1;
-        i = l->lex_i;
+        i = p->lex_i;
         for (;;) {
-                char c = l->lex_inbuf[i];
+                char c = p->lex_inbuf[i];
                 if (c == '\0') {
-                        l->lex_i = i;
+                        p->lex_i = i;
                         RETURN_STATUS(bc_error("string end could not be found"));
                 }
                 nls += (c == '\n');
-                if (i == l->lex_i || l->lex_inbuf[i - 1] != '\\') {
+                if (i == p->lex_i || p->lex_inbuf[i - 1] != '\\') {
                         if (c == '[') depth++;
                         if (c == ']')
                                 if (--depth == 0)
                                         break;
                 }
-                bc_vec_push(&l->lex_strnumbuf, &l->lex_inbuf[i]);
+                bc_vec_push(&p->lex_strnumbuf, &p->lex_inbuf[i]);
                 i++;
         }
         i++;
 
-        bc_vec_pushZeroByte(&l->lex_strnumbuf);
+        bc_vec_pushZeroByte(&p->lex_strnumbuf);
         // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
         if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
-                if (i - l->lex_i > BC_MAX_STRING)
+                if (i - p->lex_i > BC_MAX_STRING)
                         RETURN_STATUS(bc_error("string too long: must be [1,"BC_MAX_STRING_STR"]"));
         }
 
-        l->lex_i = i;
-        l->lex_line += nls;
-        G.err_line = l->lex_line;
+        p->lex_i = i;
+        p->lex_line += nls;
+        G.err_line = p->lex_line;
 
         RETURN_STATUS(BC_STATUS_SUCCESS);
 }
@@ -3436,7 +3431,7 @@ static BC_STATUS zdc_lex_string(void)
 #undef zdc_lex_token
 static BC_STATUS zdc_lex_token(void)
 {
-        BcLex *l = &G.prs.l;
+        BcParse *p = &G.prs;
         static const //BcLexType - should be this type, but narrower type saves size:
         uint8_t
         dc_lex_regs[] = {
@@ -3451,14 +3446,14 @@ static BC_STATUS zdc_lex_token(void)
         size_t i;
 
         for (i = 0; i < ARRAY_SIZE(dc_lex_regs); ++i) {
-                if (l->lex_last == dc_lex_regs[i])
+                if (p->lex_last == dc_lex_regs[i])
                         RETURN_STATUS(zdc_lex_register());
         }
 
         s = BC_STATUS_SUCCESS;
-        c = l->lex_inbuf[l->lex_i++];
+        c = p->lex_inbuf[p->lex_i++];
         if (c >= '%' && c <= '~'
-         && (l->lex = dc_char_to_LEX[c - '%']) != XC_LEX_INVALID
+         && (p->lex = dc_char_to_LEX[c - '%']) != XC_LEX_INVALID
         ) {
                 RETURN_STATUS(s);
         }
@@ -3466,7 +3461,7 @@ static BC_STATUS zdc_lex_token(void)
         // This is the workhorse of the lexer.
         switch (c) {
 //              case '\0': // probably never reached
-//                      l->lex = XC_LEX_EOF;
+//                      p->lex = XC_LEX_EOF;
 //                      break;
                 case '\n':
                         // '\n' is XC_LEX_NLINE, not XC_LEX_WHITESPACE
@@ -3477,34 +3472,34 @@ static BC_STATUS zdc_lex_token(void)
                         // commands are not executed on pressing <enter>).
                         // IOW: typing "1p<enter>" should print "1" _at once_,
                         // not after some more input.
-                        l->lex = XC_LEX_NLINE;
-                        l->lex_newline = true;
+                        p->lex = XC_LEX_NLINE;
+                        p->lex_newline = true;
                         break;
                 case '\t':
                 case '\v':
                 case '\f':
                 case '\r':
                 case ' ':
-                        l->lex_newline = 0; // was (c == '\n')
+                        p->lex_newline = 0; // was (c == '\n')
                         bc_lex_whitespace();
                         break;
                 case '!':
-                        c2 = l->lex_inbuf[l->lex_i];
+                        c2 = p->lex_inbuf[p->lex_i];
                         if (c2 == '=')
-                                l->lex = XC_LEX_OP_REL_NE;
+                                p->lex = XC_LEX_OP_REL_NE;
                         else if (c2 == '<')
-                                l->lex = XC_LEX_OP_REL_LE;
+                                p->lex = XC_LEX_OP_REL_LE;
                         else if (c2 == '>')
-                                l->lex = XC_LEX_OP_REL_GE;
+                                p->lex = XC_LEX_OP_REL_GE;
                         else
                                 RETURN_STATUS(bc_error_bad_character(c));
-                        l->lex_i++;
+                        p->lex_i++;
                         break;
                 case '#':
                         bc_lex_lineComment();
                         break;
                 case '.':
-                        if (isdigit(l->lex_inbuf[l->lex_i]))
+                        if (isdigit(p->lex_inbuf[p->lex_i]))
                                 s = zbc_lex_number(c);
                         else
                                 s = bc_error_bad_character(c);
@@ -3531,7 +3526,7 @@ static BC_STATUS zdc_lex_token(void)
                         s = zdc_lex_string();
                         break;
                 default:
-                        l->lex = XC_LEX_INVALID;
+                        p->lex = XC_LEX_INVALID;
                         s = bc_error_bad_character(c);
                         break;
         }
@@ -3593,7 +3588,7 @@ static void bc_parse_pushJUMP_ZERO(size_t idx)
 static BC_STATUS zbc_parse_pushSTR(void)
 {
         BcParse *p = &G.prs;
-        char *str = xstrdup(p->l.lex_strnumbuf.v);
+        char *str = xstrdup(p->lex_strnumbuf.v);
 
         bc_parse_push(XC_INST_STR);
         bc_parse_pushIndex(p->func->strs.len);
@@ -3607,7 +3602,7 @@ static BC_STATUS zbc_parse_pushSTR(void)
 static void bc_parse_pushNUM(void)
 {
         BcParse *p = &G.prs;
-        char *num = xstrdup(p->l.lex_strnumbuf.v);
+        char *num = xstrdup(p->lex_strnumbuf.v);
 #if ENABLE_BC && ENABLE_DC
         size_t idx = bc_vec_push(IS_BC ? &p->func->consts : &G.prog.consts, &num);
 #elif ENABLE_BC
@@ -3656,8 +3651,8 @@ static void bc_parse_reset(void)
                 p->func = bc_program_func_BC_PROG_MAIN();
         }
 
-        p->l.lex_i = p->l.lex_len;
-        p->l.lex = XC_LEX_EOF;
+        p->lex_i = p->lex_len;
+        p->lex = XC_LEX_EOF;
 
         IF_BC(bc_vec_pop_all(&p->exits);)
         IF_BC(bc_vec_pop_all(&p->conds);)
@@ -3765,7 +3760,7 @@ static BC_STATUS zbc_parse_stmt_allow_NLINE_before(const char *after_X)
         // Same for "else", "while()", "for()".
         BcStatus s = zbc_lex_next_and_skip_NLINE();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex == XC_LEX_NLINE)
+        if (p->lex == XC_LEX_NLINE)
                 RETURN_STATUS(bc_error_fmt("no statement after '%s'", after_X));
 
         RETURN_STATUS(zbc_parse_stmt());
@@ -3825,20 +3820,20 @@ static BC_STATUS zbc_parse_params(uint8_t flags)
         BcStatus s;
         size_t nparams;
 
-        dbg_lex("%s:%d p->l.lex:%d", __func__, __LINE__, p->l.lex);
+        dbg_lex("%s:%d p->lex:%d", __func__, __LINE__, p->lex);
         flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
         nparams = 0;
-        if (p->l.lex != BC_LEX_RPAREN) {
+        if (p->lex != BC_LEX_RPAREN) {
                 for (;;) {
                         s = zbc_parse_expr(flags);
                         if (s) RETURN_STATUS(s);
                         nparams++;
-                        if (p->l.lex != BC_LEX_COMMA) {
-                                if (p->l.lex == BC_LEX_RPAREN)
+                        if (p->lex != BC_LEX_COMMA) {
+                                if (p->lex == BC_LEX_RPAREN)
                                         break;
                                 RETURN_STATUS(bc_error_bad_token());
                         }
@@ -3867,7 +3862,7 @@ static BC_STATUS zbc_parse_call(char *name, uint8_t flags)
         s = zbc_parse_params(flags);
         if (s) goto err;
 
-        if (p->l.lex != BC_LEX_RPAREN) {
+        if (p->lex != BC_LEX_RPAREN) {
                 s = bc_error_bad_token();
                 goto err;
         }
@@ -3897,15 +3892,15 @@ static BC_STATUS zbc_parse_name(BcInst *type, uint8_t flags)
         BcStatus s;
         char *name;
 
-        name = xstrdup(p->l.lex_strnumbuf.v);
+        name = xstrdup(p->lex_strnumbuf.v);
         s = zbc_lex_next();
         if (s) goto err;
 
-        if (p->l.lex == BC_LEX_LBRACKET) {
+        if (p->lex == BC_LEX_LBRACKET) {
                 s = zbc_lex_next();
                 if (s) goto err;
 
-                if (p->l.lex == BC_LEX_RBRACKET) {
+                if (p->lex == BC_LEX_RBRACKET) {
                         if (!(flags & BC_PARSE_ARRAY)) {
                                 s = bc_error_bad_expression();
                                 goto err;
@@ -3922,7 +3917,7 @@ static BC_STATUS zbc_parse_name(BcInst *type, uint8_t flags)
                 bc_parse_push(*type);
                 bc_parse_pushName(name);
                 free(name);
-        } else if (p->l.lex == BC_LEX_LPAREN) {
+        } else if (p->lex == BC_LEX_LPAREN) {
                 if (flags & BC_PARSE_NOCALL) {
                         s = bc_error_bad_token();
                         goto err;
@@ -3950,11 +3945,11 @@ static BC_STATUS zbc_parse_read(void)
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
 
         bc_parse_push(XC_INST_READ);
 
@@ -3969,7 +3964,7 @@ static BC_STATUS zbc_parse_builtin(BcLexType type, uint8_t flags, BcInst *prev)
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
 
         flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
 
@@ -3979,7 +3974,7 @@ static BC_STATUS zbc_parse_builtin(BcLexType type, uint8_t flags, BcInst *prev)
         s = zbc_parse_expr(flags);
         if (s) RETURN_STATUS(s);
 
-        if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
+        if (p->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(*prev);
@@ -3996,7 +3991,7 @@ static BC_STATUS zbc_parse_scale(BcInst *type, uint8_t flags)
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
-        if (p->l.lex != BC_LEX_LPAREN) {
+        if (p->lex != BC_LEX_LPAREN) {
                 *type = XC_INST_SCALE;
                 bc_parse_push(XC_INST_SCALE);
                 RETURN_STATUS(BC_STATUS_SUCCESS);
@@ -4010,7 +4005,7 @@ static BC_STATUS zbc_parse_scale(BcInst *type, uint8_t flags)
 
         s = zbc_parse_expr(flags);
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_RPAREN)
+        if (p->lex != BC_LEX_RPAREN)
                 RETURN_STATUS(bc_error_bad_token());
         bc_parse_push(XC_INST_SCALE_FUNC);
 
@@ -4031,16 +4026,16 @@ static BC_STATUS zbc_parse_incdec(BcInst *prev, bool *paren_expr,
          || etype == XC_INST_SCALE || etype == BC_INST_LAST
          || etype == XC_INST_IBASE || etype == XC_INST_OBASE
         ) {
-                *prev = inst = BC_INST_INC_POST + (p->l.lex != BC_LEX_OP_INC);
+                *prev = inst = BC_INST_INC_POST + (p->lex != BC_LEX_OP_INC);
                 bc_parse_push(inst);
                 s = zbc_lex_next();
         } else {
-                *prev = inst = BC_INST_INC_PRE + (p->l.lex != BC_LEX_OP_INC);
+                *prev = inst = BC_INST_INC_PRE + (p->lex != BC_LEX_OP_INC);
                 *paren_expr = true;
 
                 s = zbc_lex_next();
                 if (s) RETURN_STATUS(s);
-                type = p->l.lex;
+                type = p->lex;
 
                 // Because we parse the next part of the expression
                 // right here, we need to increment this.
@@ -4059,7 +4054,7 @@ static BC_STATUS zbc_parse_incdec(BcInst *prev, bool *paren_expr,
                         case BC_LEX_KEY_SCALE:
                                 s = zbc_lex_next();
                                 if (s) RETURN_STATUS(s);
-                                if (p->l.lex == BC_LEX_LPAREN)
+                                if (p->lex == BC_LEX_LPAREN)
                                         s = bc_error_bad_token();
                                 else
                                         bc_parse_push(XC_INST_SCALE);
@@ -4128,7 +4123,7 @@ static BC_STATUS zbc_parse_print(void)
         for (;;) {
                 s = zbc_lex_next();
                 if (s) RETURN_STATUS(s);
-                type = p->l.lex;
+                type = p->lex;
                 if (type == XC_LEX_STR) {
                         s = zbc_parse_pushSTR();
                 } else {
@@ -4136,7 +4131,7 @@ static BC_STATUS zbc_parse_print(void)
                 }
                 if (s) RETURN_STATUS(s);
                 bc_parse_push(XC_INST_PRINT_POP);
-                if (p->l.lex != BC_LEX_COMMA)
+                if (p->lex != BC_LEX_COMMA)
                         break;
         }
 
@@ -4154,7 +4149,7 @@ static BC_STATUS zbc_parse_return(void)
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
-        t = p->l.lex;
+        t = p->lex;
         if (t == XC_LEX_NLINE || t == BC_LEX_SCOLON)
                 bc_parse_push(BC_INST_RET0);
         else {
@@ -4166,7 +4161,7 @@ static BC_STATUS zbc_parse_return(void)
                 }
                 if (s) RETURN_STATUS(s);
 
-                if (!paren || p->l.lex_last != BC_LEX_RPAREN) {
+                if (!paren || p->lex_last != BC_LEX_RPAREN) {
                         s = zbc_POSIX_requires("parentheses around return expressions");
                         if (s) RETURN_STATUS(s);
                 }
@@ -4195,13 +4190,13 @@ static BC_STATUS zbc_parse_if(void)
         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
         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());
+        if (p->lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
 
         // Encode "if zero, jump to ..."
         // Pushed value (destination of the jump) is uninitialized,
@@ -4212,8 +4207,8 @@ static BC_STATUS zbc_parse_if(void)
         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);
-        if (p->l.lex == BC_LEX_KEY_ELSE) {
+        dbg_lex("%s:%d in if after stmt: p->lex:%d", __func__, __LINE__, p->lex);
+        if (p->lex == BC_LEX_KEY_ELSE) {
                 size_t ip2_idx;
 
                 // Encode "after then_stmt, jump to end of if()"
@@ -4247,7 +4242,7 @@ static BC_STATUS zbc_parse_while(void)
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
@@ -4260,7 +4255,7 @@ static BC_STATUS zbc_parse_while(void)
 
         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());
+        if (p->lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
 
         bc_parse_pushJUMP_ZERO(ip_idx);
 
@@ -4286,14 +4281,14 @@ static BC_STATUS zbc_parse_for(void)
         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);
+        dbg_lex("%s:%d p->lex:%d", __func__, __LINE__, p->lex);
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
-        if (p->l.lex != BC_LEX_SCOLON) {
+        if (p->lex != BC_LEX_SCOLON) {
                 s = zbc_parse_expr(0);
                 bc_parse_push(XC_INST_POP);
                 if (s) RETURN_STATUS(s);
@@ -4302,7 +4297,7 @@ static BC_STATUS zbc_parse_for(void)
                 if (s) RETURN_STATUS(s);
         }
 
-        if (p->l.lex != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
@@ -4311,19 +4306,19 @@ static BC_STATUS zbc_parse_for(void)
         body_idx = update_idx + 1;
         exit_idx = body_idx + 1;
 
-        if (p->l.lex != BC_LEX_SCOLON)
+        if (p->lex != BC_LEX_SCOLON)
                 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_strnumbuf, 1, "1");
+                bc_vec_string(&p->lex_strnumbuf, 1, "1");
                 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());
+        if (p->lex != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
@@ -4334,10 +4329,10 @@ static BC_STATUS zbc_parse_for(void)
         bc_vec_push(&p->conds, &update_idx);
         bc_vec_push(&p->func->labels, &p->func->code.len);
 
-        if (p->l.lex != BC_LEX_RPAREN) {
+        if (p->lex != BC_LEX_RPAREN) {
                 s = zbc_parse_expr(0);
                 if (s) RETURN_STATUS(s);
-                if (p->l.lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
+                if (p->lex != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
                 bc_parse_push(XC_INST_POP);
         } else {
                 s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("update");
@@ -4415,37 +4410,37 @@ static BC_STATUS zbc_parse_funcdef(void)
         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != XC_LEX_NAME)
+        if (p->lex != XC_LEX_NAME)
                 RETURN_STATUS(bc_error("bad function definition"));
 
-        name = xstrdup(p->l.lex_strnumbuf.v);
+        name = xstrdup(p->lex_strnumbuf.v);
         p->fidx = bc_program_addFunc(name);
         p->func = bc_program_func(p->fidx);
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != BC_LEX_LPAREN)
+        if (p->lex != BC_LEX_LPAREN)
                 RETURN_STATUS(bc_error("bad function definition"));
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
-        while (p->l.lex != BC_LEX_RPAREN) {
-                if (p->l.lex != XC_LEX_NAME)
+        while (p->lex != BC_LEX_RPAREN) {
+                if (p->lex != XC_LEX_NAME)
                         RETURN_STATUS(bc_error("bad function definition"));
 
                 ++p->func->nparams;
 
-                name = xstrdup(p->l.lex_strnumbuf.v);
+                name = xstrdup(p->lex_strnumbuf.v);
                 s = zbc_lex_next();
                 if (s) goto err;
 
-                var = p->l.lex != BC_LEX_LBRACKET;
+                var = p->lex != BC_LEX_LBRACKET;
 
                 if (!var) {
                         s = zbc_lex_next();
                         if (s) goto err;
 
-                        if (p->l.lex != BC_LEX_RBRACKET) {
+                        if (p->lex != BC_LEX_RBRACKET) {
                                 s = bc_error("bad function definition");
                                 goto err;
                         }
@@ -4454,7 +4449,7 @@ static BC_STATUS zbc_parse_funcdef(void)
                         if (s) goto err;
                 }
 
-                comma = p->l.lex == BC_LEX_COMMA;
+                comma = p->lex == BC_LEX_COMMA;
                 if (comma) {
                         s = zbc_lex_next();
                         if (s) goto err;
@@ -4469,7 +4464,7 @@ static BC_STATUS zbc_parse_funcdef(void)
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
 
-        if (p->l.lex != BC_LEX_LBRACE) {
+        if (p->lex != BC_LEX_LBRACE) {
                 s = zbc_POSIX_requires("the left brace be on the same line as the function header");
                 if (s) RETURN_STATUS(s);
         }
@@ -4478,7 +4473,7 @@ static BC_STATUS zbc_parse_funcdef(void)
         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)
+        if (p->lex != BC_LEX_LBRACE)
                 RETURN_STATUS(bc_error("function { body } expected"));
 
         p->in_funcdef++; // to determine whether "return" stmt is allowed, and such
@@ -4514,19 +4509,19 @@ static BC_STATUS zbc_parse_auto(void)
         for (;;) {
                 bool var;
 
-                if (p->l.lex != XC_LEX_NAME)
+                if (p->lex != XC_LEX_NAME)
                         RETURN_STATUS(bc_error("bad 'auto' syntax"));
 
-                name = xstrdup(p->l.lex_strnumbuf.v);
+                name = xstrdup(p->lex_strnumbuf.v);
                 s = zbc_lex_next();
                 if (s) goto err;
 
-                var = (p->l.lex != BC_LEX_LBRACKET);
+                var = (p->lex != BC_LEX_LBRACKET);
                 if (!var) {
                         s = zbc_lex_next();
                         if (s) goto err;
 
-                        if (p->l.lex != BC_LEX_RBRACKET) {
+                        if (p->lex != BC_LEX_RBRACKET) {
                                 s = bc_error("bad 'auto' syntax");
                                 goto err;
                         }
@@ -4537,13 +4532,13 @@ static BC_STATUS zbc_parse_auto(void)
                 s = zbc_func_insert(p->func, name, var);
                 if (s) goto err;
 
-                if (p->l.lex == XC_LEX_NLINE
-                 || p->l.lex == BC_LEX_SCOLON
-                //|| p->l.lex == BC_LEX_RBRACE // allow "define f() {auto a}"
+                if (p->lex == XC_LEX_NLINE
+                 || p->lex == BC_LEX_SCOLON
+                //|| p->lex == BC_LEX_RBRACE // allow "define f() {auto a}"
                 ) {
                         break;
                 }
-                if (p->l.lex != BC_LEX_COMMA)
+                if (p->lex != BC_LEX_COMMA)
                         RETURN_STATUS(bc_error("bad 'auto' syntax"));
                 s = zbc_lex_next(); // skip comma
                 if (s) RETURN_STATUS(s);
@@ -4564,29 +4559,29 @@ 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);
+        dbg_lex_enter("%s:%d entered, p->lex:%d", __func__, __LINE__, p->lex);
 
-        if (p->l.lex == XC_LEX_NLINE) {
+        if (p->lex == XC_LEX_NLINE) {
                 dbg_lex_done("%s:%d done (seen XC_LEX_NLINE)", __func__, __LINE__);
                 RETURN_STATUS(zbc_lex_next());
         }
-        if (p->l.lex == BC_LEX_SCOLON) {
+        if (p->lex == BC_LEX_SCOLON) {
                 dbg_lex_done("%s:%d done (seen BC_LEX_SCOLON)", __func__, __LINE__);
                 RETURN_STATUS(zbc_lex_next());
         }
 
-        if (p->l.lex == BC_LEX_LBRACE) {
+        if (p->lex == BC_LEX_LBRACE) {
                 dbg_lex("%s:%d BC_LEX_LBRACE: (auto_allowed:%d)", __func__, __LINE__, auto_allowed);
                 do {
                         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) {
+                } while (p->lex == XC_LEX_NLINE);
+                if (auto_allowed && p->lex == BC_LEX_KEY_AUTO) {
                         dbg_lex("%s:%d calling zbc_parse_auto()", __func__, __LINE__);
                         s = zbc_parse_auto();
                         if (s) RETURN_STATUS(s);
                 }
-                while (p->l.lex != BC_LEX_RBRACE) {
+                while (p->lex != BC_LEX_RBRACE) {
                         dbg_lex("%s:%d block parsing loop", __func__, __LINE__);
                         s = zbc_parse_stmt();
                         if (s) RETURN_STATUS(s);
@@ -4596,8 +4591,8 @@ static BC_STATUS zbc_parse_stmt_possibly_auto(bool auto_allowed)
                 RETURN_STATUS(s);
         }
 
-        dbg_lex("%s:%d p->l.lex:%d", __func__, __LINE__, p->l.lex);
-        switch (p->l.lex) {
+        dbg_lex("%s:%d p->lex:%d", __func__, __LINE__, p->lex);
+        switch (p->lex) {
                 case XC_LEX_OP_MINUS:
                 case BC_LEX_OP_INC:
                 case BC_LEX_OP_DEC:
@@ -4620,7 +4615,7 @@ static BC_STATUS zbc_parse_stmt_possibly_auto(bool auto_allowed)
                         break;
                 case BC_LEX_KEY_BREAK:
                 case BC_LEX_KEY_CONTINUE:
-                        s = zbc_parse_break_or_continue(p->l.lex);
+                        s = zbc_parse_break_or_continue(p->lex);
                         break;
                 case BC_LEX_KEY_FOR:
                         s = zbc_parse_for();
@@ -4679,13 +4674,13 @@ static BC_STATUS zbc_parse_stmt_or_funcdef(void)
         BcStatus s;
 
         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
-        if (p->l.lex == XC_LEX_EOF)
+        if (p->lex == XC_LEX_EOF)
                 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__);
+        else if (p->lex == BC_LEX_KEY_DEFINE) {
+                dbg_lex("%s:%d p->lex:BC_LEX_KEY_DEFINE", __func__, __LINE__);
                 s = zbc_parse_funcdef();
         } else {
-                dbg_lex("%s:%d p->l.lex:%d (not BC_LEX_KEY_DEFINE)", __func__, __LINE__, p->l.lex);
+                dbg_lex("%s:%d p->lex:%d (not BC_LEX_KEY_DEFINE)", __func__, __LINE__, p->lex);
                 s = zbc_parse_stmt();
         }
 
@@ -4704,7 +4699,7 @@ static BcStatus bc_parse_expr_empty_ok(uint8_t flags)
         bool paren_first, paren_expr, rprn, assign, bin_last;
 
         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
-        paren_first = (p->l.lex == BC_LEX_LPAREN);
+        paren_first = (p->lex == BC_LEX_LPAREN);
         nparens = nrelops = 0;
         paren_expr = rprn = assign = false;
         bin_last = true;
@@ -4712,7 +4707,7 @@ static BcStatus bc_parse_expr_empty_ok(uint8_t flags)
         for (;;) {
                 bool get_token;
                 BcStatus s;
-                BcLexType t = p->l.lex;
+                BcLexType t = p->lex;
 
                 if (!lex_allowed_in_bc_expr(t))
                         break;
@@ -4923,9 +4918,9 @@ static BC_STATUS zdc_parse_register(void)
 
         s = zbc_lex_next();
         if (s) RETURN_STATUS(s);
-        if (p->l.lex != XC_LEX_NAME) RETURN_STATUS(bc_error_bad_token());
+        if (p->lex != XC_LEX_NAME) RETURN_STATUS(bc_error_bad_token());
 
-        bc_parse_pushName(p->l.lex_strnumbuf.v);
+        bc_parse_pushName(p->lex_strnumbuf.v);
 
         RETURN_STATUS(s);
 }
@@ -4939,7 +4934,7 @@ static void dc_parse_string(void)
 
         dbg_lex_enter("%s:%d entered", __func__, __LINE__);
 
-        str = xstrdup(p->l.lex_strnumbuf.v);
+        str = xstrdup(p->lex_strnumbuf.v);
         bc_parse_push(XC_INST_STR);
         bc_parse_pushIndex(len);
         bc_vec_push(&G.prog.strs, &str);
@@ -4988,7 +4983,7 @@ static BC_STATUS zdc_parse_cond(uint8_t inst)
         // 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) {
+        if (p->lex == DC_LEX_ELSE) {
                 s = zdc_parse_register();
                 if (s) RETURN_STATUS(s);
                 s = zbc_lex_next();
@@ -5033,7 +5028,7 @@ static BC_STATUS zdc_parse_token(BcLexType t)
                         dbg_lex("%s:%d LEX_NEG", __func__, __LINE__);
                         s = zbc_lex_next();
                         if (s) RETURN_STATUS(s);
-                        if (G.prs.l.lex != XC_LEX_NUMBER)
+                        if (G.prs.lex != XC_LEX_NUMBER)
                                 RETURN_STATUS(bc_error_bad_token());
                         bc_parse_pushNUM();
                         bc_parse_push(XC_INST_NEG);
@@ -5083,7 +5078,7 @@ static BC_STATUS zdc_parse_expr(void)
         BcParse *p = &G.prs;
         int i;
 
-        i = (int)p->l.lex - (int)XC_LEX_OP_POWER;
+        i = (int)p->lex - (int)XC_LEX_OP_POWER;
         if (i >= 0) {
                 BcInst inst = dc_LEX_to_INST[i];
                 if (inst != DC_INST_INVALID) {
@@ -5091,15 +5086,15 @@ static BC_STATUS zdc_parse_expr(void)
                         RETURN_STATUS(zbc_lex_next());
                 }
         }
-        RETURN_STATUS(zdc_parse_token(p->l.lex));
+        RETURN_STATUS(zdc_parse_token(p->lex));
 }
 #define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__) COMMA_SUCCESS)
 
 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) {
+        dbg_lex_enter("%s:%d entered, p->lex:%d", __func__, __LINE__, p->lex);
+        while (p->lex != XC_LEX_EOF) {
                 BcStatus s = zdc_parse_expr();
                 if (s) RETURN_STATUS(s);
         }
@@ -5329,7 +5324,7 @@ static BC_STATUS zbc_program_read(void)
         }
         if (s) goto exec_err;
 
-        if (G.prs.l.lex != XC_LEX_NLINE && G.prs.l.lex != XC_LEX_EOF) {
+        if (G.prs.lex != XC_LEX_NLINE && G.prs.lex != XC_LEX_EOF) {
                 s = bc_error("bad read() expression");
                 goto exec_err;
         }
@@ -6460,7 +6455,7 @@ static BC_STATUS zdc_program_execStr(char *code, size_t *bgn, bool cond)
                 s = zdc_parse_exprs_until_eof();
                 if (s) goto err;
                 bc_parse_push(DC_INST_POP_EXEC);
-                if (G.prs.l.lex != XC_LEX_EOF)
+                if (G.prs.lex != XC_LEX_EOF)
                         s = bc_error_bad_expression();
                 bc_parse_free();
                 G.prs = sv_parse; // struct copy
@@ -6797,15 +6792,15 @@ static BC_STATUS zbc_vm_process(const char *text)
         if (s) RETURN_STATUS(s);
 
  IF_BC(check_eof:)
-        while (G.prs.l.lex != XC_LEX_EOF) {
+        while (G.prs.lex != XC_LEX_EOF) {
                 BcInstPtr *ip;
                 BcFunc *f;
 
-                dbg_lex("%s:%d G.prs.l.lex:%d, parsing...", __func__, __LINE__, G.prs.l.lex);
+                dbg_lex("%s:%d G.prs.lex:%d, parsing...", __func__, __LINE__, G.prs.lex);
                 if (IS_BC) {
 #if ENABLE_BC
-                        if (G.prs.l.lex == BC_LEX_SCOLON
-                         || G.prs.l.lex == XC_LEX_NLINE
+                        if (G.prs.lex == BC_LEX_SCOLON
+                         || G.prs.lex == XC_LEX_NLINE
                         ) {
                                 s = zbc_lex_next();
                                 if (s) goto err;
@@ -6817,13 +6812,13 @@ static BC_STATUS zbc_vm_process(const char *text)
 
                         // Check that next token is a correct stmt delimiter -
                         // disallows "print 1 print 2" and such.
-                        if (G.prs.l.lex != BC_LEX_SCOLON
-                         && G.prs.l.lex != XC_LEX_NLINE
-                         && G.prs.l.lex != XC_LEX_EOF
+                        if (G.prs.lex != BC_LEX_SCOLON
+                         && G.prs.lex != XC_LEX_NLINE
+                         && G.prs.lex != XC_LEX_EOF
                         ) {
                                 const char *err_at;
 //TODO: commonalize for other parse errors:
-                                err_at = G.prs.l.lex_next_at ? G.prs.l.lex_next_at : "UNKNOWN";
+                                err_at = G.prs.lex_next_at ? G.prs.lex_next_at : "UNKNOWN";
                                 bc_error_fmt("bad statement terminator at '%.*s'",
                                         (int)(strchrnul(err_at, '\n') - err_at),
                                         err_at
@@ -6837,10 +6832,10 @@ static BC_STATUS zbc_vm_process(const char *text)
 #if ENABLE_DC
                         // Most of dc parsing assumes all whitespace,
                         // including '\n', is eaten.
-                        while (G.prs.l.lex == XC_LEX_NLINE) {
+                        while (G.prs.lex == XC_LEX_NLINE) {
                                 s = zbc_lex_next();
                                 if (s) goto err;
-                                if (G.prs.l.lex == XC_LEX_EOF)
+                                if (G.prs.lex == XC_LEX_EOF)
                                         goto done;
                         }
                         s = zdc_parse_expr();
@@ -6914,12 +6909,12 @@ static BC_STATUS zbc_vm_process(const char *text)
 static BC_STATUS zbc_vm_execute_FILE(FILE *fp, const char *filename)
 {
         // So far bc/dc have no way to include a file from another file,
-        // therefore we know G.prs.filename == NULL on entry
+        // therefore we know G.prs.lex_filename == NULL on entry
         //const char *sv_file;
         BcStatus s;
 
-        G.prs.filename = filename;
-        G.prs.input_fp = fp;
+        G.prs.lex_filename = filename;
+        G.prs.lex_input_fp = fp;
         bc_lex_file();
 
         do {
@@ -6928,8 +6923,8 @@ static BC_STATUS zbc_vm_execute_FILE(FILE *fp, const char *filename)
                 // Example: start interactive bc and enter "return".
                 // It should say "'return' not in a function"
                 // but should not exit.
-        } while (G.prs.input_fp == stdin);
-        G.prs.filename = NULL;
+        } while (G.prs.lex_input_fp == stdin);
+        G.prs.lex_filename = NULL;
         RETURN_STATUS(s);
 }
 #define zbc_vm_execute_FILE(...) (zbc_vm_execute_FILE(__VA_ARGS__) COMMA_SUCCESS)