]> git.saurik.com Git - bison.git/blobdiff - src/nullable.c
* src/reduce.c: Various comment/formatting changes.
[bison.git] / src / nullable.c
index 8733bc028c555781053a20774ecce087a7c68b23..c207924dc8328a9770263d2313451c8e38b66748 100644 (file)
@@ -1,5 +1,5 @@
 /* Part of the bison parser generator,
 /* Part of the bison parser generator,
-   Copyright (C) 1984, 1989, 2000 Free Software Foundation, Inc.
+   Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 
    do so.  */
 
 #include "system.h"
    do so.  */
 
 #include "system.h"
+#include "getargs.h"
+#include "reader.h"
 #include "types.h"
 #include "gram.h"
 #include "types.h"
 #include "gram.h"
-#include "alloc.h"
 #include "nullable.h"
 
 char *nullable = NULL;
 
 #include "nullable.h"
 
 char *nullable = NULL;
 
+static void
+nullable_print (FILE *out)
+{
+  int i;
+  fputs ("NULLABLE\n", out);
+  for (i = ntokens; i < nsyms; i++)
+    fprintf (out, "\t%s: %s\n", tags[i], nullable[i] ? "yes" : "no");
+  fputs ("\n\n", out);
+}
+
 void
 set_nullable (void)
 {
   short *r;
   short *s1;
   short *s2;
 void
 set_nullable (void)
 {
   short *r;
   short *s1;
   short *s2;
-  int ruleno;
-  int symbol;
   shorts *p;
 
   short *squeue;
   short *rcount;
   shorts **rsets;
   shorts *relts;
   shorts *p;
 
   short *squeue;
   short *rcount;
   shorts **rsets;
   shorts *relts;
-  char any_tokens;
-  short *r1;
 
 
-#ifdef TRACE
-  fprintf (stderr, _("Entering set_nullable"));
-#endif
+  if (trace_flag)
+    fprintf (stderr, "Entering set_nullable\n");
 
 
-  nullable = NEW2 (nvars, char) - ntokens;
+  nullable = XCALLOC (char, nvars) - ntokens;
 
 
-  squeue = NEW2 (nvars, short);
+  squeue = XCALLOC (short, nvars);
   s1 = s2 = squeue;
 
   s1 = s2 = squeue;
 
-  rcount = NEW2 (nrules + 1, short);
-  rsets = NEW2 (nvars, shorts *) - ntokens;
+  rcount = XCALLOC (short, nrules + 1);
+  rsets = XCALLOC (shorts *, nvars) - ntokens;
   /* This is said to be more elements than we actually use.
      Supposedly nitems - nrules is enough.
      But why take the risk?  */
   /* This is said to be more elements than we actually use.
      Supposedly nitems - nrules is enough.
      But why take the risk?  */
-  relts = NEW2 (nitems + nvars + 1, shorts);
+  relts = XCALLOC (shorts, nitems + nvars + 1);
   p = relts;
 
   r = ritem;
   p = relts;
 
   r = ritem;
@@ -70,7 +76,7 @@ set_nullable (void)
     {
       if (*r < 0)
        {
     {
       if (*r < 0)
        {
-         symbol = rlhs[-(*r++)];
+         int symbol = rule_table[-(*r++)].lhs;
          if (symbol >= 0 && !nullable[symbol])
            {
              nullable[symbol] = 1;
          if (symbol >= 0 && !nullable[symbol])
            {
              nullable[symbol] = 1;
@@ -79,17 +85,16 @@ set_nullable (void)
        }
       else
        {
        }
       else
        {
-         r1 = r;
-         any_tokens = 0;
+         int any_tokens = 0;
+         int symbol;
+         short *r1 = r;
          for (symbol = *r++; symbol > 0; symbol = *r++)
          for (symbol = *r++; symbol > 0; symbol = *r++)
-           {
-             if (ISTOKEN (symbol))
-               any_tokens = 1;
-           }
+           if (ISTOKEN (symbol))
+             any_tokens = 1;
 
          if (!any_tokens)
            {
 
          if (!any_tokens)
            {
-             ruleno = -symbol;
+             int ruleno = -symbol;
              r = r1;
              for (symbol = *r++; symbol > 0; symbol = *r++)
                {
              r = r1;
              for (symbol = *r++; symbol > 0; symbol = *r++)
                {
@@ -108,11 +113,11 @@ set_nullable (void)
       p = rsets[*s1++];
       while (p)
        {
       p = rsets[*s1++];
       while (p)
        {
-         ruleno = p->value;
+         int ruleno = p->value;
          p = p->next;
          if (--rcount[ruleno] == 0)
            {
          p = p->next;
          if (--rcount[ruleno] == 0)
            {
-             symbol = rlhs[ruleno];
+             int symbol = rule_table[ruleno].lhs;
              if (symbol >= 0 && !nullable[symbol])
                {
                  nullable[symbol] = 1;
              if (symbol >= 0 && !nullable[symbol])
                {
                  nullable[symbol] = 1;
@@ -122,15 +127,18 @@ set_nullable (void)
        }
     }
 
        }
     }
 
-  FREE (squeue);
-  FREE (rcount);
-  FREE (rsets + ntokens);
-  FREE (relts);
+  XFREE (squeue);
+  XFREE (rcount);
+  XFREE (rsets + ntokens);
+  XFREE (relts);
+
+  if (trace_flag)
+    nullable_print (stderr);
 }
 
 
 void
 free_nullable (void)
 {
 }
 
 
 void
 free_nullable (void)
 {
-  FREE (nullable + ntokens);
+  XFREE (nullable + ntokens);
 }
 }