* src/symtab.h, src/symtab.c (symbol_t): destructor_location is a

[bison.git] / src / reduce.c

diff --git a/src/reduce.c b/src/reduce.c
index 8175f29f313c83212537c117f542546688d43c94..35aab2e725e69edb73c81d6a9c40bf2b739eee24 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -1,5 +1,5 @@
 /* Grammar reduction for Bison.
 /* Grammar reduction for Bison.

-   Copyright (C) 1988, 1989, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1988, 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.
 


@@ -26,65 +26,34 @@
    user's parser.  */
 
 #include "system.h"
    user's parser.  */
 
 #include "system.h"

+#include "quotearg.h"

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

+#include "symtab.h"

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

-#include "alloc.h"

 #include "complain.h"
 #include "reduce.h"
 #include "reader.h"
 #include "getargs.h"
 #include "complain.h"
 #include "reduce.h"
 #include "reader.h"
 #include "getargs.h"

+#include "bitset.h"

 
 

-typedef unsigned *BSet;
-typedef short *rule;
+/* Set of all nonterminals which are not useless.  */
+static bitset N;

 
 

+/* Set of all rules which have no useless nonterminals in their RHS.  */
+static bitset P;

 
 

-/* N is set of all nonterminals which are not useless.  P is set of
-   all rules which have no useless nonterminals in their RHS.  V is
-   the set of all accessible symbols.  */
+/* Set of all accessible symbols.  */
+static bitset V;

 
 

-static BSet N, P, V, V1;
+/* Set of symbols used to define rule precedence (so they are
+   `useless', but no warning should be issued).  */
+static bitset V1;

 
 static int nuseful_productions;
 
 static int nuseful_productions;

-static int nuseless_productions;
+int nuseless_productions;

 static int nuseful_nonterminals;
 static int nuseful_nonterminals;

