Stop storing rules from 1 to nrules + 1.

[bison.git] / src / nullable.c

diff --git a/src/nullable.c b/src/nullable.c
index 000b8b1be0a85c6df5f84254c2568c93749e789a..6a70fa572be96a66dd3aa90c4b8dc6374234408f 100644 (file)
--- a/src/nullable.c
+++ b/src/nullable.c
@@ -1,5 +1,5 @@
 /* Part of the bison parser generator,
 /* Part of the bison parser generator,

-   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.
 


@@ -25,12 +25,18 @@
 
 #include "system.h"
 #include "getargs.h"
 
 #include "system.h"
 #include "getargs.h"

-#include "reader.h"
-#include "types.h"
+#include "symtab.h"

 #include "gram.h"
 #include "reduce.h"
 #include "nullable.h"
 
 #include "gram.h"
 #include "reduce.h"
 #include "nullable.h"
 

+/* Linked list of rule numbers.  */
+typedef struct rule_list_s
+{
+  struct rule_list_s *next;
+  rule_number_t value;
+} rule_list_t;
+

 char *nullable = NULL;
 
 static void
 char *nullable = NULL;
 
 static void


@@ -39,26 +45,26 @@ nullable_print (FILE *out)
   int i;
   fputs ("NULLABLE\n", out);
   for (i = ntokens; i < nsyms; i++)
   int i;
   fputs ("NULLABLE\n", out);
   for (i = ntokens; i < nsyms; i++)

-    fprintf (out, "\t%s: %s\n", tags[i], nullable[i] ? "yes" : "no");
+    fprintf (out, "\t%s: %s\n", symbols[i]->tag, nullable[i] ? "yes" : "no");

   fputs ("\n\n", out);
 }
 
 void
 set_nullable (void)
 {
   fputs ("\n\n", out);
 }
 
 void
 set_nullable (void)
 {

-  int ruleno;
-  short *s1;
-  short *s2;
-  shorts *p;
+  rule_number_t ruleno;
+  symbol_number_t *s1;
+  symbol_number_t *s2;
+  rule_list_t *p;

 
 

-  short *squeue = XCALLOC (short, nvars);
-  short *rcount = XCALLOC (short, nrules + 1);
+  symbol_number_t *squeue = XCALLOC (symbol_number_t, nvars);
+  short *rcount = XCALLOC (short, nrules);

   /* RITEM contains all the rules, including useless productions.
      Hence we must allocate room for useless nonterminals too.  */
   /* RITEM contains all the rules, including useless productions.
      Hence we must allocate room for useless nonterminals too.  */

-  shorts **rsets = XCALLOC (shorts *, nvars) - ntokens;
+  rule_list_t **rsets = XCALLOC (rule_list_t *, nvars) - ntokens;

   /* This is said to be more elements than we actually use.
   /* This is said to be more elements than we actually use.

-     Supposedly nitems - nrules is enough.  But why take the risk?  */
-  shorts *relts = XCALLOC (shorts, nitems + nvars + 1);
+     Supposedly NRITEMS - NRULES is enough.  But why take the risk?  */
+  rule_list_t *relts = XCALLOC (rule_list_t, nritems + nvars + 1);

 
   if (trace_flag)
     fprintf (stderr, "Entering set_nullable\n");
 
   if (trace_flag)
     fprintf (stderr, "Entering set_nullable\n");


@@ -68,22 +74,23 @@ set_nullable (void)
   s1 = s2 = squeue;
   p = relts;
 
   s1 = s2 = squeue;
   p = relts;
 

-  for (ruleno = 1; ruleno < nrules + 1; ++ruleno)
-    if (rule_table[ruleno].useful)
+  for (ruleno = 0; ruleno < nrules; ++ruleno)
+    if (rules[ruleno].useful)

       {
       {

-       if (ritem[rule_table[ruleno].rhs] > 0)
+       rule_t *rule = &rules[ruleno];
+       if (rule->rhs[0] >= 0)

          {
            /* This rule has a non empty RHS. */
          {
            /* This rule has a non empty RHS. */

-           short *r;
+           item_number_t *r = NULL;

            int any_tokens = 0;
            int any_tokens = 0;

-           for (r = ritem + rule_table[ruleno].rhs; *r > 0; ++r)
+           for (r = rule->rhs; *r >= 0; ++r)

              if (ISTOKEN (*r))
                any_tokens = 1;
 
            /* This rule has only nonterminals: schedule it for the second
               pass.  */
            if (!any_tokens)
              if (ISTOKEN (*r))
                any_tokens = 1;
 
            /* This rule has only nonterminals: schedule it for the second
               pass.  */
            if (!any_tokens)

-             for (r = ritem + rule_table[ruleno].rhs; *r > 0; ++r)
+             for (r = rule->rhs; *r >= 0; ++r)

                {
                  rcount[ruleno]++;
                  p->next = rsets[*r];
                {
                  rcount[ruleno]++;
                  p->next = rsets[*r];


@@ -95,11 +102,11 @@ set_nullable (void)
        else
          {
            /* This rule has an empty RHS. */
        else
          {
            /* This rule has an empty RHS. */

-           assert (ritem[rule_table[ruleno].rhs] == -ruleno);
-           if (rule_table[ruleno].useful && !nullable[rule_table[ruleno].lhs])
+           assert (item_number_as_rule_number (rule->rhs[0]) == ruleno);
+           if (rule->useful && !nullable[rule->lhs->number])

              {
              {

-               nullable[rule_table[ruleno].lhs] = 1;
-               *s2++ = rule_table[ruleno].lhs;
+               nullable[rule->lhs->number] = 1;
+               *s2++ = rule->lhs->number;

              }
          }
       }
              }
          }
       }


@@ -109,10 +116,10 @@ set_nullable (void)
       {
        ruleno = p->value;
        if (--rcount[ruleno] == 0)
       {
        ruleno = p->value;
        if (--rcount[ruleno] == 0)

-         if (rule_table[ruleno].useful && !nullable[rule_table[ruleno].lhs])
+         if (rules[ruleno].useful && !nullable[rules[ruleno].lhs->number])

            {
            {

-             nullable[rule_table[ruleno].lhs] = 1;
-             *s2++ = rule_table[ruleno].lhs;
+             nullable[rules[ruleno].lhs->number] = 1;
+             *s2++ = rules[ruleno].lhs->number;

            }
       }
 
            }
       }