Attaching lineno to buckets is stupid, since only one copy of each

symbol is kept, only the line of the first occurrence is kept too.
* src/symtab.h, src/symtab.c (bucket): Remove the line member.
* src/reader.c (rline_allocated): Remove, unused.
(symbol_list): Have a `line' member.
(symbol_list_new): New.
(readgram): Use it.
* src/print.c (print_grammar): Output the rule line numbers.
* tests/regression.at (Solved SR Conflicts)
(Unresolved SR Conflicts): Adjust.
Reported by Hans Aberg.

diff --git a/ChangeLog b/ChangeLog
index 2315e33a55d09dd6fb2a6f71a0d75b14c0d7c333..d761d03aee445afccd6624bc2ce015e83b8f8434 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,18 @@
+2001-11-23  Akim Demaille  <akim@epita.fr>
+
+       Attaching lineno to buckets is stupid, since only one copy of each
+       symbol is kept, only the line of the first occurrence is kept too.
+
+       * src/symtab.h, src/symtab.c (bucket): Remove the line member.
+       * src/reader.c (rline_allocated): Remove, unused.
+       (symbol_list): Have a `line' member.
+       (symbol_list_new): New.
+       (readgram): Use it.
+       * src/print.c (print_grammar): Output the rule line numbers.
+       * tests/regression.at (Solved SR Conflicts)
+       (Unresolved SR Conflicts): Adjust.
+       Reported by Hans Aberg.
+
 2001-11-22  Marc Autret  <autret_m@epita.fr>
 
        * src/bison.simple [YYERROR_VERBOSE]: Force its value to be 1 or 0.

diff --git a/src/print.c b/src/print.c
index faa6c0a133e68da3e69f775141b660c5dafa5ce0..6a302962301e0199b0c25036f71b2a6080873f8f 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -213,17 +213,19 @@ print_grammar (FILE *out)
 
   /* rule # : LHS -> RHS */
   fprintf (out, "\n%s\n\n", _("Grammar"));
+  fprintf (out, "  %s\n", _("Number, Line, Rule"));
   for (i = 1; i <= nrules; i++)
     /* Don't print rules disabled in reduce_grammar_tables.  */
     if (rule_table[i].lhs >= 0)
       {
-       fprintf (out, _("rule %-4d %s ->"), i, tags[rule_table[i].lhs]);
+       fprintf (out, _("  %3d %3d %s ->"),
+                i, rule_table[i].line, tags[rule_table[i].lhs]);
        rule = &ritem[rule_table[i].rhs];
        if (*rule > 0)
          while (*rule > 0)
            fprintf (out, " %s", tags[*rule++]);
        else
-         fprintf (out, "               /* %s */", _("empty"));
+         fprintf (out, " /* %s */", _("empty"));
        fputc ('\n', out);
       }
 

diff --git a/src/reader.c b/src/reader.c
index 5abb46edaeb3b7f3fb8bcf819766edc3b1164fe8..30e7f5814a62fc9d68922efea05c7d150d9846d7 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -36,13 +36,11 @@
 #include "conflicts.h"
 #include "muscle_tab.h"
 
-/* Number of slots allocated (but not necessarily used yet) in `rline'  */
-static int rline_allocated;
-
 typedef struct symbol_list
 {
   struct symbol_list *next;
   bucket *sym;
+  int line;
   bucket *ruleprec;
 }
 symbol_list;
@@ -66,6 +64,19 @@ static int lastprec;
 
 static bucket *errtoken;
 static bucket *undeftoken;
+
+
+symbol_list *
+symbol_list_new (bucket *sym)
+{
+  symbol_list *res = XMALLOC (symbol_list, 1);
+  res->next = NULL;
+  res->sym = sym;
+  res->line = lineno;
+  res->ruleprec = NULL;
+  return res;
+}
+
 \f
 
 /*===================\
@@ -123,7 +134,7 @@ read_signed_integer (FILE *stream)
 `--------------------------------------------------------------*/
 
 static char *
-get_type_name (int n, symbol_list * rule)
+get_type_name (int n, symbol_list *rule)
 {
   int i;
   symbol_list *rp;
@@ -568,7 +579,8 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
       else
        {
          complain (_("`%s' is invalid in %s"),
-                   token_buffer, (what_is == token_sym) ? "%token" : "%nterm");
+                   token_buffer,
+                   (what_is == token_sym) ? "%token" : "%nterm");
          skip_to_char ('%');
        }
     }
@@ -1393,8 +1405,7 @@ readgram (void)
          nrules++;
          nitems++;
 
-         p = XCALLOC (symbol_list, 1);
-         p->sym = lhs;
+         p = symbol_list_new (lhs);
 
          crule1 = p1;
          if (p1)
