From 676997e53bf9e8d364302bd1f90d812e50b1477a Mon Sep 17 00:00:00 2001 From: "Joel E. Denny" Date: Sat, 29 Jan 2011 10:58:03 -0500 Subject: [PATCH] Revert "Simplify handling of '.' and '-' after unbracketed named references." This reverts commit bf3e44fe46440ebe473798f9d887908b120bb646. See discussion following . --- ChangeLog | 41 ---------- doc/bison.texinfo | 4 +- src/scan-code.l | 182 ++++++++++++++++++++++++++------------------ src/scan-gram.l | 5 +- src/symlist.c | 2 +- src/symlist.h | 2 +- tests/named-refs.at | 70 ++++++++++------- 7 files changed, 159 insertions(+), 147 deletions(-) diff --git a/ChangeLog b/ChangeLog index ba91749b..96f75a17 100644 --- a/ChangeLog +++ b/ChangeLog @@ -4,47 +4,6 @@ 2011-01-09 Paul Eggert - Simplify handling of '.' and '-' after unbracketed named references. - * doc/bison.texinfo (Mid-Rule Actions): Mention that periods and - dashes make symbol names less convenient for named references. - * src/scan-code.l: - (handle_action_dollar): New arg textlen. All callers changed. - (handle_action_at): Likewise. Also, args are pointers to const. - (ref_tail_fields): Remove; no longer used. - (letter): Now includes '-' and '.', since this is for Bison - identifiers. - (id): Now the simpler traditional defn, since letters now include - '-' and '.'. - (c_letter, c_id): New defns. - (ref): Use c_id for unbracketed IDs. - (): Simplify, now that the distinction between - Bison and unbracketed IDs are now in the regular expressions. - (VARIANT_BAD_BRACKETING): Remove. - (VARIANT_NOT_VISIBLE_FROM_MIDRULE): Renumber. - (find_prefix_end): Remove, replacing with .... - (identifier_matches): New function. - (variant_add): Use it. Omit EXPLICIT_BRACKETING arg; no longer - needed. CP arg is pointer to constant. All callers changed. - (show_sub_messages): Remove args CP, EXPLICIT_BRACKETING, DOLLAR_OR_AT. - New arg TEXT. All callers changed. Do not worry about showing - trailing context. - (parse_ref): Args CP, RULE, TEXT are now pointers to const. New - arg TEXTLEN. Remove arg DOLLAR_OR_AT. All callers changed. - Simplify code now that the regular expressions capture the - restrictions. - * src/scan-gram.l (letter, id): Adjust to match scan-code.l. - * src/symlist.c (symbol_list_null): Arg is now pointer to const. - * src/symlist.h: Likewise. - * tests/named-refs.at (Misleading references): These are now caught - by the C compiler, not by Bison; that's good enough. Adjust test - to reflect this. - (Many kinds of errors, Unresolved references): Adjust expected - diagnostics to match new behavior. The same errors are caught, - though the diagnostics are not quite as fancy. - ($ or @ followed by . or -): Likewise. Also, Make the grammar - unambiguous, so that diagnostics are not complicated by ambiguity - warnings. - Fix minor problems encountered by a fresh bootstrap. * data/glr.c, data/yacc.c: Do not use apostrophes in '#' comments, as they confuse xgettext, which tries to parse them as C character diff --git a/doc/bison.texinfo b/doc/bison.texinfo index 29d63649..cc1e0645 100644 --- a/doc/bison.texinfo +++ b/doc/bison.texinfo @@ -3125,9 +3125,7 @@ By convention, it should be all lower case. Symbol names can contain letters, underscores, periods, dashes, and (not at the beginning) digits. Dashes in symbol names are a GNU -extension, incompatible with POSIX Yacc. Periods and dashes make symbol -names less convenient to use with named references, which require brackets -around such names (@pxref{Named References}). Terminal symbols +extension, incompatible with POSIX Yacc. Terminal symbols that contain periods or dashes make little sense: since they are not valid symbols (in most programming languages) they are not exported as token names. diff --git a/src/scan-code.l b/src/scan-code.l index 9a08af7a..3dd10443 100644 --- a/src/scan-code.l +++ b/src/scan-code.l @@ -47,9 +47,12 @@ YY_DECL; #define YY_USER_ACTION location_compute (loc, &loc->end, yytext, yyleng); -static void handle_action_dollar (symbol_list *, char *, unsigned, location); -static void handle_action_at (symbol_list const *, char const *, unsigned, - location); +static void handle_action_dollar (symbol_list *rule, char *cp, + location dollar_loc); +static void handle_action_at (symbol_list *rule, char *cp, location at_loc); + +/* A string to be pushed to obstack after dollar/at has been handled. */ +static char *ref_tail_fields; static location the_location; static location *loc = &the_location; @@ -79,16 +82,12 @@ tag [^\0\n>]+ white space between the backslash and the newline. */ splice (\\[ \f\t\v]*\n)* -/* A Bison identifier. Keep this synchronized with scan-gram.l "id". */ -letter [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] -id {letter}({letter}|[0-9])* - -/* An identifier that can appear unbracketed in a reference. - This happens to be the same as a C-language identifier. */ -c_letter [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] -c_id {c_letter}({c_letter}|[0-9])* - -ref -?[0-9]+|{c_id}|"["{id}"]"|"$" +/* C style identifier. Must start with letter. Will be used for + named symbol references. Shall be kept synchronized with + scan-gram.l "letter" and "id". */ +letter [.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] +id -*(-|{letter}({letter}|[-0-9])*) +ref -?[0-9]+|{id}|"["{id}"]"|"$" %% @@ -183,11 +182,19 @@ ref -?[0-9]+|{c_id}|"["{id}"]"|"$" { "$"("<"{tag}">")?{ref} { - handle_action_dollar (self->rule, yytext, yyleng, *loc); + ref_tail_fields = 0; + handle_action_dollar (self->rule, yytext, *loc); + if (ref_tail_fields) { + obstack_sgrow (&obstack_for_string, ref_tail_fields); + } need_semicolon = true; } "@"{ref} { - handle_action_at (self->rule, yytext, yyleng, *loc); + ref_tail_fields = 0; + handle_action_at (self->rule, yytext, *loc); + if (ref_tail_fields) { + obstack_sgrow (&obstack_for_string, ref_tail_fields); + } need_semicolon = true; } "$" { @@ -331,9 +338,13 @@ typedef struct by an explicit symbol reference. */ #define VARIANT_HIDDEN (1 << 0) +/* Set when the variant refers to a symbol containing + dots or dashes. Will require explicit bracketing. */ +#define VARIANT_BAD_BRACKETING (1 << 1) + /* Set when the variant refers to a symbol which is not visible from current midrule. */ -#define VARIANT_NOT_VISIBLE_FROM_MIDRULE (1 << 1) +#define VARIANT_NOT_VISIBLE_FROM_MIDRULE (1 << 2) static variant *variant_table = 0; static unsigned variant_table_size = 0; @@ -361,25 +372,31 @@ variant_table_free (void) variant_table_size = variant_count = 0; } -/* Return TRUE if ID matches the string from CP up to CP_END. - The string does not contain null bytes. */ -static bool -identifier_matches (char const *id, char const *cp, char const *cp_end) +static char * +find_prefix_end (const char *prefix, char *begin, char *end) { - while (cp != cp_end) - if (*id++ != *cp++) - return false; - return !*id; + char *ptr = begin; + + for (; *prefix && ptr != end; ++prefix, ++ptr) + if (*prefix != *ptr) + return 0; + + if (*prefix) + return 0; + + return ptr; } -/* If scanning ID, return a new variant with that ID, at location - ID_LOC with index SYMBOL_INDEX. Otherwise, return NULL. The - currently scanned identifier starts at CP and ends at CP_END. */ static variant * variant_add (uniqstr id, location id_loc, unsigned symbol_index, - char const *cp, char const *cp_end) + char *cp, char *cp_end, bool explicit_bracketing) { - if (identifier_matches (id, cp, cp_end)) + char *prefix_end; + + prefix_end = find_prefix_end (id, cp, cp_end); + if (prefix_end && + (prefix_end == cp_end || + (!explicit_bracketing && is_dot_or_dash (*prefix_end)))) { variant *r = variant_table_grow (); r->symbol_index = symbol_index; @@ -404,15 +421,11 @@ get_at_spec(unsigned symbol_index) return at_buf; } -/* Show a subsidiary message for a problem with a grammar rule. TEXT - points to the problematic reference. MIDRULE_RHS_INDEX is the rhs - index (1-origin) in the rule. If IS_WARNING, it is a warning, - otherwise a complaint. Indent the message INDENT spaces. */ static void -show_sub_messages (char const *text, int midrule_rhs_index, +show_sub_messages (const char* cp, bool explicit_bracketing, + int midrule_rhs_index, char dollar_or_at, bool is_warning, unsigned indent) { - char dollar_or_at = *text; unsigned i; for (i = 0; i < variant_count; ++i) @@ -432,6 +445,8 @@ show_sub_messages (char const *text, int midrule_rhs_index, else { static struct obstack msg_buf; + const char *tail = explicit_bracketing ? "" : + cp + strlen (var->id); const char *id = var->hidden_by ? var->hidden_by->id : var->id; location id_loc = var->hidden_by ? var->hidden_by->loc : @@ -445,6 +460,7 @@ show_sub_messages (char const *text, int midrule_rhs_index, obstack_fgrow1 (&msg_buf, "[%s]", id); else obstack_sgrow (&msg_buf, id); + obstack_sgrow (&msg_buf, tail); if (var->err & VARIANT_HIDDEN) { @@ -453,6 +469,7 @@ show_sub_messages (char const *text, int midrule_rhs_index, obstack_fgrow1 (&msg_buf, "[%s]", var->id); else obstack_sgrow (&msg_buf, var->id); + obstack_sgrow (&msg_buf, tail); } obstack_fgrow1 (&msg_buf, _(" at %s"), at_spec); @@ -487,22 +504,16 @@ show_sub_messages (char const *text, int midrule_rhs_index, /* Sub-messages indent. */ #define SUB_INDENT (4) -/* Return the index of a named or positional reference starting at CP - for a rule RULE of length RULE_LENGTH. If MIDRULE_RHS_INDEX is - nonzero, this is a generated midrule whose rhs index (1-origin) is - MIDRULE_RHS_INDEX in the parent rule. The entire semantic value - containing the reference is TEXT, of length TEXTLEN. Its location - is TEXT_LOC. - - In case of positional references, this can return negative values - for $-n "deep" stack accesses. */ +/* Parse named or positional reference. In case of positional + references, can return negative values for $-n "deep" stack + accesses. */ static long int -parse_ref (char const *cp, symbol_list const *rule, int rule_length, - int midrule_rhs_index, char const *text, unsigned textlen, - location text_loc) +parse_ref (char *cp, symbol_list *rule, int rule_length, + int midrule_rhs_index, char *text, location text_loc, + char dollar_or_at) { - symbol_list const *l; - char const *cp_end; + symbol_list *l; + char *cp_end; bool explicit_bracketing; unsigned i; unsigned valid_variants = 0; @@ -511,9 +522,9 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, if ('$' == *cp) return LHS_REF; - if (c_isdigit (*cp) || *cp == '-') + if (c_isdigit (*cp) || (*cp == '-' && c_isdigit (* (cp + 1)))) { - long int num = strtol (cp, NULL, 10); + long int num = strtol (cp, &cp, 10); if (1 - INT_MAX + rule_length <= num && num <= rule_length) return num; else @@ -524,9 +535,32 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, } } - explicit_bracketing = (*cp == '['); - cp += explicit_bracketing; - cp_end = text + textlen - explicit_bracketing; + if ('[' == *cp) + { + /* Ignore the brackets. */ + char *p; + for (p = ++cp; *p != ']'; ++p) + continue; + cp_end = p; + + explicit_bracketing = true; + } + else + { + /* Take all characters of the name. */ + char* p; + for (p = cp; *p; ++p) + if (is_dot_or_dash (*p)) + { + ref_tail_fields = p; + break; + } + for (p = cp; *p; ++p) + continue; + cp_end = p; + + explicit_bracketing = false; + } /* Add all relevant variants. */ { @@ -540,13 +574,13 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, continue; var = variant_add (l->content.sym->tag, l->sym_loc, - symbol_index, cp, cp_end); + symbol_index, cp, cp_end, explicit_bracketing); if (var && l->named_ref) var->hidden_by = l->named_ref; if (l->named_ref) variant_add (l->named_ref->id, l->named_ref->loc, - symbol_index, cp, cp_end); + symbol_index, cp, cp_end, explicit_bracketing); } } @@ -561,6 +595,10 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, && (symbol_index == 0 || midrule_rhs_index < symbol_index)) var->err |= VARIANT_NOT_VISIBLE_FROM_MIDRULE; + /* Check correct bracketing. */ + if (!explicit_bracketing && contains_dot_or_dash (var->id)) + var->err |= VARIANT_BAD_BRACKETING; + /* Check using of hidden symbols. */ if (var->hidden_by) var->err |= VARIANT_HIDDEN; @@ -576,7 +614,8 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, { case 0: { - unsigned len = cp_end - cp; + unsigned len = (explicit_bracketing || !ref_tail_fields) ? + cp_end - cp : ref_tail_fields - cp; unsigned indent = 0; complain_at_indent (text_loc, &indent, _("invalid reference: %s"), @@ -590,7 +629,7 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, const char *format = _("syntax error after `%c', expecting integer, letter," " `_', `[', or `$'"); - complain_at_indent (sym_loc, &indent, format, *text); + complain_at_indent (sym_loc, &indent, format, dollar_or_at); } else if (midrule_rhs_index) { @@ -608,7 +647,8 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, } if (variant_count > 0) - show_sub_messages (text, midrule_rhs_index, false, indent); + show_sub_messages (cp, explicit_bracketing, midrule_rhs_index, + dollar_or_at, false, indent); return INVALID_REF; } case 1: @@ -618,8 +658,8 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, { warn_at_indent (text_loc, &indent, _("misleading reference: %s"), quote (text)); - show_sub_messages (text, midrule_rhs_index, true, - indent + SUB_INDENT); + show_sub_messages (cp, explicit_bracketing, midrule_rhs_index, + dollar_or_at, true, indent + SUB_INDENT); } { unsigned symbol_index = @@ -633,8 +673,8 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length, unsigned indent = 0; complain_at_indent (text_loc, &indent, _("ambiguous reference: %s"), quote (text)); - show_sub_messages (text, midrule_rhs_index, false, - indent + SUB_INDENT); + show_sub_messages (cp, explicit_bracketing, midrule_rhs_index, + dollar_or_at, false, indent + SUB_INDENT); return INVALID_REF; } } @@ -652,14 +692,13 @@ int max_left_semantic_context = 0; /*------------------------------------------------------------------. | TEXT is pointing to a wannabee semantic value (i.e., a `$'). | | | -| Possible inputs: $(|)($|integer|c_id|[id]) | +| Possible inputs: $[]($|integer) | | | | Output to OBSTACK_FOR_STRING a reference to this semantic value. | `------------------------------------------------------------------*/ static void -handle_action_dollar (symbol_list *rule, char *text, unsigned textlen, - location dollar_loc) +handle_action_dollar (symbol_list *rule, char *text, location dollar_loc) { char const *type_name = NULL; char *cp = text + 1; @@ -696,7 +735,7 @@ handle_action_dollar (symbol_list *rule, char *text, unsigned textlen, } n = parse_ref (cp, effective_rule, effective_rule_length, - rule->midrule_parent_rhs_index, text, textlen, dollar_loc); + rule->midrule_parent_rhs_index, text, dollar_loc, '$'); if (gt_ptr) *gt_ptr = '\0'; @@ -767,11 +806,10 @@ handle_action_dollar (symbol_list *rule, char *text, unsigned textlen, `------------------------------------------------------*/ static void -handle_action_at (symbol_list const *rule, char const *text, unsigned textlen, - location at_loc) +handle_action_at (symbol_list *rule, char *text, location at_loc) { - char const *cp = text + 1; - symbol_list const *effective_rule; + char *cp = text + 1; + symbol_list *effective_rule; int effective_rule_length; int n; @@ -789,7 +827,7 @@ handle_action_at (symbol_list const *rule, char const *text, unsigned textlen, muscle_percent_define_ensure("locations", at_loc, true); n = parse_ref (cp, effective_rule, effective_rule_length, - rule->midrule_parent_rhs_index, text, textlen, at_loc); + rule->midrule_parent_rhs_index, text, at_loc, '@'); switch (n) { case INVALID_REF: diff --git a/src/scan-gram.l b/src/scan-gram.l index a40aadea..41291812 100644 --- a/src/scan-gram.l +++ b/src/scan-gram.l @@ -118,9 +118,8 @@ static void unexpected_newline (boundary, char const *); /* Bracketed identifiers support. */ %x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID -/* A Bison identifier. Keep this synchronized with scan-code.l "id". */ -letter [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] -id {letter}({letter}|[0-9])* +letter [.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] +id -*(-|{letter}({letter}|[-0-9])*) directive %{id} int [0-9]+ diff --git a/src/symlist.c b/src/symlist.c index 5483f071..e717c3e1 100644 --- a/src/symlist.c +++ b/src/symlist.c @@ -217,7 +217,7 @@ symbol_list_n_type_name_get (symbol_list *l, location loc, int n) } bool -symbol_list_null (symbol_list const *node) +symbol_list_null (symbol_list *node) { return !node || (node->content_type == SYMLIST_SYMBOL && !(node->content.sym)); diff --git a/src/symlist.h b/src/symlist.h index e5a0714a..297d414a 100644 --- a/src/symlist.h +++ b/src/symlist.h @@ -116,7 +116,7 @@ symbol_list *symbol_list_n_get (symbol_list *l, int n); uniqstr symbol_list_n_type_name_get (symbol_list *l, location loc, int n); /* Check whether the node is a border element of a rule. */ -bool symbol_list_null (symbol_list const *node); +bool symbol_list_null (symbol_list *node); /** Set the \c \%destructor for \c node as \c code at \c loc. */ void symbol_list_destructor_set (symbol_list *node, char const *code, diff --git a/tests/named-refs.at b/tests/named-refs.at index 17cbef3e..74549c6e 100644 --- a/tests/named-refs.at +++ b/tests/named-refs.at @@ -279,9 +279,11 @@ start: foo foo.bar { $foo.bar; } foo: '1' foo.bar: '2' ]]) -AT_BISON_CHECK([-o test.c test.y]) -AT_CHECK([if $CC $CFLAGS $CPPFLAGS test.c; then false; else true; fi], - [0], [ignore], [ignore]) +AT_BISON_CHECK([-o test.c test.y], 0, [], +[[test.y:11.22-29: warning: misleading reference: `$foo.bar' +test.y:11.8-10: warning: refers to: $foo at $1 +test.y:11.12-18: warning: possibly meant: $[foo.bar] at $2 +]]) AT_CLEANUP ####################################################################### @@ -356,33 +358,43 @@ factor: '(' expr ')' { $$ = $2; } AT_BISON_CHECK([-o test.c test.y], 1, [], [[test.y:24.36-41: invalid reference: `$cond1' test.y:23.11-24.62: symbol not found in production: cond1 -test.y:26.43-47: invalid reference: `$stmt' +test.y:26.43-53: invalid reference: `$stmt.field' test.y:25.11-26.60: symbol not found in production: stmt -test.y:25.35-38: possibly meant: $then, hiding $stmt at $4 -test.y:28.43-47: invalid reference: `$stmt' +test.y:25.35-38: possibly meant: $then.field, hiding $stmt.field at $4 +test.y:28.43-52: invalid reference: `$stmt.list' test.y:27.11-28.59: symbol not found in production: stmt +test.y:27.30-38: possibly meant: $[stmt.list] at $4 test.y:30.43-46: ambiguous reference: `$xyz' test.y:29.35-37: refers to: $xyz at $4 test.y:29.50-52: refers to: $xyz at $6 -test.y:32.43-47: invalid reference: `$stmt' +test.y:32.43-52: invalid reference: `$stmt.list' test.y:31.11-32.63: symbol not found in production: stmt -test.y:34.43-47: invalid reference: `$stmt' +test.y:31.40-43: possibly meant: $then, hiding $[stmt.list] at $4 +test.y:31.61-64: possibly meant: $else, hiding $[stmt.list] at $6 +test.y:34.43-58: invalid reference: `$stmt.list.field' test.y:33.11-34.69: symbol not found in production: stmt +test.y:33.40-43: possibly meant: $then.field, hiding $[stmt.list].field at $4 +test.y:33.61-64: possibly meant: $else.field, hiding $[stmt.list].field at $6 test.y:36.43-54: invalid reference: `$[stmt.list]' test.y:35.11-36.71: symbol not found in production: stmt.list test.y:35.40-43: possibly meant: $then, hiding $[stmt.list] at $4 test.y:35.61-64: possibly meant: $else, hiding $[stmt.list] at $6 -test.y:38.43-47: invalid reference: `$then' +test.y:38.43-49: invalid reference: `$then.1' test.y:37.11-38.60: symbol not found in production: then -test.y:40.43-47: invalid reference: `$then' +test.y:37.40-45: possibly meant: $[then.1] at $4 +test.y:40.43-55: invalid reference: `$then.1.field' test.y:39.11-40.66: symbol not found in production: then -test.y:42.44-48: invalid reference: `$stmt' +test.y:39.40-45: possibly meant: $[then.1].field at $4 +test.y:42.44-50: invalid reference: `$stmt.x' test.y:41.12-42.57: symbol not found in production: stmt -test.y:41.36-41: possibly meant: $[stmt.x], hiding $stmt at $4 -test.y:44.13-15: invalid reference: `$if' +test.y:41.36-41: possibly meant: $[stmt.x].x, hiding $stmt.x at $4 +test.y:41.36-41: possibly meant: $[stmt.x] at $4 +test.y:44.13-22: invalid reference: `$if-stmt-a' test.y:43.12-44.59: symbol not found in production: if -test.y:46.46-50: invalid reference: `$then' +test.y:43.1-9: possibly meant: $[if-stmt-a] at $$ +test.y:46.46-54: invalid reference: `$then-a.f' test.y:45.12-46.65: symbol not found in production: then +test.y:45.41-46: possibly meant: $[then-a].f at $4 ]]) AT_CLEANUP @@ -515,9 +527,9 @@ sym_a : 'a'; sym_b : 'b'; ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:13.8-11: invalid reference: `$sym' +[[test.y:13.8-17: invalid reference: `$sym.field' test.y:12.1-13.21: symbol not found in production: sym -test.y:16.8-15: invalid reference: `$sym' +test.y:16.8-21: invalid reference: `$sym.field' test.y:15.1-16.25: symbol not found in production: sym test.y:19.8-19: invalid reference: `$[sym.field]' test.y:18.1-19.23: symbol not found in production: sym.field @@ -531,9 +543,9 @@ test.y:31.8-13: invalid reference: `$[sym]' test.y:30.1-33.21: symbol not found in production before $3: sym test.y:33.8-17: invalid reference: `$[sym]' test.y:30.1-33.21: symbol not found in production: sym -test.y:37.8-11: invalid reference: `$sym' +test.y:37.8-17: invalid reference: `$sym-field' test.y:36.1-37.21: symbol not found in production: sym -test.y:40.8-15: invalid reference: `$sym' +test.y:40.8-21: invalid reference: `$sym-field' test.y:39.1-40.25: symbol not found in production: sym test.y:43.8-19: invalid reference: `$[sym-field]' test.y:42.1-43.23: symbol not found in production: sym-field @@ -560,15 +572,21 @@ start: .field { $.field; } | -field { @-field; } | 'a' { @.field; } -| 'b' { $-field; } +| 'a' { $-field; } ; -.field: 'c' ; --field: 'd' ; +.field: ; +-field: ; ]]) -AT_BISON_CHECK([[test.y]], [], [], -[[test.y:4.12: warning: stray `$' -test.y:5.12: warning: stray `@' -test.y:6.12: warning: stray `@' -test.y:7.12: warning: stray `$' +AT_BISON_CHECK([[test.y]], [[1]], [], +[[test.y:4.12-18: invalid reference: `$.field' +test.y:4.13: syntax error after `$', expecting integer, letter, `_', `@<:@', or `$' +test.y:4.3-8: possibly meant: $[.field] at $1 +test.y:5.12-18: invalid reference: `@-field' +test.y:5.13: syntax error after `@', expecting integer, letter, `_', `@<:@', or `$' +test.y:5.3-8: possibly meant: @[-field] at $1 +test.y:6.12-18: invalid reference: `@.field' +test.y:6.13: syntax error after `@', expecting integer, letter, `_', `@<:@', or `$' +test.y:7.12-18: invalid reference: `$-field' +test.y:7.13: syntax error after `$', expecting integer, letter, `_', `@<:@', or `$' ]]) AT_CLEANUP -- 2.45.2