-static int nuseless_nonterminals;
-\f
-static bool
-bits_equal (BSet L, BSet R, int n)
-{
-  int i;
-
-  for (i = n - 1; i >= 0; i--)
-    if (L[i] != R[i])
-      return FALSE;
-  return TRUE;
-}
-
-
-static int
-nbits (unsigned i)
-{
-  int count = 0;
-
-  while (i != 0)
-    {
-      i ^= (i & ((unsigned) (-(int) i)));
-      ++count;
-    }
-  return count;
-}
-
-
-static int
-bits_size (BSet S, int n)
-{
-  int i, count = 0;
-
-  for (i = n - 1; i >= 0; i--)
-    count += nbits (S[i]);
-  return count;
-}
+int nuseless_nonterminals;

 \f
 /*-------------------------------------------------------------------.
 | Another way to do this would be with a set for each production and |
 \f
 /*-------------------------------------------------------------------.
 | Another way to do this would be with a set for each production and |


@@ -93,18 +62,17 @@ bits_size (BSet S, int n)
 `-------------------------------------------------------------------*/
 
 static bool
 `-------------------------------------------------------------------*/
 
 static bool

-useful_production (int i, BSet N0)
+useful_production (int i, bitset N0)

 {
 {

-  rule r;
+  item_number_t *r;

   short n;
 
   /* A production is useful if all of the nonterminals in its appear
      in the set of useful nonterminals.  */
 
   short n;
 
   /* A production is useful if all of the nonterminals in its appear
      in the set of useful nonterminals.  */
 

-  for (r = &ritem[rrhs[i]]; *r > 0; r++)
-    if (ISVAR (n = *r))
-      if (!BITISSET (N0, n - ntokens))
-       return FALSE;
+  for (r = rules[i].rhs; *r >= 0; r++)
+    if (ISVAR (n = *r) && !bitset_test (N0, n - ntokens))
+      return FALSE;

   return TRUE;
 }
 
   return TRUE;
 }
 


@@ -116,13 +84,14 @@ useful_production (int i, BSet N0)
 static void
 useless_nonterminals (void)
 {
 static void
 useless_nonterminals (void)
 {

-  BSet Np, Ns;
-  int i, n;
+  bitset Np, Ns;
+  int i;

 
   /* N is set as built.  Np is set being built this iteration. P is
      set of all productions which have a RHS all in N.  */
 
 
   /* N is set as built.  Np is set being built this iteration. P is
      set of all productions which have a RHS all in N.  */
 

-  Np = NEW2 (WORDSIZE (nvars), unsigned);
+  Np = bitset_create (nvars, BITSET_FIXED);
+

 
   /* The set being computed is a set of nonterminals which can derive
      the empty string or strings consisting of all terminals. At each
 
   /* The set being computed is a set of nonterminals which can derive
      the empty string or strings consisting of all terminals. At each


@@ -140,29 +109,23 @@ useless_nonterminals (void)
      saved to be used when finding useful productions: only
      productions in this set will appear in the final grammar.  */
 
      saved to be used when finding useful productions: only
      productions in this set will appear in the final grammar.  */
 

-  n = 0;

   while (1)
     {
   while (1)
     {

-      for (i = WORDSIZE (nvars) - 1; i >= 0; i--)
-       Np[i] = N[i];
-      for (i = 1; i <= nrules; i++)
-       {
-         if (!BITISSET (P, i))
-           {
-             if (useful_production (i, N))
-               {
-                 SETBIT (Np, rlhs[i] - ntokens);
-                 SETBIT (P, i);
-               }
-           }
-       }
-      if (bits_equal (N, Np, WORDSIZE (nvars)))
+      bitset_copy (Np, N);
+      for (i = 1; i < nrules + 1; i++)
+       if (!bitset_test (P, i)
+           && useful_production (i, N))
+         {
+           bitset_set (Np, rules[i].lhs->number - ntokens);
+           bitset_set (P, i);
+         }
+      if (bitset_equal_p (N, Np))

        break;
       Ns = Np;
       Np = N;
       N = Ns;
     }
        break;
       Ns = Np;
       Np = N;
       N = Ns;
     }

-  FREE (N);
+  bitset_free (N);

   N = Np;
 }
 
   N = Np;
 }
 


@@ -170,10 +133,10 @@ useless_nonterminals (void)
 static void
 inaccessable_symbols (void)
 {
 static void
 inaccessable_symbols (void)
 {

-  BSet Vp, Vs, Pp;
-  int i, n;
+  bitset Vp, Vs, Pp;
+  int i;

   short t;
   short t;

-  rule r;
+  item_number_t *r;

 
   /* Find out which productions are reachable and which symbols are
      used.  Starting with an empty set of productions and a set of
 
   /* Find out which productions are reachable and which symbols are
      used.  Starting with an empty set of productions and a set of


@@ -198,310 +161,254 @@ inaccessable_symbols (void)
      terminals are printed (if running in verbose mode) so that the
      user can know.  */
 
      terminals are printed (if running in verbose mode) so that the
      user can know.  */
 

-  Vp = NEW2 (WORDSIZE (nsyms), unsigned);
-  Pp = NEW2 (WORDSIZE (nrules + 1), unsigned);
+  Vp = bitset_create (nsyms, BITSET_FIXED);
+  Pp = bitset_create (nrules + 1, BITSET_FIXED);

 
   /* If the start symbol isn't useful, then nothing will be useful. */
 
   /* If the start symbol isn't useful, then nothing will be useful. */

-  if (!BITISSET (N, start_symbol - ntokens))
-    goto end_iteration;
-
-  SETBIT (V, start_symbol);
-
-  n = 0;
-  while (1)
+  if (bitset_test (N, axiom->number - ntokens))

     {
     {

-      for (i = WORDSIZE (nsyms) - 1; i >= 0; i--)
-       Vp[i] = V[i];
-      for (i = 1; i <= nrules; i++)
+      bitset_set (V, axiom->number);
+
+      while (1)

        {
        {

-         if (!BITISSET (Pp, i) && BITISSET (P, i) && BITISSET (V, rlhs[i]))
+         bitset_copy (Vp, V);
+         for (i = 1; i < nrules + 1; i++)

            {
            {

-             for (r = &ritem[rrhs[i]]; *r >= 0; r++)
+             if (!bitset_test (Pp, i)
+                 && bitset_test (P, i)
+                 && bitset_test (V, rules[i].lhs->number))

                {
                {

-                 if (ISTOKEN (t = *r) || BITISSET (N, t - ntokens))
-                   {
-                     SETBIT (Vp, t);
-                   }
+                 for (r = rules[i].rhs; *r >= 0; r++)
+                   if (ISTOKEN (t = *r) || bitset_test (N, t - ntokens))
+                     bitset_set (Vp, t);
+                 bitset_set (Pp, i);

                }
                }

-             SETBIT (Pp, i);

            }
            }

+         if (bitset_equal_p (V, Vp))
+           break;
+         Vs = Vp;
+         Vp = V;
+         V = Vs;

        }
        }

-      if (bits_equal (V, Vp, WORDSIZE (nsyms)))
-       {
-         break;
-       }
-      Vs = Vp;
-      Vp = V;
-      V = Vs;

     }
     }

-end_iteration:

 
 

-  FREE (V);
+  bitset_free (V);

   V = Vp;
 
   /* Tokens 0, 1, and 2 are internal to Bison.  Consider them useful. */
   V = Vp;
 
   /* Tokens 0, 1, and 2 are internal to Bison.  Consider them useful. */

-  SETBIT (V, 0);               /* end-of-input token */
-  SETBIT (V, 1);               /* error token */
-  SETBIT (V, 2);               /* some undefined token */
+  bitset_set (V, eoftoken->number);            /* end-of-input token */
+  bitset_set (V, errtoken->number);            /* error token */
+  bitset_set (V, undeftoken->number);          /* some undefined token */

 
 

-  FREE (P);
+  bitset_free (P);

   P = Pp;
 
   P = Pp;
 

-  nuseful_productions = bits_size (P, WORDSIZE (nrules + 1));
+  nuseful_productions = bitset_count (P);

   nuseless_productions = nrules - nuseful_productions;
 
   nuseful_nonterminals = 0;
   for (i = ntokens; i < nsyms; i++)
   nuseless_productions = nrules - nuseful_productions;
 
   nuseful_nonterminals = 0;
   for (i = ntokens; i < nsyms; i++)

-    if (BITISSET (V, i))
+    if (bitset_test (V, i))

       nuseful_nonterminals++;
   nuseless_nonterminals = nvars - nuseful_nonterminals;
 
   /* A token that was used in %prec should not be warned about.  */
       nuseful_nonterminals++;
   nuseless_nonterminals = nvars - nuseful_nonterminals;
 
   /* A token that was used in %prec should not be warned about.  */

-  for (i = 1; i < nrules; i++)
-    if (rprecsym[i] != 0)
-      SETBIT (V1, rprecsym[i]);
+  for (i = 1; i < nrules + 1; i++)
+    if (rules[i].precsym != 0)
+      bitset_set (V1, rules[i].precsym->number);

 }
 
 }
 

+
+/*-------------------------------------------------------------------.
+| Put the useless productions at the end of RULES, and adjust NRULES |
+| accordingly.                                                       |
+`-------------------------------------------------------------------*/
+

 static void
 reduce_grammar_tables (void)
 {
 static void
 reduce_grammar_tables (void)
 {

-/* This is turned off because we would need to change the numbers
-   in the case statements in the actions file.  */
-#if 0
-  /* remove useless productions */
-  if (nuseless_productions > 0)
-    {
-      short np, pn, ni, pi;
-
-      np = 0;
-      ni = 0;
-      for (pn = 1; pn <= nrules; pn++)
-       {
-         if (BITISSET (P, pn))
-           {
-             np++;
-             if (pn != np)
-               {
-                 rlhs[np] = rlhs[pn];
-                 rline[np] = rline[pn];
-                 rprec[np] = rprec[pn];
-                 rassoc[np] = rassoc[pn];
-                 rrhs[np] = rrhs[pn];
-                 if (rrhs[np] != ni)
-                   {
-                     pi = rrhs[np];
-                     rrhs[np] = ni;
-                     while (ritem[pi] >= 0)
-                       ritem[ni++] = ritem[pi++];
-                     ritem[ni++] = -np;
-                   }
-               }
-             else
-               {
-                 while (ritem[ni++] >= 0);
-               }
-           }
-       }
-      ritem[ni] = 0;
-      nrules -= nuseless_productions;
-      nitems = ni;
-
-      /* Is it worth it to reduce the amount of memory for the
-         grammar? Probably not.  */
-
-    }
-#endif /* 0 */
-  /* Disable useless productions,
-     since they may contain useless nonterms
-     that would get mapped below to -1 and confuse everyone.  */
-  if (nuseless_productions > 0)
-    {
-      int pn;
-
-      for (pn = 1; pn <= nrules; pn++)
-       {
-         if (!BITISSET (P, pn))
-           {
-             rlhs[pn] = -1;
-           }
-       }
-    }
-
-  /* remove useless symbols */
-  if (nuseless_nonterminals > 0)
-    {
-
-      int i, n;
-/*      short  j; JF unused */
-      short *nontermmap;
-      rule r;
-
-      /* Create a map of nonterminal number to new nonterminal
-        number. -1 in the map means it was useless and is being
-        eliminated.  */
-
-      nontermmap = NEW2 (nvars, short) - ntokens;
-      for (i = ntokens; i < nsyms; i++)
-       nontermmap[i] = -1;
+  /* Report and flag useless productions.  */
+  {
+    int r;
+    for (r = 1; r < nrules + 1; r++)
+      {
+       rules[r].useful = bitset_test (P, r);
+       if (!rules[r].useful)
+         {
+           LOCATION_PRINT (stderr, rules[r].location);
+           fprintf (stderr, ": %s: %s: ", _("warning"), _("useless rule"));
+           rule_print (&rules[r], stderr);
+         }
+      }
+  }
+
+  /* Map the nonterminals to their new index: useful first, useless
+     afterwards.  Kept for later report.  */
+  {
+    int useful = 1;
+    int useless = nrules + 1 - nuseless_productions;
+    rule_t *rules_sorted = XMALLOC (rule_t, nrules + 1) - 1;
+    int i;
+    for (i = 1; i < nrules + 1; ++i)
+      rules_sorted[rules[i].useful ? useful++ : useless++] = rules[i];
+    free (rules + 1);
+    rules = rules_sorted;
+
+    /* Renumber the rules markers in RITEMS.  */
+    for (i = 1; i < nrules + 1; ++i)
+      {
+       item_number_t *rhsp = rules[i].rhs;
+       for (/* Nothing. */; *rhsp >= 0; ++rhsp)
+         /* Nothing. */;
+       *rhsp = -i;
+       rules[i].number = i;
+      }
+    nrules -= nuseless_productions;
+  }
+
+  /* Adjust NRITEMS.  */
+  {
+    int r;
+    int length;
+    for (r = nrules + 1; r < nrules + 1 + nuseless_productions; ++r)
+      {
+       length = rule_rhs_length (&rules[r]);
+       nritems -= length + 1;
+      }
+  }
+}

 
 

-      n = ntokens;
-      for (i = ntokens; i < nsyms; i++)
-       if (BITISSET (V, i))
-         nontermmap[i] = n++;

 
 

-      /* Shuffle elements of tables indexed by symbol number.  */
+/*------------------------------.
+| Remove useless nonterminals.  |
+`------------------------------*/

 
 

-      for (i = ntokens; i < nsyms; i++)
-       {
-         n = nontermmap[i];
-         if (n >= 0)
-           {
-             sassoc[n] = sassoc[i];
-             sprec[n] = sprec[i];
-             tags[n] = tags[i];
-           }
-         else
-           {
-             free (tags[i]);
-           }
-       }
-
-      /* Replace all symbol numbers in valid data structures.  */
-
-      for (i = 1; i <= nrules; i++)
-       {
-         /* Ignore the rules disabled above.  */
-         if (rlhs[i] >= 0)
-           rlhs[i] = nontermmap[rlhs[i]];
-         if (ISVAR (rprecsym[i]))
-           /* Can this happen?  */
-           rprecsym[i] = nontermmap[rprecsym[i]];
-       }
+static void
+nonterminals_reduce (void)
+{
+  symbol_number_t i, n;

 
 

-      for (r = ritem; *r; r++)
-       if (ISVAR (*r))
-         *r = nontermmap[*r];
+  /* Map the nonterminals to their new index: useful first, useless
+     afterwards.  Kept for later report.  */

 
 

-      start_symbol = nontermmap[start_symbol];
+  symbol_number_t *nontermmap = XCALLOC (symbol_number_t, nvars) - ntokens;
+  n = ntokens;
+  for (i = ntokens; i < nsyms; i++)
+    if (bitset_test (V, i))
+      nontermmap[i] = n++;
+  for (i = ntokens; i < nsyms; i++)
+    if (!bitset_test (V, i))
+      {
+       nontermmap[i] = n++;
+       LOCATION_PRINT (stderr, symbols[i]->location);
+       fprintf (stderr, ": %s: %s: %s\n",
+                _("warning"), _("useless nonterminal"),
+                symbol_tag_get (symbols[i]));
+      }
+
+
+  /* Shuffle elements of tables indexed by symbol number.  */
+  {
+    symbol_t **symbols_sorted = XMALLOC (symbol_t *, nvars) - ntokens;
+
+    for (i = ntokens; i < nsyms; i++)
+      symbols[i]->number = nontermmap[i];
+    for (i = ntokens; i < nsyms; i++)
+      symbols_sorted[nontermmap[i]] = symbols[i];
+    for (i = ntokens; i < nsyms; i++)
+      symbols[i] = symbols_sorted[i];
+    free (symbols_sorted + ntokens);
+  }
+
+  {
+    int r;
+    for (r = 1; r < nrules + 1; ++r)
+      {
+       item_number_t *rhsp;
+       for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
+         if (ISVAR (*rhsp))
+           *rhsp =  symbol_number_as_item_number (nontermmap[*rhsp]);
+      }
+    axiom->number = nontermmap[axiom->number];
+  }
+
+  nsyms -= nuseless_nonterminals;
+  nvars -= nuseless_nonterminals;
+
+  free (nontermmap + ntokens);
+}

 
 

-      nsyms -= nuseless_nonterminals;
-      nvars -= nuseless_nonterminals;

 
 

-      free (&nontermmap[ntokens]);
-    }
-}
+/*------------------------------------------------------------------.
+| Output the detailed results of the reductions.  For FILE.output.  |
+`------------------------------------------------------------------*/

 
 

