Do not let the scan-skel token buffer grow unboundedly in the usual case.

[bison.git] / src / reduce.c

diff --git a/src/reduce.c b/src/reduce.c
index b4b8dc34cfd4ee120707c6ebbde486cb2658e024..94df548e8203ec40f7d5410933459d90634172cd 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -1,5 +1,6 @@
 /* Grammar reduction for Bison.
 /* Grammar reduction for Bison.

-   Copyright 1988, 1989, 2000, 2001  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,64 +27,35 @@
    user's parser.  */
 
 #include "system.h"
    user's parser.  */
 
 #include "system.h"

-#include "getargs.h"
+
+#include <bitset.h>
+#include <quotearg.h>
+
+#include "complain.h"

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

+#include "getargs.h"

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

-#include "complain.h"
-#include "reduce.h"

 #include "reader.h"
 #include "reader.h"

-#include "getargs.h"
+#include "reduce.h"
+#include "symtab.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 nuseless_productions;
+static rule_number nuseful_productions;
+rule_number 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;
-}
+symbol_number 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 |


@@ -92,19 +64,17 @@ bits_size (BSet S, int n)
 `-------------------------------------------------------------------*/
 
 static bool
 `-------------------------------------------------------------------*/
 
 static bool

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

 {
 {

-  rule r;
-  short n;
+  item_number *rhsp;

 
   /* 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[rule_table[i].rhs]; *r > 0; r++)
-    if (ISVAR (n = *r))
-      if (!BITISSET (N0, n - ntokens))
-       return FALSE;
-  return TRUE;
+  for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
+    if (ISVAR (*rhsp) && !bitset_test (N0, *rhsp - ntokens))
+      return false;
+  return true;

 }
 
 
 }
 
 


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

-  BSet Np, Ns;
-  int i;
+  bitset Np, Ns;
+  rule_number r;

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


@@ -141,26 +112,21 @@ useless_nonterminals (void)
 
   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, rule_table[i].lhs - ntokens);
-                 SETBIT (P, i);
-               }
-           }
-       }
-      if (bits_equal (N, Np, WORDSIZE (nvars)))
+      bitset_copy (Np, N);
+      for (r = 0; r < nrules; r++)
+       if (!bitset_test (P, r)
+           && useful_production (r, N))
+         {
+           bitset_set (Np, rules[r].lhs->number - ntokens);
+           bitset_set (P, r);
+         }
+      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;
 }
 


@@ -168,10 +134,7 @@ useless_nonterminals (void)
 static void
 inaccessable_symbols (void)
 {
 static void
 inaccessable_symbols (void)
 {

-  BSet Vp, Vs, Pp;
-  int i;
-  short t;
-  rule r;
+  bitset Vp, Vs, Pp;

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


@@ -196,31 +159,32 @@ 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, 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))
+  if (bitset_test (N, accept->number - ntokens))

     {
     {

-      SETBIT (V, start_symbol);
+      bitset_set (V, accept->number);

 
       while (1)
        {
 
       while (1)
        {

-         for (i = WORDSIZE (nsyms) - 1; i >= 0; i--)
-           Vp[i] = V[i];
-         for (i = 1; i <= nrules; i++)
+         rule_number r;
+         bitset_copy (Vp, V);
+         for (r = 0; r < nrules; r++)

            {
            {

-             if (!BITISSET (Pp, i)
-                 && BITISSET (P, i)
-                 && BITISSET (V, rule_table[i].lhs))
+             if (!bitset_test (Pp, r)
+                 && bitset_test (P, r)
+                 && bitset_test (V, rules[r].lhs->number))

                {
                {

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

                }
            }
                }
            }

-         if (bits_equal (V, Vp, WORDSIZE (nsyms)))
+         if (bitset_equal_p (V, Vp))

            break;
          Vs = Vp;
          Vp = V;
            break;
          Vs = Vp;
          Vp = V;


@@ -228,251 +192,188 @@ inaccessable_symbols (void)
        }
     }
 
        }
     }
 

-  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, endtoken->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;
   nuseless_productions = nrules - nuseful_productions;
 
   nuseful_nonterminals = 0;

-  for (i = ntokens; i < nsyms; i++)
-    if (BITISSET (V, i))
-      nuseful_nonterminals++;
+  {
+    symbol_number i;
+    for (i = ntokens; i < nsyms; 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.  */
   nuseless_nonterminals = nvars - nuseful_nonterminals;
 
   /* A token that was used in %prec should not be warned about.  */

-  for (i = 1; i < nrules; i++)
-    if (rule_table[i].precsym != 0)
-      SETBIT (V1, rule_table[i].precsym);
+  {
+    rule_number r;
+    for (r = 0; r < nrules; ++r)
+      if (rules[r].precsym != 0)
+       bitset_set (V1, rules[r].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)
-               {
-                 rule_table[np].lhs = rule_table[pn].lhs;
-                 rline[np] = rline[pn];
-                 rule_table[np].prec = rule_table[pn].prec;
-                 rule_table[np].assoc = rule_table[pn].assoc;
-                 rule_table[np].rhs = rule_table[pn].rhs;
-                 if (rule_table[np].rhs != ni)
-                   {
-                     pi = rule_table[np].rhs;
-                     rule_table[np].rhs = 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))
-           {
-             rule_table[pn].lhs = -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 = XCALLOC (short, nvars) - ntokens;
-      for (i = ntokens; i < nsyms; i++)
-       nontermmap[i] = -1;
-
-      n = ntokens;
-      for (i = ntokens; i < nsyms; i++)
-       if (BITISSET (V, i))
-         nontermmap[i] = n++;
-
-      /* Shuffle elements of tables indexed by symbol number.  */
-
-      for (i = ntokens; i < nsyms; i++)
-       {
-         n = nontermmap[i];
-         if (n >= 0)
-           {
-             sassoc[n] = sassoc[i];
-             sprec[n] = sprec[i];
-             tags[n] = tags[i];
-           }
-       }
-
-      /* Replace all symbol numbers in valid data structures.  */
+  /* Report and flag useless productions.  */
+  {
+    rule_number r;
+    for (r = 0; r < nrules; r++)
+      rules[r].useful = bitset_test (P, r);
+    grammar_rules_never_reduced_report (_("useless rule"));
+  }
+
+  /* Map the nonterminals to their new index: useful first, useless
+     afterwards.  Kept for later report.  */
+  {
+    int useful = 0;
+    int useless = nrules - nuseless_productions;
+    rule *rules_sorted = MALLOC (rules_sorted, nrules);
+    rule_number r;
+    for (r = 0; r < nrules; ++r)
+      rules_sorted[rules[r].useful ? useful++ : useless++] = rules[r];
+    free (rules);
+    rules = rules_sorted;
+
+    /* Renumber the rules markers in RITEMS.  */
+    for (r = 0; r < nrules; ++r)
+      {
+       item_number *rhsp = rules[r].rhs;
+       for (/* Nothing. */; *rhsp >= 0; ++rhsp)
+         /* Nothing. */;
+       *rhsp = rule_number_as_item_number (r);
+       rules[r].number = r;
+      }
+    nrules -= nuseless_productions;
+  }
+
+  /* Adjust NRITEMS.  */
+  {
+    int r;
+    int length;
+    for (r = nrules; r < nrules + nuseless_productions; ++r)
+      {
+       length = rule_rhs_length (&rules[r]);
+       nritems -= length + 1;
+      }
+  }
+}

 
 

-      for (i = 1; i <= nrules; i++)
-       {
-         /* Ignore the rules disabled above.  */
-         if (rule_table[i].lhs >= 0)
-           rule_table[i].lhs = nontermmap[rule_table[i].lhs];
-         if (ISVAR (rule_table[i].precsym))
-           /* Can this happen?  */
-           rule_table[i].precsym = nontermmap[rule_table[i].precsym];
-       }

 
 

-      for (r = ritem; *r; r++)
-       if (ISVAR (*r))
-         *r = nontermmap[*r];
+/*------------------------------.
+| Remove useless nonterminals.  |
+`------------------------------*/

 
 

-      start_symbol = nontermmap[start_symbol];
+static void
+nonterminals_reduce (void)
+{
+  symbol_number i, n;

 
 

-      nsyms -= nuseless_nonterminals;
-      nvars -= nuseless_nonterminals;
+  /* Map the nonterminals to their new index: useful first, useless
+     afterwards.  Kept for later report.  */

 
 

-      free (&nontermmap[ntokens]);
-    }
+  symbol_number *nontermmap = CALLOC (nontermmap, nvars);
+  n = ntokens;
+  for (i = ntokens; i < nsyms; i++)
+    if (bitset_test (V, i))
+      nontermmap[i - ntokens] = n++;
+  for (i = ntokens; i < nsyms; i++)
+    if (!bitset_test (V, i))
+      {
+       nontermmap[i - ntokens] = n++;
+       warn_at (symbols[i]->location, _("useless nonterminal: %s"),
+                symbols[i]->tag);
+      }
+
+
+  /* Shuffle elements of tables indexed by symbol number.  */
+  {
+    symbol **symbols_sorted = MALLOC (symbols_sorted, nvars);
+
+    for (i = ntokens; i < nsyms; i++)
+      symbols[i]->number = nontermmap[i - ntokens];
+    for (i = ntokens; i < nsyms; i++)
+      symbols_sorted[nontermmap[i - ntokens] - ntokens] = symbols[i];
+    for (i = ntokens; i < nsyms; i++)
+      symbols[i] = symbols_sorted[i - ntokens];
+    free (symbols_sorted);
+  }
+
+  {
+    rule_number r;
+    for (r = 0; r < nrules; ++r)
+      {
+       item_number *rhsp;
+       for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
+         if (ISVAR (*rhsp))
+           *rhsp =  symbol_number_as_item_number (nontermmap[*rhsp
+                                                             - ntokens]);
+      }
+    accept->number = nontermmap[accept->number - ntokens];
+  }
+
+  nsyms -= nuseless_nonterminals;
+  nvars -= nuseless_nonterminals;
+
+  free (nontermmap);

 }
 
 
 }
 
 

-/*-----------------------------------------------------------------.
-| Ouput the detailed results of the reductions.  For FILE.output.  |
-`-----------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Output the detailed results of the reductions.  For FILE.output.  |
+`------------------------------------------------------------------*/

 
 void
 reduce_output (FILE *out)
 {
 
 void
 reduce_output (FILE *out)
 {

-  int i;
-  rule r;
-  bool b;
-

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

-      fprintf (out, _("Useless nonterminals:"));
-      fprintf (out, "\n\n");
-      for (i = ntokens; i < nsyms; i++)
-       if (!BITISSET (V, i))
-         fprintf (out, "   %s\n", tags[i]);
+      int i;
+      fprintf (out, "%s\n\n", _("Useless nonterminals"));
+      for (i = 0; i < nuseless_nonterminals; ++i)
+       fprintf (out, "   %s\n", 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 (out, "\n\n");
-             fprintf (out, _("Terminals which are not used:"));
-             fprintf (out, "\n\n");
-             b = TRUE;
-           }
-         fprintf (out, "   %s\n", tags[i]);
+           fprintf (out, "%s\n\n", _("Terminals which are not used"));
+         b = true;
+         fprintf (out, "   %s\n", symbols[i]->tag);

        }
        }

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

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

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

 }
 \f
 }
 \f

