* src/derives.h, src/derives.c (derives): A `rule_t***' instead of

`rule_number_t**'.
(set_derives, free_derives): Rename as...
(derives_compute, derives_free): this.
Adjust all dependencies.
* src/nullable.c (set_nullable, free_nullable): Rename as...
(nullable_compute, nullable_free): these.
(rule_list_t): Store rule_t *, not rule_number_t.
* src/state.c (state_rule_lookaheads_print): Directly compare rule
pointers, instead of their numbers.
* src/main.c (main): Call nullable_free, and derives_free earlier,
as they were lo longer used.

diff --git a/ChangeLog b/ChangeLog
index bfa1ed264ae07e5b7c214bd2a6b070c584b6b0b3..da461eea654bbbf5e08b971699b52dc549cd04b6 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,18 @@
+2002-08-01  Akim Demaille  <akim@epita.fr>
+
+       * src/derives.h, src/derives.c (derives): A `rule_t***' instead of
+       `rule_number_t**'.
+       (set_derives, free_derives): Rename as...
+       (derives_compute, derives_free): this.
+       Adjust all dependencies.
+       * src/nullable.c (set_nullable, free_nullable): Rename as...
+       (nullable_compute, nullable_free): these.
+       (rule_list_t): Store rule_t *, not rule_number_t.
+       * src/state.c (state_rule_lookaheads_print): Directly compare rule
+       pointers, instead of their numbers.
+       * src/main.c (main): Call nullable_free, and derives_free earlier,
+       as they were lo longer used.
+
 2002-08-01  Akim Demaille  <akim@epita.fr>
 
        * lib/timevar.c (get_time): Include children time.

diff --git a/src/closure.c b/src/closure.c
index 994634c036a7f38b50ec2322cb470ad86431de96..3d5ac28d0bcf69957980add665f832f67a517bd7 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -125,9 +125,9 @@ set_firsts (void)
   firsts = bitsetv_create (nvars, nvars, BITSET_FIXED);
 
   for (i = ntokens; i < nsyms; i++)
-    for (j = 0; derives[i][j] >= 0; ++j)
+    for (j = 0; derives[i][j]; ++j)
       {
-       int symbol = rules[derives[i][j]].rhs[0];
+       int symbol = derives[i][j]->rhs[0];
        if (ISVAR (symbol))
          bitset_set (FIRSTS (i), symbol - ntokens);
       }
@@ -165,8 +165,8 @@ set_fderives (void)
   for (i = ntokens; i < nsyms; ++i)
     for (j = ntokens; j < nsyms; ++j)
       if (bitset_test (FIRSTS (i), j - ntokens))
-       for (k = 0; derives[j][k] >= 0; ++k)
-         bitset_set (FDERIVES (i), derives[j][k]);
+       for (k = 0; derives[j][k]; ++k)
+         bitset_set (FDERIVES (i), derives[j][k]->number);
 
   if (trace_flag & trace_sets)
     print_fderives ();

diff --git a/src/derives.c b/src/derives.c
index c5b67104d32ce85bfcd9f4ed209170f092a063ef..746929755855c07c41d397ac7395c936e6f9ed59 100644 (file)
--- a/src/derives.c
+++ b/src/derives.c
@@ -1,5 +1,5 @@
 /* Match rules with nonterminals for bison,
-   Copyright 1984, 1989, 2000, 2001, 2002  Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 2000, 2001, 2002  Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -30,10 +30,10 @@
 typedef struct rule_list_s
 {
   struct rule_list_s *next;
-  rule_number_t value;
+  rule_t *value;
 } rule_list_t;
 
-rule_number_t **derives = NULL;
+rule_t ***derives = NULL;
 
 static void
 print_derives (void)
@@ -44,12 +44,12 @@ print_derives (void)
 
   for (i = ntokens; i < nsyms; i++)
     {
-      rule_number_t *rp;
+      rule_t **rp;
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
-      for (rp = derives[i]; *rp >= 0; rp++)
+      for (rp = derives[i]; *rp; ++rp)
        {
-         fprintf (stderr, "\t\t%3d ", *rp);
-         rule_rhs_print (&rules[*rp], stderr);
+         fprintf (stderr, "\t\t%3d ", (*rp)->user_number);
+         rule_rhs_print (*rp, stderr);
        }
     }
 
@@ -58,11 +58,11 @@ print_derives (void)
 
 
 void
-set_derives (void)
+derives_compute (void)
 {
   symbol_number_t i;
   int r;
-  rule_number_t *q;
+  rule_t **q;
 
   /* DSET[NTERM] -- A linked list of the numbers of the rules whose
      LHS is NTERM.  */
@@ -79,15 +79,15 @@ set_derives (void)
       rule_list_t *p = &delts[r];
       /* A new LHS is found.  */
       p->next = dset[lhs];
-      p->value = r;
+      p->value = &rules[r];
       dset[lhs] = p;
     }
 
   /* DSET contains what we need under the form of a linked list.  Make
      it a single array.  */
 