-static void
-print_results (void)
+void
+reduce_output (FILE *out)

 {
 {

-  int i;
-/*  short j; JF unused */
-  rule r;
-  bool b;
-

   if (nuseless_nonterminals > 0)
     {
   if (nuseless_nonterminals > 0)
     {

-      fprintf (foutput, _("Useless nonterminals:\n\n"));
-      for (i = ntokens; i < nsyms; i++)
-       if (!BITISSET (V, i))
-         fprintf (foutput, "   %s\n", tags[i]);
+      int i;
+      fprintf (out, "%s\n\n", _("Useless nonterminals:"));
+      for (i = 0; i < nuseless_nonterminals; ++i)
+       fprintf (out, "   %s\n", symbol_tag_get (symbols[nsyms + i]));
+      fputs ("\n\n", out);

     }
     }

-  b = FALSE;
-  for (i = 0; i < ntokens; i++)
-    {
-      if (!BITISSET (V, i) && !BITISSET (V1, i))
+
+  {
+    bool b = FALSE;
+    int i;
+    for (i = 0; i < ntokens; i++)
+      if (!bitset_test (V, i) && !bitset_test (V1, i))

        {
          if (!b)
        {
          if (!b)

-           {
-             fprintf (foutput, _("\n\nTerminals which are not used:\n\n"));
-             b = TRUE;
-           }
-         fprintf (foutput, "   %s\n", tags[i]);
+           fprintf (out, "%s\n\n", _("Terminals which are not used:"));
+         b = TRUE;
+         fprintf (out, "   %s\n", symbol_tag_get (symbols[i]));

        }
        }

-    }
+    if (b)
+      fputs ("\n\n", out);
+  }

 
   if (nuseless_productions > 0)
 
   if (nuseless_productions > 0)

-    {
-      fprintf (foutput, _("\n\nUseless rules:\n\n"));
-      for (i = 1; i <= nrules; i++)
-       {
-         if (!BITISSET (P, i))
-           {
-             fprintf (foutput, "#%-4d  ", i);
-             fprintf (foutput, "%s :\t", tags[rlhs[i]]);
-             for (r = &ritem[rrhs[i]]; *r >= 0; r++)
-               {
-                 fprintf (foutput, " %s", tags[*r]);
-               }
-             fprintf (foutput, ";\n");
-           }
-       }
-    }
-  if (nuseless_nonterminals > 0 || nuseless_productions > 0 || b)
-    fprintf (foutput, "\n\n");
+    grammar_rules_partial_print (out, _("Useless rules"),
+                                nrules + 1,
+                                nuseless_productions + nrules + 1);

 }
 \f
 }
 \f

