From adcd9a6f349f3f2715a586b45fb27350b37cf1e5 Mon Sep 17 00:00:00 2001 From: Denys Vlasenko Date: Tue, 29 Jun 2021 01:23:37 +0200 Subject: [PATCH] awk: use TS_foo for combined token classes. No code changes Confusion with "simple" classes was the cause of a bug fixed by previous commit Signed-off-by: Denys Vlasenko --- editors/awk.c | 128 +++++++++++++++++++++++++------------------------- 1 file changed, 64 insertions(+), 64 deletions(-) diff --git a/editors/awk.c b/editors/awk.c index 418bda160..764a3dd49 100644 --- a/editors/awk.c +++ b/editors/awk.c @@ -281,39 +281,39 @@ if ((n) & TC_NUMBER ) debug_printf_parse(" NUMBER" ); \ } while (0) #endif -/* combined token classes */ -#define TC_UOPPRE (TC_UOPPRE1 | TC_UOPPRE2) +/* combined token classes ("token [class] sets") */ +#define TS_UOPPRE (TC_UOPPRE1 | TC_UOPPRE2) -#define TC_BINOP (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN) -//#define TC_UNARYOP (TC_UOPPRE | TC_UOPPOST) -#define TC_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION \ - | TC_BUILTIN | TC_LENGTH | TC_GETLINE \ - | TC_SEQSTART | TC_STRING | TC_NUMBER) -#define TC_LVALUE (TC_VARIABLE | TC_ARRAY) +#define TS_BINOP (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN) +//#define TS_UNARYOP (TS_UOPPRE | TC_UOPPOST) +#define TS_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION \ + | TC_BUILTIN | TC_LENGTH | TC_GETLINE \ + | TC_SEQSTART | TC_STRING | TC_NUMBER) -#define TC_STATEMNT (TC_STATX | TC_WHILE) -#define TC_OPTERM (TC_SEMICOL | TC_NEWLINE) +#define TS_LVALUE (TC_VARIABLE | TC_ARRAY) +#define TS_STATEMNT (TC_STATX | TC_WHILE) +#define TS_OPTERM (TC_SEMICOL | TC_NEWLINE) /* word tokens, cannot mean something else if not expected */ -#define TC_WORD (TC_IN | TC_STATEMNT | TC_ELSE \ - | TC_BUILTIN | TC_LENGTH | TC_GETLINE \ - | TC_FUNCDECL | TC_BEGIN | TC_END) +#define TS_WORD (TC_IN | TS_STATEMNT | TC_ELSE \ + | TC_BUILTIN | TC_LENGTH | TC_GETLINE \ + | TC_FUNCDECL | TC_BEGIN | TC_END) /* discard newlines after these */ -#define TC_NOTERM (TC_COMMA | TC_GRPSTART | TC_GRPTERM \ - | TC_BINOP | TC_OPTERM) +#define TS_NOTERM (TC_COMMA | TC_GRPSTART | TC_GRPTERM \ + | TS_BINOP | TS_OPTERM) /* what can expression begin with */ -#define TC_OPSEQ (TC_OPERAND | TC_UOPPRE | TC_REGEXP) +#define TS_OPSEQ (TS_OPERAND | TS_UOPPRE | TC_REGEXP) /* what can group begin with */ -#define TC_GRPSEQ (TC_OPSEQ | TC_OPTERM | TC_STATEMNT | TC_GRPSTART) +#define TS_GRPSEQ (TS_OPSEQ | TS_OPTERM | TS_STATEMNT | TC_GRPSTART) -/* if previous token class is CONCAT1 and next is CONCAT2, concatenation */ +/* if previous token class is CONCAT_L and next is CONCAT_R, concatenation */ /* operator is inserted between them */ -#define TC_CONCAT1 (TC_VARIABLE | TC_ARRTERM | TC_SEQTERM \ +#define TS_CONCAT_L (TC_VARIABLE | TC_ARRTERM | TC_SEQTERM \ | TC_STRING | TC_NUMBER | TC_UOPPOST \ | TC_LENGTH) -#define TC_CONCAT2 (TC_OPERAND | TC_UOPPRE) +#define TS_CONCAT_R (TS_OPERAND | TS_UOPPRE) #define OF_RES1 0x010000 #define OF_RES2 0x020000 @@ -614,7 +614,7 @@ struct globals2 { #define rsplitter (G.rsplitter ) #define INIT_G() do { \ SET_PTR_TO_GLOBALS((char*)xzalloc(sizeof(G1)+sizeof(G)) + sizeof(G1)); \ - t_tclass = TC_OPTERM; \ + t_tclass = TS_OPTERM; \ G.evaluate__seed = 1; \ } while (0) @@ -1107,7 +1107,7 @@ static uint32_t next_token(uint32_t expected) const uint32_t *ti; uint32_t tc, last_token_class; - last_token_class = t_tclass; /* t_tclass is initialized to TC_OPTERM */ + last_token_class = t_tclass; /* t_tclass is initialized to TS_OPTERM */ debug_printf_parse("%s() expected(%x):", __func__, expected); debug_parse_print_tc(expected); @@ -1198,9 +1198,9 @@ static uint32_t next_token(uint32_t expected) * token matches, * and it's not a longer word, */ - if ((tc & (expected | TC_WORD | TC_NEWLINE)) + if ((tc & (expected | TS_WORD | TC_NEWLINE)) && strncmp(p, tl, l) == 0 - && !((tc & TC_WORD) && isalnum_(p[l])) + && !((tc & TS_WORD) && isalnum_(p[l])) ) { /* then this is what we are looking for */ t_info = *ti; @@ -1244,14 +1244,14 @@ static uint32_t next_token(uint32_t expected) g_pos = p; /* skipping newlines in some cases */ - if ((last_token_class & TC_NOTERM) && (tc & TC_NEWLINE)) + if ((last_token_class & TS_NOTERM) && (tc & TC_NEWLINE)) goto readnext; /* insert concatenation operator when needed */ debug_printf_parse("%s: concat_inserted if all nonzero: %x %x %x %x\n", __func__, - (last_token_class & TC_CONCAT1), (tc & TC_CONCAT2), (expected & TC_BINOP), + (last_token_class & TS_CONCAT_L), (tc & TS_CONCAT_R), (expected & TS_BINOP), !(last_token_class == TC_LENGTH && tc == TC_SEQSTART)); - if ((last_token_class & TC_CONCAT1) && (tc & TC_CONCAT2) && (expected & TC_BINOP) + if ((last_token_class & TS_CONCAT_L) && (tc & TS_CONCAT_R) && (expected & TS_BINOP) && !(last_token_class == TC_LENGTH && tc == TC_SEQSTART) /* but not for "length(..." */ ) { concat_inserted = TRUE; @@ -1317,7 +1317,7 @@ static node *parse_expr(uint32_t term_tc) node sn; node *cn = &sn; node *vn, *glptr; - uint32_t tc, xtc; + uint32_t tc, expected_tc; var *v; debug_printf_parse("%s() term_tc(%x):", __func__, term_tc); @@ -1326,20 +1326,20 @@ static node *parse_expr(uint32_t term_tc) sn.info = PRIMASK; sn.r.n = sn.a.n = glptr = NULL; - xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP | term_tc; + expected_tc = TS_OPERAND | TS_UOPPRE | TC_REGEXP | term_tc; - while (!((tc = next_token(xtc)) & term_tc)) { + while (!((tc = next_token(expected_tc)) & term_tc)) { if (glptr && (t_info == TI_LESS)) { /* input redirection (<) attached to glptr node */ debug_printf_parse("%s: input redir\n", __func__); cn = glptr->l.n = new_node(OC_CONCAT | SS | P(37)); cn->a.n = glptr; - xtc = TC_OPERAND | TC_UOPPRE; + expected_tc = TS_OPERAND | TS_UOPPRE; glptr = NULL; - } else if (tc & (TC_BINOP | TC_UOPPOST)) { - debug_printf_parse("%s: TC_BINOP | TC_UOPPOST tc:%x\n", __func__, tc); + } else if (tc & (TS_BINOP | TC_UOPPOST)) { + debug_printf_parse("%s: TS_BINOP | TC_UOPPOST tc:%x\n", __func__, tc); /* for binary and postfix-unary operators, jump back over * previous operators with higher priority */ vn = cn; @@ -1353,19 +1353,19 @@ static node *parse_expr(uint32_t term_tc) t_info += P(6); cn = vn->a.n->r.n = new_node(t_info); cn->a.n = vn->a.n; - if (tc & TC_BINOP) { + if (tc & TS_BINOP) { cn->l.n = vn; - xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP; + expected_tc = TS_OPERAND | TS_UOPPRE | TC_REGEXP; if ((t_info & OPCLSMASK) == OC_PGETLINE) { /* it's a pipe */ next_token(TC_GETLINE); /* give maximum priority to this pipe */ cn->info &= ~PRIMASK; - xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | term_tc; + expected_tc = TS_OPERAND | TS_UOPPRE | TS_BINOP | term_tc; } } else { cn->r.n = vn; - xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | term_tc; + expected_tc = TS_OPERAND | TS_UOPPRE | TS_BINOP | term_tc; } vn->a.n = cn; @@ -1377,14 +1377,14 @@ static node *parse_expr(uint32_t term_tc) cn = vn->r.n = new_node(t_info); cn->a.n = vn; - xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP; + expected_tc = TS_OPERAND | TS_UOPPRE | TC_REGEXP; if (t_info == TI_PREINC || t_info == TI_PREDEC) - xtc = TC_LVALUE | TC_UOPPRE1; - if (tc & (TC_OPERAND | TC_REGEXP)) { - debug_printf_parse("%s: TC_OPERAND | TC_REGEXP\n", __func__); - xtc = TC_UOPPRE | TC_UOPPOST | TC_BINOP | TC_OPERAND | term_tc; + expected_tc = TS_LVALUE | TC_UOPPRE1; + if (tc & (TS_OPERAND | TC_REGEXP)) { + debug_printf_parse("%s: TS_OPERAND | TC_REGEXP\n", __func__); + expected_tc = TS_UOPPRE | TC_UOPPOST | TS_BINOP | TS_OPERAND | term_tc; /* one should be very careful with switch on tclass - - * only simple tclasses should be used! */ + * only simple tclasses should be used (TC_xyz, not TS_xyz) */ switch (tc) { case TC_VARIABLE: case TC_ARRAY: @@ -1412,7 +1412,7 @@ static node *parse_expr(uint32_t term_tc) setvar_i(v, t_double); else { setvar_s(v, t_string); - xtc &= ~TC_UOPPOST; /* "str"++ is not allowed */ + expected_tc &= ~TC_UOPPOST; /* "str"++ is not allowed */ } break; @@ -1439,7 +1439,7 @@ static node *parse_expr(uint32_t term_tc) case TC_GETLINE: debug_printf_parse("%s: TC_GETLINE\n", __func__); glptr = cn; - xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | term_tc; + expected_tc = TS_OPERAND | TS_UOPPRE | TS_BINOP | term_tc; break; case TC_BUILTIN: @@ -1450,7 +1450,7 @@ static node *parse_expr(uint32_t term_tc) case TC_LENGTH: debug_printf_parse("%s: TC_LENGTH\n", __func__); next_token(TC_SEQSTART /* length(...) */ - | TC_OPTERM /* length; (or newline)*/ + | TS_OPTERM /* length; (or newline)*/ | TC_GRPTERM /* length } */ | TC_BINOPX /* length NUM */ | TC_COMMA /* print length, 1 */ @@ -1464,7 +1464,7 @@ static node *parse_expr(uint32_t term_tc) } } } - } + } /* while() */ debug_printf_parse("%s() returns %p\n", __func__, sn.r.n); return sn.r.n; @@ -1497,7 +1497,7 @@ static void chain_expr(uint32_t info) n = chain_node(info); - n->l.n = parse_expr(TC_OPTERM | TC_GRPTERM); + n->l.n = parse_expr(TS_OPTERM | TC_GRPTERM); if ((info & OF_REQUIRED) && !n->l.n) syntax_error(EMSG_TOO_FEW_ARGS); @@ -1535,12 +1535,12 @@ static void chain_group(void) node *n, *n2, *n3; do { - c = next_token(TC_GRPSEQ); + c = next_token(TS_GRPSEQ); } while (c & TC_NEWLINE); if (c & TC_GRPSTART) { debug_printf_parse("%s: TC_GRPSTART\n", __func__); - while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) { + while (next_token(TS_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) { debug_printf_parse("%s: !TC_GRPTERM\n", __func__); if (t_tclass & TC_NEWLINE) continue; @@ -1548,13 +1548,13 @@ static void chain_group(void) chain_group(); } debug_printf_parse("%s: TC_GRPTERM\n", __func__); - } else if (c & (TC_OPSEQ | TC_OPTERM)) { - debug_printf_parse("%s: TC_OPSEQ | TC_OPTERM\n", __func__); + } else if (c & (TS_OPSEQ | TS_OPTERM)) { + debug_printf_parse("%s: TS_OPSEQ | TS_OPTERM\n", __func__); rollback_token(); chain_expr(OC_EXEC | Vx); } else { - /* TC_STATEMNT */ - debug_printf_parse("%s: TC_STATEMNT(?)\n", __func__); + /* TS_STATEMNT */ + debug_printf_parse("%s: TS_STATEMNT(?)\n", __func__); switch (t_info & OPCLSMASK) { case ST_IF: debug_printf_parse("%s: ST_IF\n", __func__); @@ -1563,7 +1563,7 @@ static void chain_group(void) chain_group(); n2 = chain_node(OC_EXEC); n->r.n = seq->last; - if (next_token(TC_GRPSEQ | TC_GRPTERM | TC_ELSE) == TC_ELSE) { + if (next_token(TS_GRPSEQ | TC_GRPTERM | TC_ELSE) == TC_ELSE) { chain_group(); n2->a.n = seq->last; } else { @@ -1616,10 +1616,10 @@ static void chain_group(void) case OC_PRINTF: debug_printf_parse("%s: OC_PRINT[F]\n", __func__); n = chain_node(t_info); - n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM); + n->l.n = parse_expr(TS_OPTERM | TC_OUTRDR | TC_GRPTERM); if (t_tclass & TC_OUTRDR) { n->info |= t_info; - n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM); + n->r.n = parse_expr(TS_OPTERM | TC_GRPTERM); } if (t_tclass & TC_GRPTERM) rollback_token(); @@ -1658,11 +1658,11 @@ static void parse_program(char *p) g_pos = p; t_lineno = 1; - while ((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART | - TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) { + while ((tclass = next_token(TC_EOF | TS_OPSEQ | TC_GRPSTART | + TS_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) { - if (tclass & TC_OPTERM) { - debug_printf_parse("%s: TC_OPTERM\n", __func__); + if (tclass & TS_OPTERM) { + debug_printf_parse("%s: TS_OPTERM\n", __func__); continue; } @@ -1706,11 +1706,11 @@ static void parse_program(char *p) seq = &f->body; chain_group(); clear_array(ahash); - } else if (tclass & TC_OPSEQ) { - debug_printf_parse("%s: TC_OPSEQ\n", __func__); + } else if (tclass & TS_OPSEQ) { + debug_printf_parse("%s: TS_OPSEQ\n", __func__); rollback_token(); cn = chain_node(OC_TEST); - cn->l.n = parse_expr(TC_OPTERM | TC_EOF | TC_GRPSTART); + cn->l.n = parse_expr(TS_OPTERM | TC_EOF | TC_GRPSTART); if (t_tclass & TC_GRPSTART) { debug_printf_parse("%s: TC_GRPSTART\n", __func__); rollback_token();