Adjust to type name changes.

[bison.git] / src / closure.c

diff --git a/src/closure.c b/src/closure.c
index 02d275a7bb0d8d83aa7bc6cab7084160d04a26b4..618846dc8d40b92a233256b72bc76aebae7a5a13 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -1,4 +1,5 @@
-/* Subroutines for bison
+/* Closures for Bison
+

    Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -19,19 +20,21 @@
    02111-1307, USA.  */
 
 #include "system.h"
    02111-1307, USA.  */
 
 #include "system.h"

-#include "quotearg.h"
-#include "bitset.h"
-#include "bitsetv.h"
-#include "bitsetv-print.h"
+
+#include <bitset.h>
+#include <bitsetv-print.h>
+#include <bitsetv.h>
+#include <quotearg.h>
+
+#include "closure.h"
+#include "derives.h"

 #include "getargs.h"
 #include "getargs.h"

-#include "symtab.h"

 #include "gram.h"
 #include "reader.h"
 #include "gram.h"
 #include "reader.h"

-#include "closure.h"
-#include "derives.h"
+#include "symtab.h"

 
 /* NITEMSET is the size of the array ITEMSET.  */
 
 /* NITEMSET is the size of the array ITEMSET.  */

-item_number_t *itemset;
+item_number *itemset;

 int nritemset;
 
 static bitset ruleset;
 int nritemset;
 
 static bitset ruleset;


@@ -50,13 +53,13 @@ static bitsetv firsts = NULL;
 `-----------------*/
 
 static void
 `-----------------*/
 
 static void