-#if 0                          /* XXX currently unused.  */
-static void
-dump_grammar (void)
-{
-  int i;
-  rule r;

 
 

-  fprintf (foutput,
-          "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d\n\n",
-          ntokens, nvars, nsyms, nrules, nitems);
-  fprintf (foutput, _("Variables\n---------\n\n"));
-  fprintf (foutput, _("Value  Sprec    Sassoc    Tag\n"));
-  for (i = ntokens; i < nsyms; i++)
-    fprintf (foutput, "%5d  %5d  %5d  %s\n", i, sprec[i], sassoc[i], tags[i]);
-  fprintf (foutput, "\n\n");
-  fprintf (foutput, _("Rules\n-----\n\n"));
-  for (i = 1; i <= nrules; i++)
-    {
-      fprintf (foutput, "%-5d(%5d%5d)%5d : (@%-5d)",
-              i, rprec[i], rassoc[i], rlhs[i], rrhs[i]);
-      for (r = &ritem[rrhs[i]]; *r > 0; r++)
-       fprintf (foutput, "%5d", *r);
-      fprintf (foutput, " [%d]\n", -(*r));
-    }
-  fprintf (foutput, "\n\n");
-  fprintf (foutput, _("Rules interpreted\n-----------------\n\n"));
-  for (i = 1; i <= nrules; i++)
-    {
-      fprintf (foutput, "%-5d  %s :", i, tags[rlhs[i]]);
-      for (r = &ritem[rrhs[i]]; *r > 0; r++)
-       fprintf (foutput, " %s", tags[*r]);
-      fprintf (foutput, "\n");
-    }
-  fprintf (foutput, "\n\n");
-}

 
 

