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.

diff --git a/ChangeLog b/ChangeLog
index 52b30c2138c221928c2b3138c87fbbc68f2fed22..a5972d088fff6ff2b54665231c022cb555488361 100644 (file)
--- a/ChangeLog
+++ b/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
 2009-06-29  Eric Blake  <ebb9@byu.net>
 
        scan-code: avoid compiler warnings

diff --git a/src/named-ref.h b/src/named-ref.h
index 9100296fdfb7ae4e4e13e4116437139356cd780a..20e92e32759d4d6e98b9ea30294b2234315c1e83 100644 (file)
--- a/src/named-ref.h
+++ b/src/named-ref.h
@@ -20,19 +20,24 @@
 #ifndef NAMED_REF_H_
 # define NAMED_REF_H_
 
 #ifndef NAMED_REF_H_
 # define NAMED_REF_H_
 

-#include "uniqstr.h"

 #include "location.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;
   uniqstr id;

+
+  /* Location of the symbolic name. Not including brackets. */

   location loc;
   location loc;

-};
+} named_ref;

 
 

+/* Allocate a named reference object. */

 named_ref *named_ref_new (uniqstr id, location loc);
 
 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_ */
 void named_ref_free (named_ref *r);
 
 #endif /* !NAMED_REF_H_ */

diff --git a/src/parse-gram.y b/src/parse-gram.y
index 86466822b415b2228a50e636da160b19f7498800..c90d14d80cd0098ffa279bb6d096c7f35a9332fb 100644 (file)
--- 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 "getargs.h"
 #include "gram.h"
 #include "muscle_tab.h"

+#include "named-ref.h"

 #include "quotearg.h"
 #include "reader.h"
 #include "symlist.h"
 #include "quotearg.h"
 #include "reader.h"
 #include "symlist.h"

-#include "named-ref.h"

 #include "scan-gram.h"
 #include "scan-code.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 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
 
 %type <character> CHAR
 %printer { fputs (char_name ($$), stderr); } CHAR


@@ -551,11 +551,9 @@ rhs:
 ;
 
 named_ref.opt:
 ;
 
 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 ec560aa55a266638e2cadf499ce6376b1e608051..6b2b94411622ad1ae8409aa1d0cdd94163145731 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -190,6 +190,23 @@ grammar_symbol_append (symbol *sym, location loc)
   return p;
 }
 
   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).  */
 /* 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)
 
   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;
 
 
   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);
 
   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
   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 (current_rule->action_props.code)
     grammar_midrule_action ();
   p = grammar_symbol_append (sym, loc);

-

   if (named_ref)
   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.  */
 }
 
 /* Attach an ACTION to the current rule.  */

diff --git a/src/scan-code.l b/src/scan-code.l
index 36990f3895396916e45f69034bfbe8128504b0fe..47cde77eac80aca1bafb0c432387e2aa84551e33 100644 (file)
--- a/src/scan-code.l
+++ b/src/scan-code.l
@@ -32,12 +32,13 @@
 #include "complain.h"
 #include "reader.h"
 #include "getargs.h"
 #include "complain.h"
 #include "reader.h"
 #include "getargs.h"

