Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-09 12:23:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Simplify handling of '.' and '-' after unbracketed named references."

Browse Source 
This reverts commit bf3e44fe46.

See discussion following
<http://lists.gnu.org/archive/html/bison-patches/2011-01/msg00030.html>.
This commit is contained in:
Joel E. Denny
2011-01-29 10:58:03 -05:00
parent fe3cae17a1
commit 676997e53b
7 changed files with 159 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
ChangeLog
View File

@@ -4,47 +4,6 @@
2011-01-09 Paul Eggert <eggert@cs.ucla.edu> 2011-01-09 Paul Eggert <eggert@cs.ucla.edu>
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.
(<SC_RULE_ACTION>): 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. Fix minor problems encountered by a fresh bootstrap.
* data/glr.c, data/yacc.c: Do not use apostrophes in '#' comments, * data/glr.c, data/yacc.c: Do not use apostrophes in '#' comments,
as they confuse xgettext, which tries to parse them as C character as they confuse xgettext, which tries to parse them as C character

4
doc/bison.texinfo
View File

@@ -3125,9 +3125,7 @@ By convention, it should be all lower case.
Symbol names can contain letters, underscores, periods, dashes, and (not Symbol names can contain letters, underscores, periods, dashes, and (not
at the beginning) digits. Dashes in symbol names are a GNU at the beginning) digits. Dashes in symbol names are a GNU
extension, incompatible with POSIX Yacc. Periods and dashes make symbol extension, incompatible with POSIX Yacc. Terminal symbols
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 that contain periods or dashes make little sense: since they are not
valid symbols (in most programming languages) they are not exported as valid symbols (in most programming languages) they are not exported as
token names. token names.

182
src/scan-code.l
View File