-  derives = XCALLOC (rule_number_t *, nvars) - ntokens;
-  q = XCALLOC (rule_number_t, nvars + int_of_rule_number (nrules));
+  derives = XCALLOC (rule_t **, nvars) - ntokens;
+  q = XCALLOC (rule_t *, nvars + int_of_rule_number (nrules));
 
   for (i = ntokens; i < nsyms; i++)
     {
@@ -98,7 +98,7 @@ set_derives (void)
          *q++ = p->value;
          p = p->next;
        }
-      *q++ = -1;
+      *q++ = NULL;
     }
 
   if (trace_flag & trace_sets)
@@ -110,7 +110,7 @@ set_derives (void)
 
 
 void
-free_derives (void)
+derives_free (void)
 {
   XFREE (derives[ntokens]);
   XFREE (derives + ntokens);

diff --git a/src/derives.h b/src/derives.h
index bcbaa0a7ba68f550431a164e44fa4715bec04e18..c5581243921cd1ab95604eeb932b5437a7a0d410 100644 (file)
--- a/src/derives.h
+++ b/src/derives.h
@@ -1,5 +1,5 @@
 /* Match rules with nonterminals for bison,
-   Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 2000, 2001, 2002  Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -21,13 +21,13 @@
 #ifndef DERIVES_H_
 # define DERIVES_H_
 
-/* DERIVES[SYMBOL - NTOKENS] points to a vector of the number of the
-   rules that SYMBOL derives, terminated with -1.  */
-extern rule_number_t **derives;
+/* DERIVES[SYMBOL - NTOKENS] points to a vector of the rules that
+   SYMBOL derives, terminated with NULL.  */
+extern rule_t ***derives;
 
 /* Compute DERIVES.  */
 
-void set_derives PARAMS((void));
-void free_derives PARAMS((void));
+void derives_compute PARAMS((void));
+void derives_free PARAMS((void));
 
 #endif /* !DERIVES_H_ */

diff --git a/src/lalr.c b/src/lalr.c
index 275c6ab717a046564c38431f3ad589d5a489d3b3..832f1fcf75b073a980cdaf6e096b1a763aa0f26f 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -244,16 +244,16 @@ initialize_F (void)
 
 
 static void
-add_lookback_edge (state_t *state, rule_number_t ruleno, int gotono)
+add_lookback_edge (state_t *state, rule_t *rule, int gotono)
 {
   int i;
   goto_list_t *sp;
 
   for (i = 0; i < state->nlookaheads; ++i)
-    if (state->lookaheads_rule[i]->number == ruleno)
+    if (state->lookaheads_rule[i] == rule)
       break;
 
-  assert (state->lookaheads_rule[i]->number == ruleno);
+  assert (state->lookaheads_rule[i] == rule);
 
   sp = XCALLOC (goto_list_t, 1);
   sp->next = lookback[(state->lookaheads - LA) + i];
@@ -276,9 +276,9 @@ build_relations (void)
     {
       int nedges = 0;
       symbol_number_t symbol1 = states[to_state[i]]->accessing_symbol;
-      rule_number_t *rulep;
+      rule_t **rulep;
 
-      for (rulep = derives[symbol1]; *rulep >= 0; rulep++)
+      for (rulep = derives[symbol1]; *rulep; rulep++)
        {
          int done;
          int length = 1;
@@ -286,7 +286,7 @@ build_relations (void)
          state_t *state = states[from_state[i]];
          states1[0] = state->number;
 
-         for (rp = rules[*rulep].rhs; *rp >= 0; rp++)
+         for (rp = (*rulep)->rhs; *rp >= 0; rp++)
            {
              state = transitions_to (state->transitions,
                                      item_number_as_symbol_number (*rp));

diff --git a/src/main.c b/src/main.c
index b59e2978561c5c6846af3697b9615a51e516f2bc..c695ae5fc68561ae35baac6824e2f7b1ab015a89 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -1,5 +1,5 @@
 /* Top level entry point of bison,
-   Copyright 1984, 1986, 1989, 1992, 1995, 2000, 2001, 2002
+   Copyright (C) 1984, 1986, 1989, 1992, 1995, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
@@ -84,8 +84,8 @@ main (int argc, char *argv[])
   /* Record other info about the grammar.  In files derives and
      nullable.  */
   timevar_push (TV_SETS);
-  set_derives ();
-  set_nullable ();
+  derives_compute ();
+  nullable_compute ();
   timevar_pop (TV_SETS);
 
   /* Convert to nondeterministic finite state machine.  In file LR0.
@@ -99,6 +99,11 @@ main (int argc, char *argv[])
   lalr ();
   timevar_pop (TV_LALR);
 
+  timevar_push (TV_FREE);
+  nullable_free ();
+  derives_free ();
+  timevar_pop (TV_FREE);
+
   /* Find and record any conflicts: places where one token of
      lookahead is not enough to disambiguate the parsing.  In file
      conflicts.  Also resolve s/r conflicts based on precedence
@@ -152,8 +157,6 @@ main (int argc, char *argv[])
   states_free ();
   reduce_free ();
   conflicts_free ();
-  free_nullable ();
-  free_derives ();
   grammar_free ();
 
   /* The scanner memory cannot be released right after parsing, as it

diff --git a/src/nullable.c b/src/nullable.c
index 9f61fa87555ad52bb27d115c9e261eefa9ce9fb9..c0b60f64d40235e653e2f9b7033030341d0d0580 100644 (file)
--- a/src/nullable.c
+++ b/src/nullable.c
@@ -30,14 +30,14 @@
 #include "reduce.h"
 #include "nullable.h"
 
-/* Linked list of rule numbers.  */
+/* Linked list of rules.  */
 typedef struct rule_list_s
 {
   struct rule_list_s *next;
-  rule_number_t value;
+  rule_t *value;
 } rule_list_t;
 
-char *nullable = NULL;
+bool *nullable = NULL;
 
 static void
 nullable_print (FILE *out)
@@ -50,7 +50,7 @@ nullable_print (FILE *out)
 }
 
 void
-set_nullable (void)
+nullable_compute (void)
 {
   rule_number_t ruleno;
   symbol_number_t *s1;
@@ -66,7 +66,7 @@ set_nullable (void)
      Supposedly NRITEMS - NRULES is enough.  But why take the risk?  */
   rule_list_t *relts = XCALLOC (rule_list_t, nritems + nvars + 1);
 
-  nullable = XCALLOC (char, nvars) - ntokens;
+  nullable = XCALLOC (bool, nvars) - ntokens;
 
   s1 = s2 = squeue;
   p = relts;
@@ -91,7 +91,7 @@ set_nullable (void)
                {
                  rcount[ruleno]++;
                  p->next = rsets[*r];
-                 p->value = ruleno;
+                 p->value = rule;
                  rsets[*r] = p;
                  p++;
                }
@@ -111,12 +111,12 @@ set_nullable (void)
   while (s1 < s2)
     for (p = rsets[*s1++]; p; p = p->next)
       {
-       ruleno = p->value;
-       if (--rcount[ruleno] == 0)
-         if (rules[ruleno].useful && !nullable[rules[ruleno].lhs->number])
+       rule_t *rule = p->value;
+       if (--rcount[rule->number] == 0)
+         if (rule->useful && !nullable[rule->lhs->number])
            {
-             nullable[rules[ruleno].lhs->number] = 1;
-             *s2++ = rules[ruleno].lhs->number;
+             nullable[rule->lhs->number] = 1;
+             *s2++ = rule->lhs->number;
            }
       }
 
@@ -131,7 +131,7 @@ set_nullable (void)
 
 
 void
-free_nullable (void)
+nullable_free (void)
 {
   XFREE (nullable + ntokens);
 }

diff --git a/src/nullable.h b/src/nullable.h
index a2d9b4b801c935b4312cfebd3b53495d8c252e02..af46c9c69a6ffaa30cb1fcef41ee5bc9a067ab4a 100644 (file)
--- a/src/nullable.h
+++ b/src/nullable.h
@@ -1,5 +1,5 @@
 /* Part of the bison parser generator,
-   Copyright 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -23,11 +23,11 @@
 
 /* A vector saying which nonterminals can expand into the null string.
    NULLABLE[I - NTOKENS] is nonzero if symbol I can do so.  */
-extern char *nullable;
+extern bool *nullable;
 
 /* Set up NULLABLE. */
-extern void set_nullable PARAMS((void));
+extern void nullable_compute PARAMS((void));
 
 /* Free NULLABLE. */
-extern void free_nullable PARAMS((void));
+extern void nullable_free PARAMS((void));
 #endif /* !NULLABLE_H_ */

diff --git a/src/state.c b/src/state.c
index 773071267335a3b1b319af60acf5194617f9bf70..eb244e28f043e4b23acfe6657f5f15ae24282b6e 100644 (file)
--- a/src/state.c
+++ b/src/state.c
@@ -223,7 +223,7 @@ state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out)
   /* Count the number of lookaheads corresponding to this rule.  */
   for (j = 0; j < state->nlookaheads; ++j)
     BITSET_FOR_EACH (biter, state->lookaheads[j], k, 0)
-      if (state->lookaheads_rule[j]->number == rule->number)
+      if (state->lookaheads_rule[j] == rule)
        nlookaheads++;
 
   /* Print them if there are.  */
@@ -232,7 +232,7 @@ state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out)
       fprintf (out, "  [");
       for (j = 0; j < state->nlookaheads; ++j)
        BITSET_FOR_EACH (biter, state->lookaheads[j], k, 0)
-         if (state->lookaheads_rule[j]->number == rule->number)
+         if (state->lookaheads_rule[j] == rule)
            fprintf (out, "%s%s",
                     symbols[k]->tag,
                     --nlookaheads ? ", " : "");