* doc/bison.texinfo (Debugging): Split into...

[bison.git] / src / closure.c

diff --git a/src/closure.c b/src/closure.c
index b20e98c0ac54620a62d2f0d55df1cf155d293584..928b686747127ab507e902a0cc754fdedbcd3d99 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -1,5 +1,5 @@
 /* Subroutines for bison
 /* Subroutines 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.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -19,24 +19,26 @@
    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 "getargs.h"
 #include "symtab.h"
 #include "gram.h"
 #include "reader.h"
 #include "closure.h"
 #include "derives.h"
 #include "getargs.h"
 #include "symtab.h"
 #include "gram.h"
 #include "reader.h"
 #include "closure.h"
 #include "derives.h"

-#include "bitset.h"
-#include "warshall.h"

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

-short *itemset;
-int nitemset;
+item_number_t *itemset;
+int nritemset;

 
 static bitset ruleset;
 
 /* internal data.  See comments before set_fderives and set_firsts.  */
 
 static bitset ruleset;
 
 /* internal data.  See comments before set_fderives and set_firsts.  */

-static bitset *fderives = NULL;
-static bitset *firsts = NULL;
+static bitsetv fderives = NULL;
+static bitsetv firsts = NULL;

 
 /* Retrieve the FDERIVES/FIRSTS sets of the nonterminals numbered Var.  */
 #define FDERIVES(Var)   fderives[(Var) - ntokens]
 
 /* Retrieve the FDERIVES/FIRSTS sets of the nonterminals numbered Var.  */
 #define FDERIVES(Var)   fderives[(Var) - ntokens]


@@ -48,16 +50,17 @@ static bitset *firsts = NULL;
 `-----------------*/
 
 static void
 `-----------------*/
 
 static void

-print_closure (const char *title, short *array, size_t size)
+print_closure (const char *title, item_number_t *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)
     {

-      short *rp;
+      item_number_t *rp;

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

-       fprintf (stderr, " %s", symbols[*rp]->tag);
+       fprintf (stderr, " %s",
+                quotearg_style (escape_quoting_style, symbols[*rp]->tag));

       fprintf (stderr, "  (rule %d)\n", -*rp - 1);
     }
   fputs ("\n\n", stderr);
       fprintf (stderr, "  (rule %d)\n", -*rp - 1);
     }
   fputs ("\n\n", stderr);