@@ -1456,27 +1467,25 @@ readgram (void)
                 non-terminal.  */
              if (action_flag)
                {
-                 bucket *sdummy;
-
                  /* Since the action was written out with this rule's
                     number, we must give the new rule this number by
                     inserting the new rule before it.  */
 
                  /* Make a dummy nonterminal, a gensym.  */
-                 sdummy = gensym ();
+                 bucket *sdummy = gensym ();
 
                  /* Make a new rule, whose body is empty,
                     before the current one, so that the action
                     just read can belong to it.  */
                  nrules++;
                  nitems++;
-                 p = XCALLOC (symbol_list, 1);
+                 p = symbol_list_new (sdummy);
                  if (crule1)
                    crule1->next = p;
                  else
                    grammar = p;
-                 p->sym = sdummy;
-                 crule1 = XCALLOC (symbol_list, 1);
+                 /* End of the rule. */
+                 crule1 = symbol_list_new (NULL);
                  crule1->next = crule;
 
                  p->next = crule1;
@@ -1484,8 +1493,7 @@ readgram (void)
                  /* Insert the dummy generated by that rule into this
                     rule.  */
                  nitems++;
-                 p = XCALLOC (symbol_list, 1);
-                 p->sym = sdummy;
+                 p = symbol_list_new (sdummy);
                  p1->next = p;
                  p1 = p;
 
@@ -1495,8 +1503,7 @@ readgram (void)
              if (t == tok_identifier)
                {
                  nitems++;
-                 p = XCALLOC (symbol_list, 1);
-                 p->sym = symval;
+                 p = symbol_list_new (symval);
                  p1->next = p;
                  p1 = p;
                }
@@ -1510,7 +1517,7 @@ readgram (void)
            }                   /* end of  read rhs of rule */
 
          /* Put an empty link in the list to mark the end of this rule  */
-         p = XCALLOC (symbol_list, 1);
+         p = symbol_list_new (NULL);
          p1->next = p;
          p1 = p;
 
@@ -1903,8 +1910,6 @@ packgram (void)
   int ruleno;
   symbol_list *p;
 
-  bucket *ruleprec;
-
   ritem = XCALLOC (short, nitems + 1);
   rule_table = XCALLOC (rule_t, nrules) - 1;
 
@@ -1914,10 +1919,10 @@ packgram (void)
   p = grammar;
   while (p)
     {
+      bucket *ruleprec = p->ruleprec;
       rule_table[ruleno].lhs = p->sym->value;
       rule_table[ruleno].rhs = itemno;
-      rule_table[ruleno].line = p->sym->line;
-      ruleprec = p->ruleprec;
+      rule_table[ruleno].line = p->line;
 
       p = p->next;
       while (p && p->sym)

diff --git a/src/symtab.c b/src/symtab.c
index c701ccd673b6479f9ff8533305bcdc5db1a0e9c8..455e74e2310ec00727a8f68034e406d3f7fd17a9 100644 (file)
--- a/src/symtab.c
+++ b/src/symtab.c
@@ -49,9 +49,6 @@ hash (const char *key)
 static bucket *
 bucket_new (const char *tag, int hashval)
 {
-  /* Hack, until we have a Bison parser. */
-  extern int lineno;
-
   bucket *res = XMALLOC (bucket, 1);
 
   res->link = symtab[hashval];
@@ -64,7 +61,6 @@ bucket_new (const char *tag, int hashval)
   res->user_token_number = SUNDEF;
   res->alias = NULL;
   res->class = unknown_sym;
-  res->line = lineno;
 
   nsyms++;
 

diff --git a/src/symtab.h b/src/symtab.h
index 4ebc4a1afea4f1fee3b9b142533164a8bdb156d0..b98902e14015b1e210cd307b99fc0f24aaaab010 100644 (file)
--- a/src/symtab.h
+++ b/src/symtab.h
@@ -42,9 +42,6 @@ typedef struct bucket
   struct bucket *link;
   struct bucket *next;
 
-  /* The line it was found in. */
-  short line;
-
   /* The key, name of the symbol. */
   char *tag;
   /* Its type. */

diff --git a/tests/regression.at b/tests/regression.at
index 6f702f322083da909339a71370a634e2f70a5038..2de592b27052c55125d529008c12678720b97a16 100644 (file)
--- a/tests/regression.at
+++ b/tests/regression.at
@@ -65,8 +65,9 @@ AT_CHECK([cat input.output], [],
 
 Grammar
 
-rule 1    exp -> exp OP exp
-rule 2    exp -> NUM
+  Number, Line, Rule
+    1   3 exp -> exp OP exp
+    2   3 exp -> NUM
 
 Terminals, with rules where they appear
 
@@ -163,8 +164,9 @@ AT_CHECK([cat input.output], [],
 
 Grammar
 
-rule 1    exp -> exp OP exp
-rule 2    exp -> NUM
+  Number, Line, Rule
+    1   4 exp -> exp OP exp
+    2   4 exp -> NUM
 
 Terminals, with rules where they appear