-#include <get-errno.h>
-#include <quote.h>
-

 #include "scan-code.h"
 #include "symlist.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)
 /* 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);
 
                                  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;
 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
 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}"]"|"$"
 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);
   "$"("<"{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;
       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);
   "@"{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;
       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
 static inline bool

-is_dot_or_dash(char ch)
+is_dot_or_dash (char ch)

 {
   return ch == '.' || ch == '-';
 }
 
 static inline bool
 {
   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. */
 typedef struct
 {
   /* Index in symbol list. */

-  long int ind;
+  unsigned index;

 
   /* Matched symbol id and loc. */
   uniqstr id;
   location loc;
 
 
   /* Matched symbol id and loc. */
   uniqstr id;
   location loc;
 

-  /* Hidding named reference. */
+  /* Hiding named reference. */

   named_ref* hidden_by;
 
   named_ref* hidden_by;
 

-  /* Error flags. */
+  /* Error flags. May contain zero (no errors) or
+     a combination of VARIANT_* values. */

   unsigned err;
 } variant;
 
   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 *
 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)
 {
   ++variant_count;
   if (variant_count > variant_table_size)


@@ -352,16 +351,13 @@ variant_table_grow()
 }
 
 static char *
 }
 
 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;
 
 {
   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;
 
   if (*prefix)
     return 0;


@@ -370,18 +366,18 @@ find_prefix_end(const char *prefix, char *begin, char *end)
 }
 
 static variant *
 }
 
 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;
 
 {
   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 ||
   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;
       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;
 }
 
     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)
 #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)
 
 #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
 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;
 {
   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 ('$' == *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)
     {
       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)
     {
 
   if ('[' == *cp)
     {

-      exact_mode = true;
-

       /* Ignore the brackets. */
       /* Ignore the brackets. */

-      ++cp;
-      for (p = cp; *p != ']'; ++p);
+      char *p;
+      for (p = ++cp; *p != ']'; ++p)
+       continue;

       cp_end = p;
       cp_end = p;

+
+      exact_mode = true;

     }
   else
     {
     }
   else
     {

-      exact_mode = false;
-

       /* Take all characters of the name. */
       /* Take all characters of the name. */

+      char* p;

       for (p = cp; *p; ++p)
       for (p = cp; *p; ++p)

-       if (is_dot_or_dash(*p))
+       if (is_dot_or_dash (*p))

          {
            ref_tail_fields = p;
            break;
          }
          {
            ref_tail_fields = p;
            break;
          }

-      for (p = cp; *p; ++p);
+      for (p = cp; *p; ++p)
+       continue;

       cp_end = p;
       cp_end = p;

+
+      exact_mode = false;

     }
 
   /* Add all relevant variants. */
     }
 
   /* 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)
     {
 
   /* 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. */
 
       /* 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. */
        {
          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. */
        {
          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;
        {
          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. */
   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 LHS_REF;
       else

-       return ind;
+       return index;

     }
 
   /* Start complaining. */
 
   if (variant_count == 0)
     }
 
   /* 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)
                 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)
                 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
                 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)
     {
                 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"),
 
       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;
       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. */
 
          /* Create the explanation message. */

-

          obstack_init (&msg_buf);
 
          obstack_fgrow1 (&msg_buf, "  possibly meant: %c", dollar_or_at);
          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_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 "
 
          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;
   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)
     {
 
   if (rule->midrule_parent_rule)
     {


@@ -646,8 +649,8 @@ handle_action_dollar (symbol_list *rule, char *text, location dollar_loc)
       tag_seen = true;
     }
 
       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';
 
   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;
 {
   char *cp = text + 1;
   symbol_list *effective_rule;

-  int effective_rule_length, n;
+  int effective_rule_length;
+  int n;

 
   if (rule->midrule_parent_rule)
     {
 
   if (rule->midrule_parent_rule)
     {


@@ -737,7 +741,7 @@ handle_action_at (symbol_list *rule, char *text, location at_loc)
 
   locations_flag = true;
 
 
   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)
     {
                       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 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;
 {
   self->kind = CODE_PROPS_PLAIN;
   self->code = code;

diff --git a/src/scan-gram.l b/src/scan-gram.l
index 00c7ab40793c4756acbd6893e2d2c5de2363f00c..60813bb620d352ee0e2dea522b085a92d19cffaa 100644 (file)
--- 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;
 
 /* 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;
 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
 %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_]
 %x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID
 
 letter   [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]


@@ -308,19 +308,19 @@ splice     (\\[ \f\t\v]*\n)*
 <SC_AFTER_IDENTIFIER>
 {
   "[" {
 <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;
       }
       {
        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);
   }
   ":" {
     BEGIN (bracketed_id_str ? SC_RETURN_BRACKETED_ID : INITIAL);


@@ -347,15 +347,15 @@ splice     (\\[ \f\t\v]*\n)*
 <SC_BRACKETED_ID>
 {
   {id} {
 <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
       {
       }
     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
          }
       }
     else

-      complain_at (*loc, _("a non empty identifier expected"));
+      complain_at (*loc, _("an identifier expected"));

   }
   . {
     complain_at (*loc, _("invalid character in bracketed name: %s"),
   }
   . {
     complain_at (*loc, _("invalid character in bracketed name: %s"),

diff --git a/src/symlist.c b/src/symlist.c
index 974d974ccf447555847f797c8e9fdf503780e87e..b3500d2dbbe336b044536c67ac74907896dd4b54 100644 (file)
--- 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;
 }
 
   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)
 
 void
 symbol_list_destructor_set (symbol_list *node, char const *code, location loc)

diff --git a/src/symlist.h b/src/symlist.h
index df3a0421302f8dfba2c9aba0693716ce18094c25..e02c9e4f72d9cd147456a124d7cbce70975985bf 100644 (file)
--- 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);
 
    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);
 /** 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 6a91cb4b95e9e98b13495e28eb859f4d3905a652..8374cc4b6effd2f58eee590eae9f02fe135f57ff 100644 (file)
--- a/tests/named-refs.at
+++ b/tests/named-refs.at
@@ -1,7 +1,6 @@
 # Named references test.                           -*- Autotest -*-
 
 # 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
 
 # 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, [],
 ]])
 
 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: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
 
 ]])
 AT_CLEANUP
 


@@ -278,7 +277,7 @@ foo: '1'
 foo.bar: '2'
 ]])
 AT_BISON_CHECK([-o test.c test.y], 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
 ]])
 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, [],
     ;
 ]])
 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: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: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: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: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: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: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: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: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: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: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
 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, [],
   { 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
 
 ]])
 AT_CLEANUP
 


@@ -409,7 +408,7 @@ start: foo[ a d ] bar
   { s = $foo; }
 ]])
 AT_BISON_CHECK([-o test.c test.y], 1, [],
   { 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
 
 ]])
 AT_CLEANUP
 


@@ -423,7 +422,7 @@ start: foo[/* comment */] bar
   { s = $foo; }
 ]])
 AT_BISON_CHECK([-o test.c test.y], 1, [],
   { 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
 
 ]])
 AT_CLEANUP
 


@@ -452,6 +451,6 @@ AT_DATA_GRAMMAR([test.y],
 start[a s]: foo
 ]])
 AT_BISON_CHECK([-o test.c test.y], 1, [],
 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
 ]])
 AT_CLEANUP