@@ -72,11 +75,13 @@ print_firsts (void)
   fprintf (stderr, "FIRSTS\n");
   for (i = ntokens; i < nsyms; i++)
     {
   fprintf (stderr, "FIRSTS\n");
   for (i = ntokens; i < nsyms; i++)
     {

-      fprintf (stderr, "\t%s firsts\n", symbols[i]->tag);
+      fprintf (stderr, "\t%s firsts\n",
+              quotearg_style (escape_quoting_style, symbols[i]->tag));

       for (j = 0; j < nvars; j++)
        if (bitset_test (FIRSTS (i), j))
       for (j = 0; j < nvars; j++)
        if (bitset_test (FIRSTS (i), j))

-         fprintf (stderr, "\t\t%d (%s)\n",
-                  j + ntokens, symbols[j + ntokens]->tag);
+         fprintf (stderr, "\t\t%s\n",
+                  quotearg_style (escape_quoting_style,
+                                  symbols[j + ntokens]->tag));

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


@@ -90,14 +95,17 @@ print_fderives (void)
   fprintf (stderr, "FDERIVES\n");
   for (i = ntokens; i < nsyms; i++)
     {
   fprintf (stderr, "FDERIVES\n");
   for (i = ntokens; i < nsyms; i++)
     {

-      fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
-      for (j = 0; j <= nrules; j++)
+      fprintf (stderr, "\t%s derives\n",
+              quotearg_style (escape_quoting_style, symbols[i]->tag));
+      for (j = 0; j < nrules + 1; j++)

        if (bitset_test (FDERIVES (i), j))
          {
        if (bitset_test (FDERIVES (i), j))
          {

-           short *rhsp;
+           item_number_t *rhsp;

            fprintf (stderr, "\t\t%d:", j - 1);
            fprintf (stderr, "\t\t%d:", j - 1);

-           for (rhsp = &ritem[rules[j].rhs]; *rhsp >= 0; ++rhsp)
-             fprintf (stderr, " %s", symbols[*rhsp]->tag);
+           for (rhsp = rules[j].rhs; *rhsp >= 0; ++rhsp)
+             fprintf (stderr, " %s",
+                      quotearg_style (escape_quoting_style,
+                                      symbols[*rhsp]->tag));

            fputc ('\n', stderr);
          }
     }
            fputc ('\n', stderr);
          }
     }


@@ -120,19 +128,21 @@ set_firsts (void)
 {
   int i, j;
 
 {
   int i, j;
 

-  firsts = XCALLOC (bitset, nvars);
+  firsts = bitsetv_create (nvars, nvars, BITSET_FIXED);
+

   for (i = ntokens; i < nsyms; i++)
   for (i = ntokens; i < nsyms; i++)

-    {
-      FIRSTS (i) = bitset_create (nvars, BITSET_FIXED);
-      for (j = 0; derives[i][j] >= 0; ++j)
-       {
-         int symbol = ritem[rules[derives[i][j]].rhs];
-         if (ISVAR (symbol))
-           bitset_set (FIRSTS (i), symbol - ntokens);
-       }
-    }
+    for (j = 0; derives[i][j] >= 0; ++j)
+      {
+       int symbol = rules[derives[i][j]].rhs[0];
+       if (ISVAR (symbol))
+         bitset_set (FIRSTS (i), symbol - ntokens);
+      }

 
 

-  RTC (firsts, nvars);
+  if (trace_flag)
+    bitsetv_matrix_dump (stderr, "RTC: Firsts Input", firsts);
+  bitsetv_reflexive_transitive_closure (firsts);
+  if (trace_flag)
+    bitsetv_matrix_dump (stderr, "RTC: Firsts Output", firsts);

 
   if (trace_flag)
     print_firsts ();
 
   if (trace_flag)
     print_firsts ();


@@ -153,10 +163,7 @@ set_fderives (void)
 {
   int i, j, k;
 
 {
   int i, j, k;
 

-  fderives = XCALLOC (bitset, nvars);
-  bitset_stats_init ();
-  for (i = 0 ; i < nvars; ++i)
-    fderives[i] = bitset_create (nrules + 1, BITSET_FIXED);
+  fderives = bitsetv_create (nvars, nrules + 1, BITSET_FIXED);

 
   set_firsts ();
 
 
   set_firsts ();
 


@@ -169,16 +176,15 @@ set_fderives (void)
   if (trace_flag)
     print_fderives ();
 
   if (trace_flag)
     print_fderives ();
 

-  for (i = ntokens; i < nsyms; ++i)
-    bitset_free (FIRSTS (i));
-  XFREE (firsts);
+  bitsetv_free (firsts);

 }
 }

+

 \f
 
 void
 new_closure (int n)
 {
 \f
 
 void
 new_closure (int n)
 {

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

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


@@ -188,70 +194,55 @@ new_closure (int n)
 
 
 void
 
 
 void

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

 {
   /* Index over CORE. */
   int c;
 
 {
   /* Index over CORE. */
   int c;
 

-  /* An index over RULESET. */
-  int r;
-

   /* A bit index over RULESET. */
   int ruleno;
 
   if (trace_flag)
     print_closure ("input", core, n);
 
   /* A bit index over RULESET. */
   int ruleno;
 
   if (trace_flag)
     print_closure ("input", core, n);
 

-  if (n == 0)
-    {
-      bitset_copy (ruleset, FDERIVES (start_symbol));
-    }
-  else
-    {
-      bitset_zero (ruleset);
+  bitset_zero (ruleset);

 
 

-      for (c = 0; c < n; ++c)
-       if (ISVAR (ritem[core[c]]))
-         bitset_or (ruleset, ruleset, FDERIVES (ritem[core[c]]));
-    }
+  for (c = 0; c < n; ++c)
+    if (ISVAR (ritem[core[c]]))
+      bitset_or (ruleset, ruleset, FDERIVES (ritem[core[c]]));

 
 

-  nitemset = 0;
+  nritemset = 0;

   c = 0;
   for (ruleno = 0; ruleno < nrules + 1; ++ruleno)
     if (bitset_test (ruleset, ruleno))
       {
   c = 0;
   for (ruleno = 0; ruleno < nrules + 1; ++ruleno)
     if (bitset_test (ruleset, ruleno))
       {

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

        while (c < n && core[c] < itemno)
          {
        while (c < n && core[c] < itemno)
          {

-           itemset[nitemset] = core[c];
-           nitemset++;
+           itemset[nritemset] = core[c];
+           nritemset++;

            c++;
          }
            c++;
          }

-       itemset[nitemset] = itemno;
-       nitemset++;
+       itemset[nritemset] = itemno;
+       nritemset++;

       }
 
   while (c < n)
     {
       }
 
   while (c < n)
     {

-      itemset[nitemset] = core[c];
-      nitemset++;
+      itemset[nritemset] = core[c];
+      nritemset++;

       c++;
     }
 
   if (trace_flag)
       c++;
     }
 
   if (trace_flag)

-    print_closure ("output", itemset, nitemset);
+    print_closure ("output", itemset, nritemset);

 }
 
 
 void
 free_closure (void)
 {
 }
 
 
 void
 free_closure (void)
 {

-  int i;

   XFREE (itemset);
   XFREE (itemset);

-

   bitset_free (ruleset);
   bitset_free (ruleset);

-
-  for (i = 0 ; i < nvars; ++i)
-    bitset_free (fderives[i]);
-  free (fderives);
+  bitsetv_free (fderives);

 }
 }