From bf3e44fe46440ebe473798f9d887908b120bb646 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sun, 9 Jan 2011 23:26:12 -0800 Subject: [PATCH] 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. --- 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, 147 insertions(+), 159 deletions(-) diff --git a/ChangeLog b/ChangeLog index 9255aab5..1ed26ad9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,46 @@ 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 cc1e0645..29d63649 100644 --- a/doc/bison.texinfo +++ b/doc/bison.texinfo @@ -3125,7 +3125,9 @@ 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. Terminal symbols +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 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 3dd10443..9a08af7a 100644 --- a/src/scan-code.l +++ b/src/scan-code.l @@ -47,12 +47,9 @@ YY_DECL; #define YY_USER_ACTION location_compute (loc, &loc->end, yytext, yyleng); -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 void handle_action_dollar (symbol_list *, char *, unsigned, location); +static void handle_action_at (symbol_list const *, char const *, unsigned, + location); static location the_location; static location *loc = &the_location; @@ -82,12 +79,16 @@ tag [^\0\n>]+ white space between the backslash and the newline. */ splice (\\[ \f\t\v]*\n)* -/* 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}"]"|"$" +/* 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}"]"|"$" %% @@ -182,19 +183,11 @@ ref -?[0-9]+|{id}|"["{id}"]"|"$" { "$"("<"{tag}">")?{ref} { - ref_tail_fields = 0; - handle_action_dollar (self->rule, yytext, *loc); - if (ref_tail_fields) { - obstack_sgrow (&obstack_for_string, ref_tail_fields); - } + handle_action_dollar (self->rule, yytext, yyleng, *loc); need_semicolon = true; } "@"{ref} { - ref_tail_fields = 0; - handle_action_at (self->rule, yytext, *loc); - if (ref_tail_fields) { - obstack_sgrow (&obstack_for_string, ref_tail_fields); - } + handle_action_at (self->rule, yytext, yyleng, *loc); need_semicolon = true; } "$" { @@ -338,13 +331,9 @@ 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 << 2) +#define VARIANT_NOT_VISIBLE_FROM_MIDRULE (1 << 1) static variant *variant_table = 0; static unsigned variant_table_size = 0; @@ -372,31 +361,25 @@ variant_table_free (void) variant_table_size = variant_count = 0; } -static char * -find_prefix_end (const char *prefix, char *begin, char *end) +/* 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) { - char *ptr = begin; - - for (; *prefix && ptr != end; ++prefix, ++ptr) - if (*prefix != *ptr) - return 0; - - if (*prefix) - return 0; - - return ptr; + while (cp != cp_end) + if (*id++ != *cp++) + return false; + return !*id; } +/* 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 *cp, char *cp_end, bool explicit_bracketing) + char const *cp, char const *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)))) + if (identifier_matches (id, cp, cp_end)) { variant *r = variant_table_grow (); r->symbol_index = symbol_index; @@ -421,11 +404,15 @@ 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 (const char* cp, bool explicit_bracketing, - int midrule_rhs_index, char dollar_or_at, +show_sub_messages (char const *text, int midrule_rhs_index, bool is_warning, unsigned indent) { + char dollar_or_at = *text; unsigned i; for (i = 0; i < variant_count; ++i) @@ -445,8 +432,6 @@ show_sub_messages (const char* cp, bool explicit_bracketing, 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 : @@ -460,7 +445,6 @@ show_sub_messages (const char* cp, bool explicit_bracketing, obstack_fgrow1 (&msg_buf, "[%s]", id); else obstack_sgrow (&msg_buf, id); - obstack_sgrow (&msg_buf, tail); if (var->err & VARIANT_HIDDEN) { @@ -469,7 +453,6 @@ show_sub_messages (const char* cp, bool explicit_bracketing, 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); @@ -504,16 +487,22 @@ show_sub_messages (const char* cp, bool explicit_bracketing, /* Sub-messages indent. */ #define SUB_INDENT (4) -/* Parse named or positional reference. In case of positional - references, can return negative values for $-n "deep" stack - accesses. */ +/* 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. */ static long int -parse_ref (char *cp, symbol_list *rule, int rule_length, - int midrule_rhs_index, char *text, location text_loc, - char dollar_or_at) +parse_ref (char const *cp, symbol_list const *rule, int rule_length, + int midrule_rhs_index, char const *text, unsigned textlen, + location text_loc) { - symbol_list *l; - char *cp_end; + symbol_list const *l; + char const *cp_end; bool explicit_bracketing; unsigned i; unsigned valid_variants = 0; @@ -522,9 +511,9 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, if ('$' == *cp) return LHS_REF; - if (c_isdigit (*cp) || (*cp == '-' && c_isdigit (* (cp + 1)))) + if (c_isdigit (*cp) || *cp == '-') { - long int num = strtol (cp, &cp, 10); + long int num = strtol (cp, NULL, 10); if (1 - INT_MAX + rule_length <= num && num <= rule_length) return num; else @@ -535,32 +524,9 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, } } - 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; - } + explicit_bracketing = (*cp == '['); + cp += explicit_bracketing; + cp_end = text + textlen - explicit_bracketing; /* Add all relevant variants. */ { @@ -574,13 +540,13 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, continue; var = variant_add (l->content.sym->tag, l->sym_loc, - symbol_index, cp, cp_end, explicit_bracketing); + symbol_index, cp, cp_end); 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, explicit_bracketing); + symbol_index, cp, cp_end); } } @@ -595,10 +561,6 @@ parse_ref (char *cp, symbol_list *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; @@ -614,8 +576,7 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, { case 0: { - unsigned len = (explicit_bracketing || !ref_tail_fields) ? - cp_end - cp : ref_tail_fields - cp; + unsigned len = cp_end - cp; unsigned indent = 0; complain_at_indent (text_loc, &indent, _("invalid reference: %s"), @@ -629,7 +590,7 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, const char *format = _("syntax error after `%c', expecting integer, letter," " `_', `[', or `$'"); - complain_at_indent (sym_loc, &indent, format, dollar_or_at); + complain_at_indent (sym_loc, &indent, format, *text); } else if (midrule_rhs_index) { @@ -647,8 +608,7 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, } if (variant_count > 0) - show_sub_messages (cp, explicit_bracketing, midrule_rhs_index, - dollar_or_at, false, indent); + show_sub_messages (text, midrule_rhs_index, false, indent); return INVALID_REF; } case 1: @@ -658,8 +618,8 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, { warn_at_indent (text_loc, &indent, _("misleading reference: %s"), quote (text)); - show_sub_messages (cp, explicit_bracketing, midrule_rhs_index, - dollar_or_at, true, indent + SUB_INDENT); + show_sub_messages (text, midrule_rhs_index, true, + indent + SUB_INDENT); } { unsigned symbol_index = @@ -673,8 +633,8 @@ parse_ref (char *cp, symbol_list *rule, int rule_length, unsigned indent = 0; complain_at_indent (text_loc, &indent, _("ambiguous reference: %s"), quote (text)); - show_sub_messages (cp, explicit_bracketing, midrule_rhs_index, - dollar_or_at, false, indent + SUB_INDENT); + show_sub_messages (text, midrule_rhs_index, false, + indent + SUB_INDENT); return INVALID_REF; } } @@ -692,13 +652,14 @@ int max_left_semantic_context = 0; /*------------------------------------------------------------------. | TEXT is pointing to a wannabee semantic value (i.e., a `$'). | | | -| Possible inputs: $[]($|integer) | +| Possible inputs: $(|)($|integer|c_id|[id]) | | | | Output to OBSTACK_FOR_STRING a reference to this semantic value. | `------------------------------------------------------------------*/ static void -handle_action_dollar (symbol_list *rule, char *text, location dollar_loc) +handle_action_dollar (symbol_list *rule, char *text, unsigned textlen, + location dollar_loc) { char const *type_name = NULL; char *cp = text + 1; @@ -735,7 +696,7 @@ handle_action_dollar (symbol_list *rule, char *text, location dollar_loc) } n = parse_ref (cp, effective_rule, effective_rule_length, - rule->midrule_parent_rhs_index, text, dollar_loc, '$'); + rule->midrule_parent_rhs_index, text, textlen, dollar_loc); if (gt_ptr) *gt_ptr = '\0'; @@ -806,10 +767,11 @@ handle_action_dollar (symbol_list *rule, char *text, location dollar_loc) `------------------------------------------------------*/ static void -handle_action_at (symbol_list *rule, char *text, location at_loc) +handle_action_at (symbol_list const *rule, char const *text, unsigned textlen, + location at_loc) { - char *cp = text + 1; - symbol_list *effective_rule; + char const *cp = text + 1; + symbol_list const *effective_rule; int effective_rule_length; int n; @@ -827,7 +789,7 @@ handle_action_at (symbol_list *rule, char *text, location at_loc) muscle_percent_define_ensure("locations", at_loc, true); n = parse_ref (cp, effective_rule, effective_rule_length, - rule->midrule_parent_rhs_index, text, at_loc, '@'); + rule->midrule_parent_rhs_index, text, textlen, at_loc); switch (n) { case INVALID_REF: diff --git a/src/scan-gram.l b/src/scan-gram.l index 41291812..a40aadea 100644 --- a/src/scan-gram.l +++ b/src/scan-gram.l @@ -118,8 +118,9 @@ static void unexpected_newline (boundary, char const *); /* Bracketed identifiers support. */ %x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID -letter [.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] -id -*(-|{letter}({letter}|[-0-9])*) +/* A Bison identifier. Keep this synchronized with scan-code.l "id". */ +letter [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] +id {letter}({letter}|[0-9])* directive %{id} int [0-9]+ diff --git a/src/symlist.c b/src/symlist.c index e717c3e1..5483f071 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 *node) +symbol_list_null (symbol_list const *node) { return !node || (node->content_type == SYMLIST_SYMBOL && !(node->content.sym)); diff --git a/src/symlist.h b/src/symlist.h index 297d414a..e5a0714a 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 *node); +bool symbol_list_null (symbol_list const *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 74549c6e..17cbef3e 100644 --- a/tests/named-refs.at +++ b/tests/named-refs.at @@ -279,11 +279,9 @@ start: foo foo.bar { $foo.bar; } foo: '1' foo.bar: '2' ]]) -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_BISON_CHECK([-o test.c test.y]) +AT_CHECK([if $CC $CFLAGS $CPPFLAGS test.c; then false; else true; fi], + [0], [ignore], [ignore]) AT_CLEANUP ####################################################################### @@ -358,43 +356,33 @@ 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-53: invalid reference: `$stmt.field' +test.y:26.43-47: invalid reference: `$stmt' test.y:25.11-26.60: symbol not found in production: 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:25.35-38: possibly meant: $then, hiding $stmt at $4 +test.y:28.43-47: invalid reference: `$stmt' 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-52: invalid reference: `$stmt.list' +test.y:32.43-47: invalid reference: `$stmt' test.y:31.11-32.63: symbol not found in production: 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:34.43-47: invalid reference: `$stmt' 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-49: invalid reference: `$then.1' +test.y:38.43-47: invalid reference: `$then' test.y:37.11-38.60: symbol not found in production: then -test.y:37.40-45: possibly meant: $[then.1] at $4 -test.y:40.43-55: invalid reference: `$then.1.field' +test.y:40.43-47: invalid reference: `$then' test.y:39.11-40.66: symbol not found in production: then -test.y:39.40-45: possibly meant: $[then.1].field at $4 -test.y:42.44-50: invalid reference: `$stmt.x' +test.y:42.44-48: invalid reference: `$stmt' test.y:41.12-42.57: symbol not found in production: stmt -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:41.36-41: possibly meant: $[stmt.x], hiding $stmt at $4 +test.y:44.13-15: invalid reference: `$if' test.y:43.12-44.59: symbol not found in production: if -test.y:43.1-9: possibly meant: $[if-stmt-a] at $$ -test.y:46.46-54: invalid reference: `$then-a.f' +test.y:46.46-50: invalid reference: `$then' 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 @@ -527,9 +515,9 @@ sym_a : 'a'; sym_b : 'b'; ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:13.8-17: invalid reference: `$sym.field' +[[test.y:13.8-11: invalid reference: `$sym' test.y:12.1-13.21: symbol not found in production: sym -test.y:16.8-21: invalid reference: `$sym.field' +test.y:16.8-15: invalid reference: `$sym' 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 @@ -543,9 +531,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-17: invalid reference: `$sym-field' +test.y:37.8-11: invalid reference: `$sym' test.y:36.1-37.21: symbol not found in production: sym -test.y:40.8-21: invalid reference: `$sym-field' +test.y:40.8-15: invalid reference: `$sym' 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 @@ -572,21 +560,15 @@ start: .field { $.field; } | -field { @-field; } | 'a' { @.field; } -| 'a' { $-field; } +| 'b' { $-field; } ; -.field: ; --field: ; +.field: 'c' ; +-field: 'd' ; ]]) -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_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_CLEANUP -- 2.45.2