-print_closure (const char *title, item_number_t *array, size_t size)
+print_closure (char const *title, item_number *array, size_t size)

 {
   size_t i;
   fprintf (stderr, "Closure: %s\n", title);
   for (i = 0; i < size; ++i)
     {
 {
   size_t i;
   fprintf (stderr, "Closure: %s\n", title);
   for (i = 0; i < size; ++i)
     {

-      item_number_t *rp;
+      item_number *rp;

       fprintf (stderr, "  %2d: .", array[i]);
       for (rp = &ritem[array[i]]; *rp >= 0; ++rp)
        fprintf (stderr, " %s", symbols[*rp]->tag);
       fprintf (stderr, "  %2d: .", array[i]);
       for (rp = &ritem[array[i]]; *rp >= 0; ++rp)
        fprintf (stderr, " %s", symbols[*rp]->tag);


@@ -69,7 +72,7 @@ print_closure (const char *title, item_number_t *array, size_t size)
 static void
 print_firsts (void)
 {
 static void
 print_firsts (void)
 {

-  symbol_number_t i, j;
+  symbol_number i, j;

 
   fprintf (stderr, "FIRSTS\n");
   for (i = ntokens; i < nsyms; i++)
 
   fprintf (stderr, "FIRSTS\n");
   for (i = ntokens; i < nsyms; i++)


@@ -90,7 +93,7 @@ static void
 print_fderives (void)
 {
   int i;
 print_fderives (void)
 {
   int i;

-  rule_number_t r;
+  rule_number r;

 
   fprintf (stderr, "FDERIVES\n");
   for (i = ntokens; i < nsyms; i++)
 
   fprintf (stderr, "FDERIVES\n");
   for (i = ntokens; i < nsyms; i++)


@@ -99,11 +102,8 @@ print_fderives (void)
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
       BITSET_FOR_EACH (iter, FDERIVES (i), r, 0)
        {
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
       BITSET_FOR_EACH (iter, FDERIVES (i), r, 0)
        {

-         item_number_t *rhsp = NULL;
-         fprintf (stderr, "\t\t%d:", r - 1);
-         for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
-           fprintf (stderr, " %s", symbols[*rhsp]->tag);
-         fputc ('\n', stderr);
+         fprintf (stderr, "\t\t%3d ", r);
+         rule_rhs_print (&rules[r], stderr);

        }
     }
   fprintf (stderr, "\n\n");
        }
     }
   fprintf (stderr, "\n\n");


@@ -123,25 +123,25 @@ print_fderives (void)
 static void
 set_firsts (void)
 {
 static void
 set_firsts (void)
 {

-  symbol_number_t i, j;
+  symbol_number i, j;

 
   firsts = bitsetv_create (nvars, nvars, BITSET_FIXED);
 
   for (i = ntokens; i < nsyms; i++)
 
   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];
-       if (ISVAR (symbol))
-         bitset_set (FIRSTS (i), symbol - ntokens);
+       item_number sym = derives[i][j]->rhs[0];
+       if (ISVAR (sym))
+         bitset_set (FIRSTS (i), sym - ntokens);

       }
 
       }
 

-  if (trace_flag)
+  if (trace_flag & trace_sets)

     bitsetv_matrix_dump (stderr, "RTC: Firsts Input", firsts);
   bitsetv_reflexive_transitive_closure (firsts);
     bitsetv_matrix_dump (stderr, "RTC: Firsts Input", firsts);
   bitsetv_reflexive_transitive_closure (firsts);

-  if (trace_flag)
+  if (trace_flag & trace_sets)

     bitsetv_matrix_dump (stderr, "RTC: Firsts Output", firsts);
 
     bitsetv_matrix_dump (stderr, "RTC: Firsts Output", firsts);
 

-  if (trace_flag)
+  if (trace_flag & trace_sets)

     print_firsts ();
 }
 
     print_firsts ();
 }
 


@@ -158,20 +158,20 @@ set_firsts (void)
 static void
 set_fderives (void)
 {
 static void
 set_fderives (void)
 {

-  symbol_number_t i, j;
-  rule_number_t k;
+  symbol_number i, j;
+  rule_number k;

 
 

-  fderives = bitsetv_create (nvars, nrules + 1, BITSET_FIXED);
+  fderives = bitsetv_create (nvars, nrules, BITSET_FIXED);

 
   set_firsts ();
 
   for (i = ntokens; i < nsyms; ++i)
     for (j = ntokens; j < nsyms; ++j)
       if (bitset_test (FIRSTS (i), j - ntokens))
 
   set_firsts ();
 
   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)
+  if (trace_flag & trace_sets)

     print_fderives ();
 
   bitsetv_free (firsts);
     print_fderives ();
 
   bitsetv_free (firsts);


@@ -182,9 +182,9 @@ set_fderives (void)
 void
 new_closure (int n)
 {
 void
 new_closure (int n)
 {

-  itemset = XCALLOC (item_number_t, n);
+  itemset = XCALLOC (item_number, n);

 
 

-  ruleset = bitset_create (nrules + 1, BITSET_FIXED);
+  ruleset = bitset_create (nrules, BITSET_FIXED);

 
   set_fderives ();
 }
 
   set_fderives ();
 }


@@ -192,17 +192,17 @@ new_closure (int n)
 
 
 void
 
 
 void

-closure (item_number_t *core, int n)
+closure (item_number *core, int n)

 {
   /* Index over CORE. */
   int c;
 
   /* A bit index over RULESET. */
 {
   /* Index over CORE. */
   int c;
 
   /* A bit index over RULESET. */

-  rule_number_t ruleno;
+  rule_number ruleno;

 
   bitset_iterator iter;
 
 
   bitset_iterator iter;
 

-  if (trace_flag)
+  if (trace_flag & trace_sets)

     print_closure ("input", core, n);
 
   bitset_zero (ruleset);
     print_closure ("input", core, n);
 
   bitset_zero (ruleset);


@@ -215,7 +215,7 @@ closure (item_number_t *core, int n)
   c = 0;
   BITSET_FOR_EACH (iter, ruleset, ruleno, 0)
     {
   c = 0;
   BITSET_FOR_EACH (iter, ruleset, ruleno, 0)
     {

-      item_number_t itemno = rules[ruleno].rhs - ritem;
+      item_number itemno = rules[ruleno].rhs - ritem;

       while (c < n && core[c] < itemno)
        {
          itemset[nritemset] = core[c];
       while (c < n && core[c] < itemno)
        {
          itemset[nritemset] = core[c];


@@ -233,7 +233,7 @@ closure (item_number_t *core, int n)
       c++;
     }
 
       c++;
     }
 

-  if (trace_flag)
+  if (trace_flag & trace_sets)

     print_closure ("output", itemset, nritemset);
 }
 
     print_closure ("output", itemset, nritemset);
 }