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

@@ -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

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;
+/* Named reference object. Keeps information about
-
+   a symbolic name of a symbol in a rule. */
-struct named_ref
+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_ */

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.  */
+  /* Nothing. */ { $$ = 0; }
-    { $$ = 0; }
 |
-  BRACKETED_ID
+  BRACKETED_ID   { $$ = named_ref_new($1, @1); }
-    { $$ = named_ref_new($1, @1); }
 ;
 
 

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)
-    {
+    assign_named_ref(p, 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;
-    }
 
   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)
-    {
+    assign_named_ref(p, 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;
-    }
 }
 
 /* Attach an ACTION to the current rule.  */

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)
+is_dot_or_dash (char ch)
-{
-  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)
 {
   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
+/* Defines a variant of a symbolic name resolution. */
-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)
-
 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)
+  for (; *prefix && ptr != end; ++prefix, ++ptr)
-    {
+    if (*prefix != *ptr)
-      if (*prefix != *ptr)
+      return 0;
-	return 0;
-      ++prefix, ++ptr;
-    }
 
   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,
+variant_add (uniqstr id, location loc, unsigned index,
-	    char *cp, char *cp_end, bool exact_mode)
+	     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();
+      variant *r = variant_table_grow ();
-      r->ind = ind;
+      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,
+parse_ref (char *cp, symbol_list *rule, int rule_length,
-		int midrule_rhs_index, char *text, location loc,
+	   int midrule_rhs_index, char *text, location loc,
-		char dollar_or_at)
+	   char dollar_or_at)
 {
   symbol_list *l;
   char *cp_end;
   bool exact_mode;
   bool has_error;
   bool has_valid;
-  long int ind, i;
+  unsigned i;
-  variant* variant;
-  char* p;
 
   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;
+      char *p;
-      for (p = cp; *p != ']'; ++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)
+    unsigned index;
-    {
+    variant_count = 0;
-      if (l->content_type != SYMLIST_SYMBOL)
+    for (index = 0, l = rule; !symbol_list_null (l); ++index, l = l->next)
-	continue;
+      {
+	variant *variant;
+	if (l->content_type != SYMLIST_SYMBOL)
+	  continue;
 
-      variant = variant_add(l->content.sym->tag, l->sym_loc, ind,
+	variant = variant_add (l->content.sym->tag, l->sym_loc, index,
-			    cp, cp_end, exact_mode);
+			       cp, cp_end, exact_mode);
 
-      if (variant && l->named_ref)
+	if (variant && l->named_ref)
-	variant->hidden_by = l->named_ref;
+	  variant->hidden_by = l->named_ref;
 
-      if (l->named_ref)
+	if (l->named_ref)
-	variant_add(l->named_ref->id, l->named_ref->loc, ind,
+	  variant_add (l->named_ref->id, l->named_ref->loc, index,
-		    cp, cp_end, exact_mode);
+		       cp, cp_end, exact_mode);
-    }
+      }
+  }
 
   /* Check errors. */
   has_error = false;
   has_valid = false;
   for (i = 0; i < variant_count; ++i)
     {
-      variant = &variant_table[i];
+      variant *variant = &variant_table[i];
-      ind = variant->ind;
+      unsigned index = variant->index;
 
       /* Check visibility from mid-rule actions. */
-      if (midrule_rhs_index != 0 &&
+      if (midrule_rhs_index != 0
-	  (ind == 0 || ind > midrule_rhs_index))
+	  && (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;
+      unsigned index = variant_table[0].index;
-      if (ind == midrule_rhs_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];
+      const variant *variant = &variant_table[i];
-
+      const char *at_spec = get_at_spec (variant->index);
-      variant = &variant_table[i];
-
-      if (variant->ind == 0)
-	strcpy(at_buf, "$$");
-      else
-	snprintf(at_buf, sizeof(at_buf), "$%ld", variant->ind);
 
       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 *tail = exact_mode ? "" :
-	  const char *id;
+	    cp + strlen (variant->id);
-	  location loc;
+	  const char *id = variant->hidden_by ? variant->hidden_by->id :
-
+	    variant->id;
-	  if (!exact_mode)
+	  location loc = variant->hidden_by ? variant->hidden_by->loc :
-	    tail = cp + strlen(variant->id);
+	    variant->loc;
-
-	  if (variant->hidden_by)
-	    {
-	      id = variant->hidden_by->id;
-	      loc = variant->hidden_by->loc;
-	    }
-	  else
-	    {
-	      id = variant->id;
-	      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,
+  n = parse_ref (cp, effective_rule, effective_rule_length,
-		       rule->midrule_parent_rhs_index, text, dollar_loc, '$');
+		 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;

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)
+    if (bracketed_id_str)
-      {
-	bracketed_id_start = loc->start;
-	bracketed_id_context_state = YY_START;
-	BEGIN SC_BRACKETED_ID;
-      }
-    else
       {
 	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);
+	complain_at (*loc, _("unexpected identifier in bracketed name: %s"),
-	bracketed_id_loc = *loc;
+		     quote (yytext));
       }
     else
       {
-	complain_at (*loc, _("redundant identifier in bracketed name: %s"),
+	bracketed_id_str = uniqstr_new (yytext);
-		     quote (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"),

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)

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);

tests/named-refs.at

@@ -1,7 +1,6 @@
 # Named references test.                           -*- Autotest -*-
 
-# Copyright (C) 2009 Free Software
+# Copyright (C) 2009 Free Software Foundation, Inc.
-# 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:50.51-60: invalid reference: `$<ival>lo9', symbol not found
-test.y:51.51-60: reference is misleading: `$<ival>exp'
+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:55.46-49: invalid reference: `$r12', symbol not found
-test.y:56.29-33: reference is invalid: `$expo', 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:24.36-41: invalid reference: `$cond1', symbol not found
-test.y:26.43-53: reference is invalid: `$stmt.field'
+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