From 872b52bc24b5590ac8bdec7db882cdbefc0ec3ff Mon Sep 17 00:00:00 2001 From: Alex Rozenman Date: Sat, 4 Jul 2009 17:52:38 +0300 Subject: [PATCH] Style changes and factoring. * src/named-ref.h: Add comments. * src/parse-gram.y: Readability and style changes. * src/reader.c: Factoring: assign_named_ref function. * src/scan-code.l: Factoring and style changes. Rename parse_named_ref to parse_ref. Use "c-ctype.h" from gnulib. Use "unsigned" type for variant index. Improve readablity. * src/scan-gram.l: Change error messages and add comments. * src/symlist.h: symbol_list_null: New function decl. * src/symlist.c: symbol_list_null: Implement here. * tests/named-refs.at: Adjust for new error messages. --- ChangeLog | 14 +++ src/named-ref.h | 15 ++- src/parse-gram.y | 10 +-- src/reader.c | 44 ++++----- src/scan-code.l | 248 ++++++++++++++++++++++++++------------------------- src/scan-gram.l | 30 +++--- src/symlist.c | 6 ++ src/symlist.h | 3 + tests/named-refs.at | 45 +++++----- 9 files changed, 221 insertions(+), 194 deletions(-) diff --git a/ChangeLog b/ChangeLog index df07483..19f68b2 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,17 @@ +2009-07-04 Alex Rozenman + + Style changes and factoring. + * src/named-ref.h: Add comments. + * src/parse-gram.y: Readability and style changes. + * src/reader.c: Factoring: assign_named_ref function. + * src/scan-code.l: Factoring and style changes. Rename + parse_named_ref to parse_ref. Use "c-ctype.h" from gnulib. + Use "unsigned" type for variant index. Improve readablity. + * src/scan-gram.l: Change error messages and add comments. + * src/symlist.h: symbol_list_null: New function decl. + * src/symlist.c: symbol_list_null: Implement here. + * tests/named-refs.at: Adjust for new error messages. + 2009-06-29 Eric Blake scan-code: avoid compiler warnings diff --git a/src/named-ref.h b/src/named-ref.h index 9100296..20e92e3 100644 --- a/src/named-ref.h +++ b/src/named-ref.h @@ -20,19 +20,24 @@ #ifndef NAMED_REF_H_ # define NAMED_REF_H_ -#include "uniqstr.h" #include "location.h" +#include "uniqstr.h" -typedef struct named_ref named_ref; - -struct named_ref +/* Named reference object. Keeps information about + a symbolic name of a symbol in a rule. */ +typedef struct named_ref { + /* Symbolic named given by user. */ uniqstr id; + + /* Location of the symbolic name. Not including brackets. */ location loc; -}; +} named_ref; +/* Allocate a named reference object. */ named_ref *named_ref_new (uniqstr id, location loc); +/* Free a named reference object. */ void named_ref_free (named_ref *r); #endif /* !NAMED_REF_H_ */ diff --git a/src/parse-gram.y b/src/parse-gram.y index a10c32e..6f9ac83 100644 --- a/src/parse-gram.y +++ b/src/parse-gram.y @@ -27,10 +27,10 @@ #include "getargs.h" #include "gram.h" #include "muscle-tab.h" +#include "named-ref.h" #include "quotearg.h" #include "reader.h" #include "symlist.h" -#include "named-ref.h" #include "scan-gram.h" #include "scan-code.h" @@ -171,7 +171,7 @@ static int current_prec = 0; %token TAG "" %token TAG_ANY "<*>" %token TAG_NONE "<>" -%token BRACKETED_ID "[id]" +%token BRACKETED_ID "[identifier]" %type CHAR %printer { fputs (char_name ($$), stderr); } CHAR @@ -543,11 +543,9 @@ rhs: ; named_ref.opt: - /* Nothing. */ - { $$ = 0; } + /* Nothing. */ { $$ = 0; } | - BRACKETED_ID - { $$ = named_ref_new($1, @1); } + BRACKETED_ID { $$ = named_ref_new($1, @1); } ; diff --git a/src/reader.c b/src/reader.c index 0811317..275d7c4 100644 --- a/src/reader.c +++ b/src/reader.c @@ -190,6 +190,23 @@ grammar_symbol_append (symbol *sym, location loc) return p; } +static void +assign_named_ref (symbol_list *p, named_ref *named_ref) +{ + symbol *sym = p->content.sym; + + if (named_ref->id == sym->tag) + { + warn_at (named_ref->loc, + _("duplicated symbol name for %s ignored"), + quote (sym->tag)); + named_ref_free (named_ref); + } + else + p->named_ref = named_ref; +} + + /* The rule currently being defined, and the previous rule. CURRENT_RULE points to the first LHS of the current rule, while PREVIOUS_RULE_END points to the *end* of the previous rule (NULL). */ @@ -213,17 +230,7 @@ grammar_current_rule_begin (symbol *lhs, location loc, p = grammar_symbol_append (lhs, loc); if (lhs_named_ref) - { - if (lhs_named_ref->id == lhs->tag) - { - warn_at (lhs_named_ref->loc, - _("duplicated symbol name for %s ignored"), - quote (lhs->tag)); - named_ref_free (lhs_named_ref); - } - else - p->named_ref = lhs_named_ref; - } + assign_named_ref(p, lhs_named_ref); current_rule = grammar_end; @@ -348,7 +355,7 @@ grammar_midrule_action (void) symbol *dummy = dummy_symbol_get (dummy_location); symbol_list *midrule = symbol_list_sym_new (dummy, dummy_location); - /* Remember named_ref of previous action */ + /* Remember named_ref of previous action. */ named_ref *named_ref = current_rule->action_props.named_ref; /* Make a new rule, whose body is empty, before the current one, so @@ -432,19 +439,8 @@ grammar_current_rule_symbol_append (symbol *sym, location loc, if (current_rule->action_props.code) grammar_midrule_action (); p = grammar_symbol_append (sym, loc); - if (named_ref) - { - if (named_ref->id == sym->tag) - { - warn_at (named_ref->loc, - _("duplicated symbol name for %s ignored"), - quote (sym->tag)); - named_ref_free (named_ref); - } - else - p->named_ref = named_ref; - } + assign_named_ref(p, named_ref); } /* Attach an ACTION to the current rule. */ diff --git a/src/scan-code.l b/src/scan-code.l index 28a9fe4..78cf839 100644 --- a/src/scan-code.l +++ b/src/scan-code.l @@ -32,12 +32,14 @@ #include #include #include -#include -#include #include #include #include +#include +#include +#include + /* The current calling start condition: SC_RULE_ACTION or SC_SYMBOL_ACTION. */ # define YY_DECL static char *code_lex (code_props *self, int sc_context) @@ -49,7 +51,7 @@ 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 */ +/* A string to be pushed to obstack after dollar/at has been handled. */ static char *ref_tail_fields; static location the_location; @@ -81,7 +83,8 @@ tag [^\0\n>]+ splice (\\[ \f\t\v]*\n)* /* C style identifier. Must start with letter. Will be used for - named symbol references. */ + 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}"]"|"$" @@ -181,7 +184,7 @@ ref -?[0-9]+|{id}|"["{id}"]"|"$" "$"("<"{tag}">")?{ref} { ref_tail_fields = 0; handle_action_dollar (self->rule, yytext, *loc); - if (ref_tail_fields != NULL) { + if (ref_tail_fields) { obstack_sgrow (&obstack_for_string, ref_tail_fields); } need_semicolon = true; @@ -189,7 +192,7 @@ ref -?[0-9]+|{id}|"["{id}"]"|"$" "@"{ref} { ref_tail_fields = 0; handle_action_at (self->rule, yytext, *loc); - if (ref_tail_fields != NULL) { + if (ref_tail_fields) { obstack_sgrow (&obstack_for_string, ref_tail_fields); } need_semicolon = true; @@ -285,60 +288,57 @@ ref -?[0-9]+|{id}|"["{id}"]"|"$" %% - -static inline bool -symbol_list_null(symbol_list *l) -{ - if (l && !(l->content_type == SYMLIST_SYMBOL && l->content.sym == NULL)) - return false; - else - return true; -} - static inline bool -is_dot_or_dash(char ch) +is_dot_or_dash (char ch) { return ch == '.' || ch == '-'; } static inline bool -is_digit(char ch) -{ - return '0' <= ch && ch <= '9'; -} - -static inline bool -contains_dot_or_dash(const char* str) +contains_dot_or_dash (const char* p) { - return strpbrk(str, ".-") != NULL; + for (; *p; ++p) + if (is_dot_or_dash (*p)) + return true; + return false; } -#define VARIANT_HIDDEN (1 << 0) -#define VARIANT_BAD_BRACKETING (1 << 1) -#define VARIANT_NOT_VISIBLE_FROM_MIDRULE (1 << 2) - +/* Defines a variant of a symbolic name resolution. */ typedef struct { /* Index in symbol list. */ - long int ind; + unsigned index; /* Matched symbol id and loc. */ uniqstr id; location loc; - /* Hidding named reference. */ + /* Hiding named reference. */ named_ref* hidden_by; - /* Error flags. */ + /* Error flags. May contain zero (no errors) or + a combination of VARIANT_* values. */ unsigned err; } variant; +/* Set when the variant refers to a symbol hidden + 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) + static variant *variant_table = 0; static unsigned variant_table_size = 0; static unsigned variant_count = 0; static variant * -variant_table_grow() +variant_table_grow () { ++variant_count; if (variant_count > variant_table_size) @@ -352,16 +352,13 @@ variant_table_grow() } static char * -find_prefix_end(const char *prefix, char *begin, char *end) +find_prefix_end (const char *prefix, char *begin, char *end) { char *ptr = begin; - while (*prefix && ptr != end) - { - if (*prefix != *ptr) - return 0; - ++prefix, ++ptr; - } + for (; *prefix && ptr != end; ++prefix, ++ptr) + if (*prefix != *ptr) + return 0; if (*prefix) return 0; @@ -370,18 +367,18 @@ find_prefix_end(const char *prefix, char *begin, char *end) } static variant * -variant_add(uniqstr id, location loc, long int ind, - char *cp, char *cp_end, bool exact_mode) +variant_add (uniqstr id, location loc, unsigned index, + char *cp, char *cp_end, bool exact_mode) { char *prefix_end; - prefix_end = find_prefix_end(id, cp, cp_end); + prefix_end = find_prefix_end (id, cp, cp_end); if (prefix_end && (prefix_end == cp_end || - (!exact_mode && is_dot_or_dash(*prefix_end)))) + (!exact_mode && is_dot_or_dash (*prefix_end)))) { - variant *r = variant_table_grow(); - r->ind = ind; + variant *r = variant_table_grow (); + r->index = index; r->id = id; r->loc = loc; r->hidden_by = NULL; @@ -392,27 +389,44 @@ variant_add(uniqstr id, location loc, long int ind, return NULL; } +static const char * +get_at_spec(unsigned index) +{ + static char at_buf[20]; + if (index == 0) + strcpy (at_buf, "$$"); + else + snprintf (at_buf, sizeof at_buf, "$%u", index); + return at_buf; +} + +/* Returned from "parse_ref" when the reference + is inappropriate. */ #define INVALID_REF (INT_MIN) + +/* Returned from "parse_ref" when the reference + points to LHS ($$) of the current rule. */ #define LHS_REF (INT_MIN + 1) +/* Parse named or positional reference. In case of positional + references, can return negative values for $-n "deep" stack + accesses. */ static long int -parse_named_ref(char *cp, symbol_list *rule, int rule_length, - int midrule_rhs_index, char *text, location loc, - char dollar_or_at) +parse_ref (char *cp, symbol_list *rule, int rule_length, + int midrule_rhs_index, char *text, location loc, + char dollar_or_at) { symbol_list *l; char *cp_end; bool exact_mode; bool has_error; bool has_valid; - long int ind, i; - variant* variant; - char* p; + unsigned i; if ('$' == *cp) return LHS_REF; - if (is_digit (*cp) || (*cp == '-' && is_digit (* (cp + 1)))) + if (c_isdigit (*cp) || (*cp == '-' && c_isdigit (* (cp + 1)))) { long int num = strtol (cp, &cp, 10); if (1 - INT_MAX + rule_length <= num && num <= rule_length) @@ -426,71 +440,78 @@ parse_named_ref(char *cp, symbol_list *rule, int rule_length, if ('[' == *cp) { - exact_mode = true; - /* Ignore the brackets. */ - ++cp; - for (p = cp; *p != ']'; ++p); + char *p; + for (p = ++cp; *p != ']'; ++p) + continue; cp_end = p; + + exact_mode = true; } else { - exact_mode = false; - /* Take all characters of the name. */ + char* p; for (p = cp; *p; ++p) - if (is_dot_or_dash(*p)) + if (is_dot_or_dash (*p)) { ref_tail_fields = p; break; } - for (p = cp; *p; ++p); + for (p = cp; *p; ++p) + continue; cp_end = p; + + exact_mode = false; } /* Add all relevant variants. */ - variant_count = 0; - for (ind = 0, l = rule; !symbol_list_null(l); ++ind, l = l->next) - { - if (l->content_type != SYMLIST_SYMBOL) - continue; + { + unsigned index; + variant_count = 0; + for (index = 0, l = rule; !symbol_list_null (l); ++index, l = l->next) + { + variant *variant; + if (l->content_type != SYMLIST_SYMBOL) + continue; - variant = variant_add(l->content.sym->tag, l->sym_loc, ind, - cp, cp_end, exact_mode); + variant = variant_add (l->content.sym->tag, l->sym_loc, index, + cp, cp_end, exact_mode); - if (variant && l->named_ref) - variant->hidden_by = l->named_ref; + if (variant && l->named_ref) + variant->hidden_by = l->named_ref; - if (l->named_ref) - variant_add(l->named_ref->id, l->named_ref->loc, ind, - cp, cp_end, exact_mode); - } + if (l->named_ref) + variant_add (l->named_ref->id, l->named_ref->loc, index, + cp, cp_end, exact_mode); + } + } /* Check errors. */ has_error = false; has_valid = false; for (i = 0; i < variant_count; ++i) { - variant = &variant_table[i]; - ind = variant->ind; + variant *variant = &variant_table[i]; + unsigned index = variant->index; /* Check visibility from mid-rule actions. */ - if (midrule_rhs_index != 0 && - (ind == 0 || ind > midrule_rhs_index)) + if (midrule_rhs_index != 0 + && (index == 0 || midrule_rhs_index < index)) { variant->err |= VARIANT_NOT_VISIBLE_FROM_MIDRULE; has_error = true; } /* Check correct bracketing. */ - if (!exact_mode && contains_dot_or_dash(variant->id)) + if (!exact_mode && contains_dot_or_dash (variant->id)) { variant->err |= VARIANT_BAD_BRACKETING; has_error = true; } /* Check using of hidden symbols. */ - if (variant->hidden_by != NULL) + if (variant->hidden_by) { variant->err |= VARIANT_HIDDEN; has_error = true; @@ -503,65 +524,47 @@ parse_named_ref(char *cp, symbol_list *rule, int rule_length, if (variant_count == 1 && has_valid) { /* The only "good" case is here. */ - ind = variant_table[0].ind; - if (ind == midrule_rhs_index) + unsigned index = variant_table[0].index; + if (index == midrule_rhs_index) return LHS_REF; else - return ind; + return index; } /* Start complaining. */ if (variant_count == 0) - complain_at (loc, _("reference is invalid: %s, symbol not found"), + complain_at (loc, _("invalid reference: %s, symbol not found"), quote (text)); else if (variant_count > 1 && !has_error) - complain_at (loc, _("reference is ambiguous: %s"), + complain_at (loc, _("ambiguous reference: %s"), quote (text)); else if (variant_count > 1 && has_valid && has_error) - complain_at (loc, _("reference is misleading: %s"), + complain_at (loc, _("misleading reference: %s"), quote (text)); else - complain_at (loc, _("reference is invalid: %s"), + complain_at (loc, _("invalid reference: %s"), quote (text)); for (i = 0; i < variant_count; ++i) { - static char at_buf[20]; - - variant = &variant_table[i]; - - if (variant->ind == 0) - strcpy(at_buf, "$$"); - else - snprintf(at_buf, sizeof(at_buf), "$%ld", variant->ind); + const variant *variant = &variant_table[i]; + const char *at_spec = get_at_spec (variant->index); if (variant->err == 0) complain_at (variant->loc, _(" refers to: %c%s at %s"), - dollar_or_at, variant->id, at_buf); + dollar_or_at, variant->id, at_spec); else { static struct obstack msg_buf; - const char *tail = ""; - const char *id; - location loc; - - if (!exact_mode) - tail = cp + strlen(variant->id); - - if (variant->hidden_by) - { - id = variant->hidden_by->id; - loc = variant->hidden_by->loc; - } - else - { - id = variant->id; - loc = variant->loc; - } + const char *tail = exact_mode ? "" : + cp + strlen (variant->id); + const char *id = variant->hidden_by ? variant->hidden_by->id : + variant->id; + location loc = variant->hidden_by ? variant->hidden_by->loc : + variant->loc; /* Create the explanation message. */ - obstack_init (&msg_buf); obstack_fgrow1 (&msg_buf, " possibly meant: %c", dollar_or_at); @@ -581,7 +584,7 @@ parse_named_ref(char *cp, symbol_list *rule, int rule_length, obstack_sgrow (&msg_buf, tail); } - obstack_fgrow1 (&msg_buf, " at %s", at_buf); + obstack_fgrow1 (&msg_buf, " at %s", at_spec); if (variant->err & VARIANT_NOT_VISIBLE_FROM_MIDRULE) obstack_fgrow1 (&msg_buf, ", cannot be accessed from " @@ -617,7 +620,8 @@ handle_action_dollar (symbol_list *rule, char *text, location dollar_loc) char *cp = text + 1; char *gt_ptr = 0; symbol_list *effective_rule; - int effective_rule_length, n; + int effective_rule_length; + int n; if (rule->midrule_parent_rule) { @@ -646,8 +650,8 @@ handle_action_dollar (symbol_list *rule, char *text, location dollar_loc) tag_seen = true; } - n = parse_named_ref (cp, effective_rule, effective_rule_length, - rule->midrule_parent_rhs_index, text, dollar_loc, '$'); + n = parse_ref (cp, effective_rule, effective_rule_length, + rule->midrule_parent_rhs_index, text, dollar_loc, '$'); if (gt_ptr) *gt_ptr = '\0'; @@ -722,7 +726,8 @@ handle_action_at (symbol_list *rule, char *text, location at_loc) { char *cp = text + 1; symbol_list *effective_rule; - int effective_rule_length, n; + int effective_rule_length; + int n; if (rule->midrule_parent_rule) { @@ -737,7 +742,7 @@ handle_action_at (symbol_list *rule, char *text, location at_loc) muscle_percent_define_ensure("locations", at_loc, true); - n = parse_named_ref (cp, effective_rule, effective_rule_length, + n = parse_ref (cp, effective_rule, effective_rule_length, rule->midrule_parent_rhs_index, text, at_loc, '@'); switch (n) { @@ -796,7 +801,8 @@ code_props_none_init (code_props *self) code_props const code_props_none = CODE_PROPS_NONE_INIT; void -code_props_plain_init (code_props *self, char const *code, location code_loc) +code_props_plain_init (code_props *self, char const *code, + location code_loc) { self->kind = CODE_PROPS_PLAIN; self->code = code; diff --git a/src/scan-gram.l b/src/scan-gram.l index 279bba9..6813e60 100644 --- a/src/scan-gram.l +++ b/src/scan-gram.l @@ -70,7 +70,7 @@ static size_t no_cr_read (FILE *, char *, size_t); /* A string representing the most recently saved token. */ static char *last_string; -/* Bracketed identifier */ +/* Bracketed identifier. */ static uniqstr bracketed_id_str = 0; static location bracketed_id_loc; static boundary bracketed_id_start; @@ -108,7 +108,7 @@ static void unexpected_newline (boundary, char const *); %x SC_COMMENT SC_LINE_COMMENT /* Strings and characters in code. */ %x SC_STRING SC_CHARACTER - /* Bracketed identifiers support */ + /* Bracketed identifiers support. */ %x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID letter [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_] @@ -336,19 +336,19 @@ splice (\\[ \f\t\v]*\n)* { "[" { - if (!bracketed_id_str) - { - bracketed_id_start = loc->start; - bracketed_id_context_state = YY_START; - BEGIN SC_BRACKETED_ID; - } - else + if (bracketed_id_str) { ROLLBACK_CURRENT_TOKEN; BEGIN SC_RETURN_BRACKETED_ID; *loc = id_loc; return ID; } + else + { + bracketed_id_start = loc->start; + bracketed_id_context_state = YY_START; + BEGIN SC_BRACKETED_ID; + } } ":" { BEGIN (bracketed_id_str ? SC_RETURN_BRACKETED_ID : INITIAL); @@ -375,15 +375,15 @@ splice (\\[ \f\t\v]*\n)* { {id} { - if (!bracketed_id_str) + if (bracketed_id_str) { - bracketed_id_str = uniqstr_new (yytext); - bracketed_id_loc = *loc; + complain_at (*loc, _("unexpected identifier in bracketed name: %s"), + quote (yytext)); } else { - complain_at (*loc, _("redundant identifier in bracketed name: %s"), - quote (yytext)); + bracketed_id_str = uniqstr_new (yytext); + bracketed_id_loc = *loc; } } "]" { @@ -399,7 +399,7 @@ splice (\\[ \f\t\v]*\n)* } } else - complain_at (*loc, _("a non empty identifier expected")); + complain_at (*loc, _("an identifier expected")); } . { complain_at (*loc, _("invalid character in bracketed name: %s"), diff --git a/src/symlist.c b/src/symlist.c index 974d974..b3500d2 100644 --- a/src/symlist.c +++ b/src/symlist.c @@ -208,6 +208,12 @@ symbol_list_n_type_name_get (symbol_list *l, location loc, int n) return l->content.sym->type_name; } +bool +symbol_list_null (symbol_list *node) +{ + return !node || + (node->content_type == SYMLIST_SYMBOL && !(node->content.sym)); +} void symbol_list_destructor_set (symbol_list *node, char const *code, location loc) diff --git a/src/symlist.h b/src/symlist.h index df3a042..e02c9e4 100644 --- a/src/symlist.h +++ b/src/symlist.h @@ -114,6 +114,9 @@ symbol_list *symbol_list_n_get (symbol_list *l, int n); symbol N in rule RULE. */ 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); + /** Set the \c \%destructor for \c node as \c code at \c loc. */ void symbol_list_destructor_set (symbol_list *node, char const *code, location loc); diff --git a/tests/named-refs.at b/tests/named-refs.at index d8fd2ec..efa10b0 100644 --- a/tests/named-refs.at +++ b/tests/named-refs.at @@ -1,7 +1,6 @@ # Named references test. -*- Autotest -*- -# Copyright (C) 2009 Free Software -# Foundation, Inc. +# Copyright (C) 2009 Free Software Foundation, Inc. # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -256,14 +255,14 @@ exp: ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:50.51-60: reference is invalid: `$lo9', symbol not found -test.y:51.51-60: reference is misleading: `$exp' +[[test.y:50.51-60: invalid reference: `$lo9', symbol not found +test.y:51.51-60: misleading reference: `$exp' test.y:42.1-3: refers to: $exp at $$ test.y:51.7: possibly meant: $x, hiding $exp at $1 test.y:51.41: possibly meant: $r, hiding $exp at $4 test.y:52.51-52: $l of `exp' has no declared type -test.y:55.46-49: reference is invalid: `$r12', symbol not found -test.y:56.29-33: reference is invalid: `$expo', symbol not found +test.y:55.46-49: invalid reference: `$r12', symbol not found +test.y:56.29-33: invalid reference: `$expo', symbol not found ]]) AT_CLEANUP @@ -278,7 +277,7 @@ foo: '1' foo.bar: '2' ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:11.22-29: reference is misleading: `$foo.bar' +[[test.y:11.22-29: misleading reference: `$foo.bar' test.y:11.8-10: refers to: $foo at $1 test.y:11.12-18: possibly meant: $[foo.bar] at $2 ]]) @@ -354,33 +353,33 @@ factor: '(' expr ')' { $$ = $2; } ; ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:24.36-41: reference is invalid: `$cond1', symbol not found -test.y:26.43-53: reference is invalid: `$stmt.field' +[[test.y:24.36-41: invalid reference: `$cond1', symbol not found +test.y:26.43-53: invalid reference: `$stmt.field' test.y:25.35-38: possibly meant: $then.field, hiding $stmt.field at $4 -test.y:28.43-52: reference is invalid: `$stmt.list' +test.y:28.43-52: invalid reference: `$stmt.list' test.y:27.30-38: possibly meant: $[stmt.list] at $4 -test.y:30.43-46: reference is ambiguous: `$xyz' +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: reference is invalid: `$stmt.list' +test.y:32.43-52: invalid reference: `$stmt.list' 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: reference is invalid: `$stmt.list.field' +test.y:34.43-58: invalid reference: `$stmt.list.field' 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: reference is invalid: `$[stmt.list]' +test.y:36.43-54: invalid reference: `$[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: reference is invalid: `$then.1' +test.y:38.43-49: invalid reference: `$then.1' test.y:37.40-45: possibly meant: $[then.1] at $4 -test.y:40.43-55: reference is invalid: `$then.1.field' +test.y:40.43-55: invalid reference: `$then.1.field' test.y:39.40-45: possibly meant: $[then.1].field at $4 -test.y:42.44-50: reference is invalid: `$stmt.x' +test.y:42.44-50: invalid reference: `$stmt.x' 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: reference is invalid: `$if-stmt-a' +test.y:44.13-22: invalid reference: `$if-stmt-a' test.y:43.1-9: possibly meant: $[if-stmt-a] at $$ -test.y:46.46-54: reference is invalid: `$then-a.f' +test.y:46.46-54: invalid reference: `$then-a.f' test.y:45.41-46: possibly meant: $[then-a].f at $4 ]]) AT_CLEANUP @@ -395,7 +394,7 @@ start: foo[] bar { s = $foo; } ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:11.12: a non empty identifier expected +[[test.y:11.12: an identifier expected ]]) AT_CLEANUP @@ -409,7 +408,7 @@ start: foo[ a d ] bar { s = $foo; } ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:11.15: redundant identifier in bracketed name: `d' +[[test.y:11.15: unexpected identifier in bracketed name: `d' ]]) AT_CLEANUP @@ -423,7 +422,7 @@ start: foo[/* comment */] bar { s = $foo; } ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:11.25: a non empty identifier expected +[[test.y:11.25: an identifier expected ]]) AT_CLEANUP @@ -452,6 +451,6 @@ AT_DATA_GRAMMAR([test.y], start[a s]: foo ]]) AT_BISON_CHECK([-o test.c test.y], 1, [], -[[test.y:11.9: redundant identifier in bracketed name: `s' +[[test.y:11.9: unexpected identifier in bracketed name: `s' ]]) AT_CLEANUP -- 1.6.0.6