-#endif

 
 
 
 

+/*-------------------------------.
+| Report the results to STDERR.  |
+`-------------------------------*/
+

 static void
 static void

-print_notices (void)
+reduce_print (void)

 {
 {

-  if (fixed_outfiles && nuseless_productions)
-    fprintf (stderr, _("%d rules never reduced\n"), nuseless_productions);
+  if (yacc_flag && nuseless_productions)
+    fprintf (stderr, ngettext ("%d rule never reduced\n",
+                              "%d rules never reduced\n",
+                              nuseless_productions),
+            nuseless_productions);

 
 

-  fprintf (stderr, _("%s contains "), infile);
+  fprintf (stderr, "%s: %s: ", infile, _("warning"));

 
   if (nuseless_nonterminals > 0)
 
   if (nuseless_nonterminals > 0)

-    {
-      fprintf (stderr, _("%d useless nonterminal%s"),
-              nuseless_nonterminals,
-              (nuseless_nonterminals == 1 ? "" : "s"));
-    }
+    fprintf (stderr, ngettext ("%d useless nonterminal",
+                              "%d useless nonterminals",
+                              nuseless_nonterminals),
+            nuseless_nonterminals);
+

   if (nuseless_nonterminals > 0 && nuseless_productions > 0)
     fprintf (stderr, _(" and "));
 
   if (nuseless_productions > 0)
   if (nuseless_nonterminals > 0 && nuseless_productions > 0)
     fprintf (stderr, _(" and "));
 
   if (nuseless_productions > 0)

-    {
-      fprintf (stderr, _("%d useless rule%s"),
-              nuseless_productions, (nuseless_productions == 1 ? "" : "s"));
-    }
+    fprintf (stderr, ngettext ("%d useless rule",
+                              "%d useless rules",
+                              nuseless_productions),
+            nuseless_productions);

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


@@ -513,52 +420,52 @@ reduce_grammar (void)
 
   /* Allocate the global sets used to compute the reduced grammar */
 
 
   /* Allocate the global sets used to compute the reduced grammar */
 

-  N = NEW2 (WORDSIZE (nvars), unsigned);
-  P = NEW2 (WORDSIZE (nrules + 1), unsigned);
-  V = NEW2 (WORDSIZE (nsyms), unsigned);
-  V1 = NEW2 (WORDSIZE (nsyms), unsigned);
+  N = bitset_create (nvars, BITSET_FIXED);
+  P =  bitset_create (nrules + 1, BITSET_FIXED);
+  V = bitset_create (nsyms, BITSET_FIXED);
+  V1 = bitset_create (nsyms, BITSET_FIXED);

 
   useless_nonterminals ();
   inaccessable_symbols ();
 
   reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0);
 
   useless_nonterminals ();
   inaccessable_symbols ();
 
   reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0);

