Attached now ---------- Forwarded message ---------- From: Alex Rozenman <[email protected]> Date: Sat, Jul 4, 2009 at 9:50 PM Subject: [PATCH] Style change and some factoring To: Akim Demaille <[email protected]>, "Joel E. Denny" < [email protected]> Cc: [email protected], Alex Rozenman <[email protected]>
Hi I pushed the attached patch to the master. The patch contains various style fixes (according to Akim's request) and some factoring. I will also cherry-pick to branch-2.5. Some points: On Sun, Jun 28, 2009 at 2:57 PM, Akim Demaille <[email protected]> wrote: > Too eager to play with your patch, I made several errors in my grammar. I > had a $from.name_get() but I forgot to declare [from]. Bison answered: > ugrammar-pruned.y:534.37-50: reference is invalid: `$from.name_get', symbol > not found > IMHO it should refer to $from, not to $from.name_get. > I will change it. I can agree that in case of "symbol not found" error we should show shortest possible symbol (without dots and dashes). > Also, I had a $9foo, where 9 should have been removed. It accepted $9 and > left the "foo" attached to the expansion of $9. Now that we have $[] to > make what we mean clear, I think that it should complain about $9foo, like > it does for the grammar symbol 9foo. We should support $[9]foo for those > who really mean that. > This applies to other values of 9 and foo :) > I would agree with that, except it will affect backward compatibility. I tried the same example with an old version of bison and got exactly the same behaviour: only digit was eaten and all the rest was attached in the generated code. Currently my code deals with positional references exactly like the old implementations did. There is no another option, IMHO. #define INVALID_REF (INT_MIN) > #define LHS_REF (INT_MIN + 1) > static long int > parse_named_ref(char *cp, symbol_list *rule, int rule_length, > More doc please. What is "long int"? Probably the domain for ind, so > please introduce some "variant_index" typedef. > Please note that, actually there is two domains for indexes. When we speak about named references, "unsigned" is very enough (I changed it). But for positional references, there is an option for $-3 "deep" stack references. This is the reason that "parse_ref" function must return a signed value. "long int" is also taken from old code with intention to keep existing functionality. -- Best regards, Alex Rozenman ([email protected]). -- Best regards, Alex Rozenman ([email protected]).
From 872b52bc24b5590ac8bdec7db882cdbefc0ec3ff Mon Sep 17 00:00:00 2001 From: Alex Rozenman <[email protected]> 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 <[email protected]> + + 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 <[email protected]> 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 "<tag>" %token TAG_ANY "<*>" %token TAG_NONE "<>" -%token BRACKETED_ID "[id]" +%token BRACKETED_ID "[identifier]" %type <character> 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 <src/complain.h> #include <src/reader.h> #include <src/getargs.h> -#include <get-errno.h> -#include <quote.h> #include <src/muscle-tab.h> #include <src/scan-code.h> #include <src/symlist.h> +#include <c-ctype.h> +#include <get-errno.h> +#include <quote.h> + /* 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)* <SC_AFTER_IDENTIFIER> { "[" { - 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)* <SC_BRACKETED_ID> { {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: `$<ival>lo9', symbol not found -test.y:51.51-60: reference is misleading: `$<ival>exp' +[[test.y:50.51-60: invalid reference: `$<ival>lo9', symbol not found +test.y:51.51-60: misleading reference: `$<ival>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