-static void
-dump_grammar (FILE *out)
-{
-  int i;
-  rule r;
-
-  fprintf (out, "REDUCED GRAMMAR\n\n");
-  fprintf (out,
-        "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d\n\n",
-        ntokens, nvars, nsyms, nrules, nitems);
-  fprintf (out, _("Variables\n---------\n\n"));
-  fprintf (out, _("Value  Sprec    Sassoc    Tag\n"));
-  for (i = ntokens; i < nsyms; i++)
-    fprintf (out, "%5d  %5d  %5d  %s\n", i, sprec[i], sassoc[i], tags[i]);
-  fprintf (out, "\n\n");
-  fprintf (out, _("Rules\n-----\n\n"));
-  for (i = 1; i <= nrules; i++)
-    {
-      fprintf (out, "%-5d(%5d%5d)%5d : (@%-5d)",
-              i,
-              rule_table[i].prec,
-              rule_table[i].assoc,
-              rule_table[i].lhs,
-              rule_table[i].rhs);
-      for (r = &ritem[rule_table[i].rhs]; *r > 0; r++)
-       fprintf (out, "%5d", *r);
-      fprintf (out, " [%d]\n", -(*r));
-    }
-  fprintf (out, "\n\n");
-  fprintf (out, _("Rules interpreted\n-----------------\n\n"));
-  for (i = 1; i <= nrules; i++)
-    {
-      fprintf (out, "%-5d  %s :", i, tags[rule_table[i].lhs]);
-      for (r = &ritem[rule_table[i].rhs]; *r > 0; r++)
-       fprintf (out, " %s", tags[*r]);
-      fputc ('\n', out);
-    }
-  fprintf (out, "\n\n");
-}
+

 
 
 
 
 
 


