* src/system.h: No longer using strndup.

[bison.git] / src / reduce.c

diff --git a/src/reduce.c b/src/reduce.c
index 001b9109308a86fb232db40976b039c224fce6d7..256817505722905f706b36c7ae396237443168bd 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,37 @@
    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 "xalloc.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;
 
 
 typedef short *rule;
 
 

-/* 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 nonterminals which are not useless.  */
+static bitset N;

 
 

-static BSet N, P, V, V1;
+/* Set of all rules which have no useless nonterminals in their RHS.  */
+static bitset P;
+
+/* Set of all accessible symbols.  */
+static bitset V;
+
+/* 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 nuseless_productions;
 static int nuseful_nonterminals;
 
 static int nuseful_productions;
 static int nuseless_productions;
 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,7 +65,7 @@ bits_size (BSet S, int n)
 `-------------------------------------------------------------------*/
 
 static bool
 `-------------------------------------------------------------------*/
 
 static bool

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

 {
   rule r;
   short n;
 {
   rule r;
   short n;


@@ -101,10 +73,9 @@ useful_production (int i, BSet N0)
   /* A production is useful if all of the nonterminals in its appear
      in the set of useful nonterminals.  */
 
   /* 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 +87,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 = XCALLOC (unsigned, WORDSIZE (nvars));
+  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 +112,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;
     }

-  XFREE (N);
+  bitset_free (N);

   N = Np;
 }
 
   N = Np;
 }
 


@@ -170,8 +136,8 @@ 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;
   rule r;
 
   short t;
   rule r;
 


@@ -198,310 +164,300 @@ 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 = XCALLOC (unsigned, WORDSIZE (nsyms));
-  Pp = XCALLOC (unsigned, WORDSIZE (nrules + 1));
+  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, start_symbol - ntokens))

     {
     {

-      for (i = WORDSIZE (nsyms) - 1; i >= 0; i--)
-       Vp[i] = V[i];
-      for (i = 1; i <= nrules; i++)
+      bitset_set (V, start_symbol);
+
+      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:

 
 

-  XFREE (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 */

 
 

-  XFREE (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;
+  /* Flag useless productions.  */
+  {
+    int pn;
+    for (pn = 1; pn < nrules + 1; pn++)
+      rules[pn].useful = bitset_test (P, pn);
+  }
+
+  /* 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)
+      {
+       short *rhsp = rules[i].rhs;
+       for (/* Nothing. */; *rhsp >= 0; ++rhsp)
+         /* Nothing. */;
+       *rhsp = -i;
+       rules[i].number = i;
+      }
+    nrules -= nuseless_productions;
+  }
+
+  /* Adjust NRITEMS and NITEMS.  */
+  {
+    int r;
+    int length;
+    for (r = nrules + 1; r < nrules + 1 + nuseless_productions; ++r)
+      {
+       length = rule_rhs_length (&rules[r]);
+       nritems -= length + 1;
+      }
+  }
+}

 
 

-      for (pn = 1; pn <= nrules; pn++)
-       {
-         if (!BITISSET (P, pn))
-           {
-             rlhs[pn] = -1;
-           }
-       }
-    }

 
 

-  /* remove useless symbols */
-  if (nuseless_nonterminals > 0)
-    {
+/*------------------------------.
+| Remove useless nonterminals.  |
+`------------------------------*/

 
 

-      int i, n;
-/*      short  j; JF unused */
-      short *nontermmap;
-      rule r;
+static void
+nonterminals_reduce (void)
+{
+  int i, n;

 
 

-      /* Create a map of nonterminal number to new nonterminal
-        number. -1 in the map means it was useless and is being
-        eliminated.  */
+  /* Map the nonterminals to their new index: useful first, useless
+     afterwards.  Kept for later report.  */

 
 

-      nontermmap = XCALLOC (short, nvars) - ntokens;
-      for (i = ntokens; i < nsyms; i++)
-       nontermmap[i] = -1;
+  short *nontermmap = XCALLOC (short, 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++;

 
 

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

 
 

-      /* Shuffle elements of tables indexed by symbol number.  */
+  /* Shuffle elements of tables indexed by symbol number.  */
+  {
+    symbol_t **symbols_sorted = XMALLOC (symbol_t *, nvars) - ntokens;

 
 

-      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]);
-           }
-       }
+    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);
+  }

 
 

-      /* Replace all symbol numbers in valid data structures.  */
+  for (i = 0; i < nritems; ++i)
+    if (ISVAR (ritem[i]))
+      ritem[i] = nontermmap[ritem[i]];

 
 

-      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]];
-       }
+  start_symbol = nontermmap[start_symbol];

 
 

-      for (r = ritem; *r; r++)
-       if (ISVAR (*r))
-         *r = nontermmap[*r];
+  nsyms -= nuseless_nonterminals;
+  nvars -= nuseless_nonterminals;

 
 

