In GLR grammars, $N and @N now yield non-modifiable lvalues.

[bison.git] / src / closure.c

diff --git a/src/closure.c b/src/closure.c
index da9d4db3c71f5277d9b45675a2a6587d37701551..228056f7bb46c501b4212607cc73494e116a965d 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,22 @@
    02111-1307, USA.  */
 
 #include "system.h"
    02111-1307, USA.  */
 
 #include "system.h"

-#include "bitset.h"
-#include "bitsetv.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 "warshall.h"
+#include "symtab.h"

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

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

 
 static bitset ruleset;
 
 
 static bitset ruleset;
 


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

-print_closure (const char *title, short *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)
     {

-      short *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);


@@ -68,16 +72,18 @@ print_closure (const char *title, short *array, size_t size)
 static void
 print_firsts (void)
 {
 static void
 print_firsts (void)
 {

-  int 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++)
     {

+      bitset_iterator iter;

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

-      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);
+      BITSET_FOR_EACH (iter, FIRSTS (i), j, 0)
+       {
+         fprintf (stderr, "\t\t%s\n",
+                  symbols[j + ntokens]->tag);
+       }

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


@@ -86,21 +92,19 @@ print_firsts (void)
 static void
 print_fderives (void)
 {
 static void
 print_fderives (void)
 {

-  int i, j;
+  int i;
+  rule_number r;

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

+      bitset_iterator iter;

       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);

-      for (j = 0; j <= nrules; j++)
-       if (bitset_test (FDERIVES (i), j))
-         {
-           short *rhsp;
-           fprintf (stderr, "\t\t%d:", j - 1);
-           for (rhsp = &ritem[rules[j].rhs]; *rhsp >= 0; ++rhsp)
-             fprintf (stderr, " %s", symbols[*rhsp]->tag);
-           fputc ('\n', stderr);
-         }
+      BITSET_FOR_EACH (iter, FDERIVES (i), r, 0)
+       {
+         fprintf (stderr, "\t\t%3d ", r);
+         rule_rhs_print (&rules[r], stderr);
+       }

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


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

-  int 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 - ntokens][j]; ++j)

       {
       {

-       int symbol = ritem[rules[derives[i][j]].rhs];
-       if (ISVAR (symbol))
-         bitset_set (FIRSTS (i), symbol - ntokens);
+       item_number sym = derives[i - ntokens][j]->rhs[0];
+       if (ISVAR (sym))
+         bitset_set (FIRSTS (i), sym - ntokens);

       }
 
       }
 

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

 
 

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

     print_firsts ();
 }
 
     print_firsts ();
 }
 


@@ -150,31 +158,33 @@ set_firsts (void)
 static void
 set_fderives (void)
 {
 static void
 set_fderives (void)
 {

-  int i, j, 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 - ntokens][k]; ++k)
+         bitset_set (FDERIVES (i), derives[j - ntokens][k]->number);

 
 

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

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

+

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

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

 
 

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

 
   set_fderives ();
 }
 
   set_fderives ();
 }


@@ -182,58 +192,49 @@ new_closure (int n)
 
 
 void
 
 
 void

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

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

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

   /* A bit index over RULESET. */
   /* A bit index over RULESET. */

-  int ruleno;
+  rule_number ruleno;
+
+  bitset_iterator iter;

 
 

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

     print_closure ("input", core, n);
 
     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;
   c = 0;

-  for (ruleno = 0; ruleno < nrules + 1; ++ruleno)
-    if (bitset_test (ruleset, ruleno))
-      {
-       int itemno = rules[ruleno].rhs;
-       while (c < n && core[c] < itemno)
-         {
-           itemset[nitemset] = core[c];
-           nitemset++;
-           c++;
-         }
-       itemset[nitemset] = itemno;
-       nitemset++;
-      }
+  BITSET_FOR_EACH (iter, ruleset, ruleno, 0)
+    {
+      item_number itemno = rules[ruleno].rhs - ritem;
+      while (c < n && core[c] < itemno)
+       {
+         itemset[nritemset] = core[c];
+         nritemset++;
+         c++;
+       }
+      itemset[nritemset] = itemno;
+      nritemset++;
+    };

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

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

       c++;
     }
 
       c++;
     }
 

-  if (trace_flag)
-    print_closure ("output", itemset, nitemset);
+  if (trace_flag & trace_sets)
+    print_closure ("output", itemset, nritemset);

 }
 
 
 }