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.
2026-03-09 12:23:04 +00:00 · 2009-07-04 22:16:17 +03:00
parent ae09ec8577
commit d5e8574bf6
9 changed files with 222 additions and 196 deletions
--- a/14
+++ b/14
@@ -1,3 +1,17 @@
+2009-07-04  Alex Rozenman <rozenman@gmail.com>
+
+	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  <ebb9@byu.net>

 	scan-code: avoid compiler warnings
--- 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 loc;
-};

+  /* 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_ */
--- 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"

@@ -172,7 +172,7 @@ static int current_prec = 0;
 %token TYPE            "type"
 %token TYPE_TAG_ANY    "<*>"
 %token TYPE_TAG_NONE   "<>"
-%token BRACKETED_ID    "[id]"
+%token BRACKETED_ID    "[identifier]"

 %type <character> CHAR
 %printer { fputs (char_name ($$), stderr); } CHAR
@@ -551,11 +551,9 @@ rhs:
 ;

 named_ref.opt:
-  /* Nothing.  */
-    { $$ = 0; }
+  /* Nothing. */ { $$ = 0; }
 |
-  BRACKETED_ID
-    { $$ = named_ref_new($1, @1); }
+  BRACKETED_ID   { $$ = named_ref_new($1, @1); }
 ;


--- 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.  */
--- a/src/scan-code.l
+++ b/src/scan-code.l
@@ -32,12 +32,13 @@
 #include "complain.h"
 #include "reader.h"
 #include "getargs.h"
-#include <get-errno.h>
-#include <quote.h>
-
 #include "scan-code.h"
 #include "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 +50,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 +82,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 +183,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 +191,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 +287,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)
+contains_dot_or_dash (const char* p)
 {
-  return '0' <= ch && ch <= '9';
+  for (; *p; ++p)
+    if (is_dot_or_dash (*p))
+      return true;
+  return false;
 }

-static inline bool
-contains_dot_or_dash(const char* str)
-{
-  return strpbrk(str, ".-") != NULL;
-}
-
-#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 +351,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 +366,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 +388,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 +439,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 +523,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 +583,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 +619,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 +649,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 +725,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 +741,7 @@ handle_action_at (symbol_list *rule, char *text, location at_loc)

  locations_flag = 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 +800,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;
--- a/src/scan-gram.l
+++ b/src/scan-gram.l
@@ -64,7 +64,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;
@@ -100,7 +100,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_]
@@ -308,19 +308,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);
@@ -347,15 +347,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;
      }
  }
  "]" {
@@ -371,7 +371,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"),
--- 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)
--- 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);
--- 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