-      start_symbol = nontermmap[start_symbol];
+  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", quotearg_style (escape_quoting_style,
+                                                symbols[nsyms + i]->tag));
+      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", quotearg_style (escape_quoting_style,
+                                                  symbols[i]->tag));

        }
        }

-    }
+    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++)
+      int i;
+      fprintf (out, "%s\n\n", _("Useless rules:"));
+      for (i = nrules + 1; i < nuseless_productions + nrules + 1; 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");
-           }
+         rule r;
+         fprintf (out, "#%-4d  ", rules[i].user_number - 1);
+         fprintf (out, "%s:", quotearg_style (escape_quoting_style,
+                                              rules[i].lhs->tag));
+         for (r = rules[i].rhs; *r >= 0; r++)
+           fprintf (out, " %s", quotearg_style (escape_quoting_style,
+                                                symbols[*r]->tag));
+         fputs (";\n", out);

        }
        }

+      fputs ("\n\n", out);

     }
     }

-  if (nuseless_nonterminals > 0 || nuseless_productions > 0 || b)
-    fprintf (foutput, "\n\n");

 }
 \f
 }
 \f

-#if 0                          /* XXX currently unused.  */

 static void
 static void

-dump_grammar (void)
+dump_grammar (FILE *out)

 {
   int i;
   rule r;
 
 {
   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"));
+  fprintf (out, "REDUCED GRAMMAR\n\n");
+  fprintf (out,
+          "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
+          ntokens, nvars, nsyms, nrules, nritems);
+  fprintf (out, "Variables\n---------\n\n");
+  fprintf (out, "Value  Sprec  Sassoc  Tag\n");

   for (i = ntokens; i < nsyms; i++)
   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 (out, "%5d  %5d   %5d  %s\n",
+            i,
+            symbols[i]->prec, symbols[i]->assoc,
+            quotearg_style (escape_quoting_style, symbols[i]->tag));
+  fprintf (out, "\n\n");
+  fprintf (out, "Rules\n-----\n\n");
+  fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
+  for (i = 1; i < nrules + nuseless_productions + 1; 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));
+      int rhs_count = 0;
+      /* Find the last RHS index in ritems. */
+      for (r = rules[i].rhs; *r >= 0; ++r)
+       ++rhs_count;
+      fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
+              i - 1,
+              rules[i].prec->prec,
+              rules[i].prec->assoc,
+              rules[i].useful,
+              rules[i].rhs - ritem,
+              rules[i].rhs - ritem + rhs_count - 1,
+              rules[i].lhs->number);
+      /* Dumped the RHS. */
+      for (r = rules[i].rhs; *r >= 0; r++)
+       fprintf (out, "%3d", *r);
+      fprintf (out, "  [%d]\n", -(*r) - 1);

     }
     }

-  fprintf (foutput, "\n\n");
-  fprintf (foutput, _("Rules interpreted\n-----------------\n\n"));
-  for (i = 1; i <= nrules; i++)
+  fprintf (out, "\n\n");
+  fprintf (out, "Rules interpreted\n-----------------\n\n");
+  for (i = 1; i < nrules + nuseless_productions + 1; 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 (out, "%-5d  %s :",
+              i, quotearg_style (escape_quoting_style, rules[i].lhs->tag));
+      for (r = rules[i].rhs; *r >= 0; r++)
+       fprintf (out, " %s",
+                quotearg_style (escape_quoting_style, symbols[*r]->tag));
+      fputc ('\n', out);

     }
     }

-  fprintf (foutput, "\n\n");
+  fprintf (out, "\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);
 
   if (nuseless_nonterminals > 0)
 
   fprintf (stderr, _("%s contains "), infile);
 
   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 +469,49 @@ reduce_grammar (void)
 
   /* Allocate the global sets used to compute the reduced grammar */
 
 
   /* Allocate the global sets used to compute the reduced grammar */
 

-  N = XCALLOC (unsigned, WORDSIZE (nvars));
-  P = XCALLOC (unsigned, WORDSIZE (nrules + 1));
-  V = XCALLOC (unsigned, WORDSIZE (nsyms));
-  V1 = XCALLOC (unsigned, WORDSIZE (nsyms));
+  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 ();
-
-  if (reduced == FALSE)
-    goto done_reducing;
-
-  print_notices ();
+  reduce_print ();

 
 

-  if (!BITISSET (N, start_symbol - ntokens))
+  if (!bitset_test (N, start_symbol - ntokens))

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

-          tags[start_symbol]);
+          quotearg_style (escape_quoting_style, symbols[start_symbol]->tag));
+
+  if (nuseless_productions > 0)
+    reduce_grammar_tables ();
+  if (nuseless_nonterminals > 0)
+    nonterminals_reduce ();

 
 

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

     {
     {

-      fprintf (foutput, "REDUCED GRAMMAR\n\n");
-      dump_grammar ();
+      dump_grammar (stderr);
+
+      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 */
-
-  XFREE (N);
-  XFREE (V);
-  XFREE (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);

 }
 }