+  if (!reduced)
+    return;

 
 

-  if (verboseflag)
-    print_results ();
+  reduce_print ();

 
 

-  if (reduced == FALSE)
-    goto done_reducing;
-
-  print_notices ();
-
-  if (!BITISSET (N, start_symbol - ntokens))
+  if (!bitset_test (N, axiom->number - ntokens))

     fatal (_("Start symbol %s does not derive any sentence"),
     fatal (_("Start symbol %s does not derive any sentence"),

-          tags[start_symbol]);
+          symbol_tag_get (symbols[axiom->number]));
+
+  /* First reduce the nonterminals, as they renumber themselves in the
+     whole grammar.  If you change the order, nonterms would be
+     renumbered only in the reduced grammar.  */
+  if (nuseless_nonterminals > 0)
+    nonterminals_reduce ();
+  if (nuseless_productions > 0)
+    reduce_grammar_tables ();

 
 

-  reduce_grammar_tables ();
-#if 0
-  if (verboseflag)
+  if (trace_flag)

     {
     {

-      fprintf (foutput, "REDUCED GRAMMAR\n\n");
-      dump_grammar ();
+      grammar_dump (stderr, "Reduced Grammar");
+
+      fprintf (stderr, "reduced %s defines %d terminals, %d nonterminals\
+, and %d productions.\n",
+              infile, ntokens, nvars, nrules);

     }
     }

-#endif
-
-  if (statisticsflag)
-    fprintf (stderr, _("reduced %s defines %d terminal%s, %d nonterminal%s\
-, and %d production%s.\n"),
-            infile,
-            ntokens,
-            (ntokens == 1 ? "" : "s"),
-            nvars,
-            (nvars == 1 ? "" : "s"),
-            nrules,
-            (nrules == 1 ? "" : "s"));
-
-done_reducing:
-  /* Free the global sets used to compute the reduced grammar */
-
-  FREE (N);
-  FREE (V);
-  FREE (P);
+}
+
+
+/*-----------------------------------------------------------.
+| Free the global sets used to compute the reduced grammar.  |
+`-----------------------------------------------------------*/
+
+void
+reduce_free (void)
+{
+  bitset_free (N);
+  bitset_free (V);
+  bitset_free (V1);
+  bitset_free (P);

 }
 }