@@ -47,9 +47,12 @@ YY_DECL;
#define YY_USER_ACTION location_compute (loc, &loc->end, yytext, yyleng); #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_dollar (symbol_list *rule, char *cp,
static void handle_action_at (symbol_list const *, char const *, unsigned, location dollar_loc);
location); 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 the_location;
static location *loc = &the_location; static location *loc = &the_location;
@@ -79,16 +82,12 @@ tag [^\0\n>]+
white space between the backslash and the newline. */ white space between the backslash and the newline. */
splice (\\[ \f\t\v]*\n)* splice (\\[ \f\t\v]*\n)*
/* A Bison identifier. Keep this synchronized with scan-gram.l "id". */ /* C style identifier. Must start with letter. Will be used for
letter [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] named symbol references. Shall be kept synchronized with
id {letter}({letter}|[0-9])* scan-gram.l "letter" and "id". */
letter [.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]
/* An identifier that can appear unbracketed in a reference. id -*(-|{letter}({letter}|[-0-9])*)
This happens to be the same as a C-language identifier. */ ref -?[0-9]+|{id}|"["{id}"]"|"$"
c_letter [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]
c_id {c_letter}({c_letter}|[0-9])*
ref -?[0-9]+|{c_id}|"["{id}"]"|"$"
%% %%
@@ -183,11 +182,19 @@ ref -?[0-9]+|{c_id}|"["{id}"]"|"$"
<SC_RULE_ACTION> <SC_RULE_ACTION>
{ {
"$"("<"{tag}">")?{ref} { "$"("<"{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; need_semicolon = true;
} }
"@"{ref} { "@"{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; need_semicolon = true;
} }
"$" { "$" {
@@ -331,9 +338,13 @@ typedef struct
by an explicit symbol reference. */ by an explicit symbol reference. */
#define VARIANT_HIDDEN (1 << 0) #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 /* Set when the variant refers to a symbol which is
not visible from current midrule. */ 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 variant *variant_table = 0;
static unsigned variant_table_size = 0; static unsigned variant_table_size = 0;
@@ -361,25 +372,31 @@ variant_table_free (void)
variant_table_size = variant_count = 0; variant_table_size = variant_count = 0;
} }
/* Return TRUE if ID matches the string from CP up to CP_END. static char *
The string does not contain null bytes. */ find_prefix_end (const char *prefix, char *begin, char *end)
static bool
identifier_matches (char const *id, char const *cp, char const *cp_end)
{ {
while (cp != cp_end) char *ptr = begin;
if (*id++ != *cp++)
return false; for (; *prefix && ptr != end; ++prefix, ++ptr)
return !*id; 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 * static variant *
variant_add (uniqstr id, location id_loc, unsigned symbol_index, 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 (); variant *r = variant_table_grow ();
r->symbol_index = symbol_index; r->symbol_index = symbol_index;
@@ -404,15 +421,11 @@ get_at_spec(unsigned symbol_index)
return at_buf; 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 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) bool is_warning, unsigned indent)
{ {
char dollar_or_at = *text;
unsigned i; unsigned i;
for (i = 0; i < variant_count; ++i) for (i = 0; i < variant_count; ++i)
@@ -432,6 +445,8 @@ show_sub_messages (char const *text, int midrule_rhs_index,
else else
{ {
static struct obstack msg_buf; static struct obstack msg_buf;
const char *tail = explicit_bracketing ? "" :
cp + strlen (var->id);
const char *id = var->hidden_by ? var->hidden_by->id : const char *id = var->hidden_by ? var->hidden_by->id :
var->id; var->id;
location id_loc = var->hidden_by ? var->hidden_by->loc : 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); obstack_fgrow1 (&msg_buf, "[%s]", id);
else else
obstack_sgrow (&msg_buf, id); obstack_sgrow (&msg_buf, id);
obstack_sgrow (&msg_buf, tail);
if (var->err & VARIANT_HIDDEN) 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); obstack_fgrow1 (&msg_buf, "[%s]", var->id);
else else
obstack_sgrow (&msg_buf, var->id); obstack_sgrow (&msg_buf, var->id);
obstack_sgrow (&msg_buf, tail);
} }
obstack_fgrow1 (&msg_buf, _(" at %s"), at_spec); 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. */ /* Sub-messages indent. */
#define SUB_INDENT (4) #define SUB_INDENT (4)
/* Return the index of a named or positional reference starting at CP /* Parse named or positional reference. In case of positional
for a rule RULE of length RULE_LENGTH. If MIDRULE_RHS_INDEX is references, can return negative values for $-n "deep" stack
nonzero, this is a generated midrule whose rhs index (1-origin) is accesses. */
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 static long int
parse_ref (char const *cp, symbol_list const *rule, int rule_length, parse_ref (char *cp, symbol_list *rule, int rule_length,
int midrule_rhs_index, char const *text, unsigned textlen, int midrule_rhs_index, char *text, location text_loc,
location text_loc) char dollar_or_at)
{ {
symbol_list const *l; symbol_list *l;
char const *cp_end; char *cp_end;
bool explicit_bracketing; bool explicit_bracketing;
unsigned i; unsigned i;
unsigned valid_variants = 0; unsigned valid_variants = 0;
@@ -511,9 +522,9 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length,
if ('$' == *cp) if ('$' == *cp)
return LHS_REF; 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) if (1 - INT_MAX + rule_length <= num && num <= rule_length)
return num; return num;
else else
@@ -524,9 +535,32 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length,
} }
} }
explicit_bracketing = (*cp == '['); if ('[' == *cp)
cp += explicit_bracketing; {
cp_end = text + textlen - explicit_bracketing; /* 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. */ /* Add all relevant variants. */
{ {
@@ -540,13 +574,13 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length,
continue; continue;
var = variant_add (l->content.sym->tag, l->sym_loc, 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) if (var && l->named_ref)
var->hidden_by = l->named_ref; var->hidden_by = l->named_ref;
if (l->named_ref) if (l->named_ref)
variant_add (l->named_ref->id, l->named_ref->loc, 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)) && (symbol_index == 0 || midrule_rhs_index < symbol_index))
var->err |= VARIANT_NOT_VISIBLE_FROM_MIDRULE; 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. */ /* Check using of hidden symbols. */
if (var->hidden_by) if (var->hidden_by)
var->err |= VARIANT_HIDDEN; var->err |= VARIANT_HIDDEN;
@@ -576,7 +614,8 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length,
{ {
case 0: case 0:
{ {
unsigned len = cp_end - cp; unsigned len = (explicit_bracketing || !ref_tail_fields) ?
cp_end - cp : ref_tail_fields - cp;
unsigned indent = 0; unsigned indent = 0;
complain_at_indent (text_loc, &indent, _("invalid reference: %s"), 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 = const char *format =
_("syntax error after `%c', expecting integer, letter," _("syntax error after `%c', expecting integer, letter,"
" `_', `[', or `$'"); " `_', `[', or `$'");
complain_at_indent (sym_loc, &indent, format, *text); complain_at_indent (sym_loc, &indent, format, dollar_or_at);
} }
else if (midrule_rhs_index) 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) 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; return INVALID_REF;
} }
case 1: 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"), warn_at_indent (text_loc, &indent, _("misleading reference: %s"),
quote (text)); quote (text));
show_sub_messages (text, midrule_rhs_index, true, show_sub_messages (cp, explicit_bracketing, midrule_rhs_index,
indent + SUB_INDENT); dollar_or_at, true, indent + SUB_INDENT);
} }
{ {
unsigned symbol_index = unsigned symbol_index =
@@ -633,8 +673,8 @@ parse_ref (char const *cp, symbol_list const *rule, int rule_length,
unsigned indent = 0; unsigned indent = 0;
complain_at_indent (text_loc, &indent, _("ambiguous reference: %s"), complain_at_indent (text_loc, &indent, _("ambiguous reference: %s"),
quote (text)); quote (text));
show_sub_messages (text, midrule_rhs_index, false, show_sub_messages (cp, explicit_bracketing, midrule_rhs_index,
indent + SUB_INDENT); dollar_or_at, false, indent + SUB_INDENT);
return INVALID_REF; return INVALID_REF;
} }
} }
@@ -652,14 +692,13 @@ int max_left_semantic_context = 0;
/*------------------------------------------------------------------. /*------------------------------------------------------------------.
| TEXT is pointing to a wannabee semantic value (i.e., a `$'). | | TEXT is pointing to a wannabee semantic value (i.e., a `$'). |
| | | |
| Possible inputs: $(<TYPENAME>|)($|integer|c_id|[id]) | | Possible inputs: $[<TYPENAME>]($|integer) |
| | | |
| Output to OBSTACK_FOR_STRING a reference to this semantic value. | | Output to OBSTACK_FOR_STRING a reference to this semantic value. |
`------------------------------------------------------------------*/ `------------------------------------------------------------------*/
static void static void
handle_action_dollar (symbol_list *rule, char *text, unsigned textlen, handle_action_dollar (symbol_list *rule, char *text, location dollar_loc)
location dollar_loc)
{ {
char const *type_name = NULL; char const *type_name = NULL;
char *cp = text + 1; 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, 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) if (gt_ptr)
*gt_ptr = '\0'; *gt_ptr = '\0';
@@ -767,11 +806,10 @@ handle_action_dollar (symbol_list *rule, char *text, unsigned textlen,
`------------------------------------------------------*/ `------------------------------------------------------*/
static void static void
handle_action_at (symbol_list const *rule, char const *text, unsigned textlen, handle_action_at (symbol_list *rule, char *text, location at_loc)
location at_loc)
{ {
char const *cp = text + 1; char *cp = text + 1;
symbol_list const *effective_rule; symbol_list *effective_rule;
int effective_rule_length; int effective_rule_length;
int n; 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); muscle_percent_define_ensure("locations", at_loc, true);
n = parse_ref (cp, effective_rule, effective_rule_length, 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) switch (n)
{ {
case INVALID_REF: case INVALID_REF:

5
src/scan-gram.l
View File

@@ -118,9 +118,8 @@ static void unexpected_newline (boundary, char const *);
/* Bracketed identifiers support. */ /* Bracketed identifiers support. */
%x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID %x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID
/* A Bison identifier. Keep this synchronized with scan-code.l "id". */ letter [.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]
letter [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] id -*(-|{letter}({letter}|[-0-9])*)
id {letter}({letter}|[0-9])*
directive %{id} directive %{id}
int [0-9]+ int [0-9]+

2
src/symlist.c
View File

@@ -217,7 +217,7 @@ symbol_list_n_type_name_get (symbol_list *l, location loc, int n)
} }
bool bool
symbol_list_null (symbol_list const *node) symbol_list_null (symbol_list *node)
{ {
return !node || return !node ||
(node->content_type == SYMLIST_SYMBOL && !(node->content.sym)); (node->content_type == SYMLIST_SYMBOL && !(node->content.sym));

2
src/symlist.h
View File

@@ -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); 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. */ /* 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. */ /** Set the \c \%destructor for \c node as \c code at \c loc. */
void symbol_list_destructor_set (symbol_list *node, char const *code, void symbol_list_destructor_set (symbol_list *node, char const *code,

70
tests/named-refs.at
View File

@@ -279,9 +279,11 @@ start: foo foo.bar { $foo.bar; }
foo: '1' foo: '1'
foo.bar: '2' foo.bar: '2'
]]) ]])
AT_BISON_CHECK([-o test.c test.y]) AT_BISON_CHECK([-o test.c test.y], 0, [],
AT_CHECK([if $CC $CFLAGS $CPPFLAGS test.c; then false; else true; fi], [[test.y:11.22-29: warning: misleading reference: `$foo.bar'
[0], [ignore], [ignore]) 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 AT_CLEANUP
####################################################################### #######################################################################
@@ -356,33 +358,43 @@ factor: '(' expr ')' { $$ = $2; }
AT_BISON_CHECK([-o test.c test.y], 1, [], AT_BISON_CHECK([-o test.c test.y], 1, [],
[[test.y:24.36-41: invalid reference: `$cond1' [[test.y:24.36-41: invalid reference: `$cond1'
test.y:23.11-24.62: symbol not found in production: 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.11-26.60: symbol not found in production: stmt
test.y:25.35-38: possibly meant: $then, hiding $stmt at $4 test.y:25.35-38: possibly meant: $then.field, hiding $stmt.field at $4
test.y:28.43-47: invalid reference: `$stmt' test.y:28.43-52: invalid reference: `$stmt.list'
test.y:27.11-28.59: symbol not found in production: 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:30.43-46: ambiguous reference: `$xyz'
test.y:29.35-37: refers to: $xyz at $4 test.y:29.35-37: refers to: $xyz at $4
test.y:29.50-52: refers to: $xyz at $6 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: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.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:36.43-54: invalid reference: `$[stmt.list]'
test.y:35.11-36.71: symbol not found in production: 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.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: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: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: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.12-42.57: symbol not found in production: stmt
test.y:41.36-41: possibly meant: $[stmt.x], hiding $stmt at $4 test.y:41.36-41: possibly meant: $[stmt.x].x, hiding $stmt.x at $4
test.y:44.13-15: invalid reference: `$if' 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: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.12-46.65: symbol not found in production: then
test.y:45.41-46: possibly meant: $[then-a].f at $4
]]) ]])
AT_CLEANUP AT_CLEANUP
@@ -515,9 +527,9 @@ sym_a : 'a';
sym_b : 'b'; sym_b : 'b';
]]) ]])
AT_BISON_CHECK([-o test.c test.y], 1, [], 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:12.1-13.21: symbol not found in production: sym
test.y:16.8-15: invalid reference: `$<aa>sym' test.y:16.8-21: invalid reference: `$<aa>sym.field'
test.y:15.1-16.25: symbol not found in production: sym test.y:15.1-16.25: symbol not found in production: sym
test.y:19.8-19: invalid reference: `$[sym.field]' test.y:19.8-19: invalid reference: `$[sym.field]'
test.y:18.1-19.23: symbol not found in production: 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:30.1-33.21: symbol not found in production before $3: sym
test.y:33.8-17: invalid reference: `$<aa>[sym]' test.y:33.8-17: invalid reference: `$<aa>[sym]'
test.y:30.1-33.21: symbol not found in production: 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:36.1-37.21: symbol not found in production: sym
test.y:40.8-15: invalid reference: `$<aa>sym' test.y:40.8-21: invalid reference: `$<aa>sym-field'
test.y:39.1-40.25: symbol not found in production: sym test.y:39.1-40.25: symbol not found in production: sym
test.y:43.8-19: invalid reference: `$[sym-field]' test.y:43.8-19: invalid reference: `$[sym-field]'
test.y:42.1-43.23: symbol not found in production: sym-field test.y:42.1-43.23: symbol not found in production: sym-field
@@ -560,15 +572,21 @@ start:
.field { $.field; } .field { $.field; }
| -field { @-field; } | -field { @-field; }
| 'a' { @.field; } | 'a' { @.field; }
| 'b' { $-field; } | 'a' { $-field; }
; ;
.field: 'c' ; .field: ;
-field: 'd' ; -field: ;
]]) ]])
AT_BISON_CHECK([[test.y]], [], [], AT_BISON_CHECK([[test.y]], [[1]], [],
[[test.y:4.12: warning: stray `$' [[test.y:4.12-18: invalid reference: `$.field'
test.y:5.12: warning: stray `@' test.y:4.13: syntax error after `$', expecting integer, letter, `_', `@<:@', or `$'
test.y:6.12: warning: stray `@' test.y:4.3-8: possibly meant: $[.field] at $1
test.y:7.12: warning: stray `$' 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 AT_CLEANUP