@@ -484,26 +385,28 @@ static void
 reduce_print (void)
 {
   if (yacc_flag && nuseless_productions)
 reduce_print (void)
 {
   if (yacc_flag && nuseless_productions)

-    fprintf (stderr, _("%d rules never reduced\n"), 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: ", grammar_file, _("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");
   fprintf (stderr, "\n");

-  fflush (stderr);

 }
 \f
 void
 }
 \f
 void


@@ -513,34 +416,40 @@ 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, 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;
 
   reduce_print ();
 
   if (!reduced)
     return;
 
   reduce_print ();
 

-  if (!BITISSET (N, start_symbol - ntokens))
-    fatal (_("Start symbol %s does not derive any sentence"),
-          tags[start_symbol]);
+  if (!bitset_test (N, accept->number - ntokens))
+    fatal_at (startsymbol_location,
+             _("start symbol %s does not derive any sentence"),
+             startsymbol->tag);

 
 

-  reduce_grammar_tables ();
+  /* 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 ();

 
 

-  if (trace_flag)
+  if (trace_flag & trace_grammar)

     {
     {

-      dump_grammar (stderr);
+      grammar_dump (stderr, "Reduced Grammar");

 
       fprintf (stderr, "reduced %s defines %d terminals, %d nonterminals\
 , and %d productions.\n",
 
       fprintf (stderr, "reduced %s defines %d terminals, %d nonterminals\
 , and %d productions.\n",

-              infile, ntokens, nvars, nrules);
+              grammar_file, ntokens, nvars, nrules);

     }
 }
 
     }
 }
 


@@ -552,8 +461,8 @@ reduce_grammar (void)
 void
 reduce_free (void)
 {
 void
 reduce_free (void)
 {

-  XFREE (N);
-  XFREE (V);
-  XFREE (V1);
-  XFREE (P);
+  bitset_free (N);
+  bitset_free (V);
+  bitset_free (V1);
+  bitset_free (P);

 }
 }