Copy BYacc's nice way to report the grammar.

[bison.git] / src / reduce.c

diff --git a/src/reduce.c b/src/reduce.c
index db033b34113a7aab9c7b3e9eaf2fe196ec5d7b4b..2319b60bf192104f672ff22b0617b62015217824 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -1,5 +1,5 @@
 /* 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,6 +26,7 @@
    user's parser.  */
 
 #include "system.h"
    user's parser.  */
 
 #include "system.h"

+#include "quotearg.h"

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


@@ -36,9 +37,6 @@
 #include "getargs.h"
 #include "bitset.h"
 
 #include "getargs.h"
 #include "bitset.h"
 

-typedef short *rule;
-
-

 /* Set of all nonterminals which are not useless.  */
 static bitset N;
 
 /* Set of all nonterminals which are not useless.  */
 static bitset N;
 


@@ -53,7 +51,7 @@ static bitset V;
 static bitset V1;
 
 static int nuseful_productions;
 static bitset V1;
 
 static int nuseful_productions;

-static int nuseless_productions;
+int nuseless_productions;

 static int nuseful_nonterminals;
 int nuseless_nonterminals;
 \f
 static int nuseful_nonterminals;
 int nuseless_nonterminals;
 \f


@@ -66,7 +64,7 @@ int nuseless_nonterminals;
 static bool
 useful_production (int i, bitset N0)
 {
 static bool
 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
   short n;
 
   /* A production is useful if all of the nonterminals in its appear


@@ -138,7 +136,7 @@ inaccessable_symbols (void)
   bitset Vp, Vs, Pp;
   int i;
   short t;
   bitset Vp, Vs, Pp;
   int i;
   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


@@ -167,9 +165,9 @@ inaccessable_symbols (void)
   Pp = bitset_create (nrules + 1, BITSET_FIXED);
 
   /* If the start symbol isn't useful, then nothing will be useful. */
   Pp = bitset_create (nrules + 1, BITSET_FIXED);
 
   /* If the start symbol isn't useful, then nothing will be useful. */

-  if (bitset_test (N, start_symbol - ntokens))
+  if (bitset_test (N, axiom->number - ntokens))

     {
     {

-      bitset_set (V, start_symbol);
+      bitset_set (V, axiom->number);

 
       while (1)
        {
 
       while (1)
        {


@@ -198,9 +196,9 @@ inaccessable_symbols (void)
   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. */

-  bitset_set (V, 0);           /* end-of-input token */
-  bitset_set (V, 1);           /* error token */
-  bitset_set (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 */

 
   bitset_free (P);
   P = Pp;
 
   bitset_free (P);
   P = Pp;


@@ -217,7 +215,7 @@ inaccessable_symbols (void)
   /* A token that was used in %prec should not be warned about.  */
   for (i = 1; i < nrules + 1; i++)
     if (rules[i].precsym != 0)
   /* A token that was used in %prec should not be warned about.  */
   for (i = 1; i < nrules + 1; i++)
     if (rules[i].precsym != 0)

-      bitset_set (V1, rules[i].precsym);
+      bitset_set (V1, rules[i].precsym->number);

 }
 
 
 }
 
 


@@ -229,11 +227,19 @@ inaccessable_symbols (void)
 static void
 reduce_grammar_tables (void)
 {
 static void
 reduce_grammar_tables (void)
 {

-  /* Flag useless productions.  */
+  /* Report and flag useless productions.  */

   {
   {

-    int pn;
-    for (pn = 1; pn < nrules + 1; pn++)
-      rules[pn].useful = bitset_test (P, pn);
+    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
   }
 
   /* Map the nonterminals to their new index: useful first, useless


@@ -248,26 +254,19 @@ reduce_grammar_tables (void)
     free (rules + 1);
     rules = rules_sorted;
 
     free (rules + 1);
     rules = rules_sorted;
 

-    /* Also reorder ritems. */
-    {
-      short *ritems_sorted = XCALLOC (short, nitems + 1);
-      short *ritemsp = ritems_sorted;
-      for (i = 1; i < nrules + 1; ++i)
-       {
-         short *rhsp = rules[i].rhs;
-         rules[i].rhs = ritemsp;
-         for (/* Nothing. */; *rhsp >= 0; ++rhsp)
-           *ritemsp++ = *rhsp;
-         *ritemsp++ = -i;
-       }
-      *ritemsp++ = 0;
-      free (ritem);
-      ritem = ritems_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;
   }
 
     nrules -= nuseless_productions;
   }
 

-  /* Adjust NRITEMS and NITEMS.  */
+  /* Adjust NRITEMS.  */

   {
     int r;
     int length;
   {
     int r;
     int length;


@@ -275,7 +274,6 @@ reduce_grammar_tables (void)
       {
        length = rule_rhs_length (&rules[r]);
        nritems -= length + 1;
       {
        length = rule_rhs_length (&rules[r]);
        nritems -= length + 1;

-       nitems -= length + 1;

       }
   }
 }
       }
   }
 }


@@ -288,24 +286,30 @@ reduce_grammar_tables (void)
 static void
 nonterminals_reduce (void)
 {
 static void
 nonterminals_reduce (void)
 {

-  int i, n;
+  symbol_number_t i, n;

 
   /* Map the nonterminals to their new index: useful first, useless
      afterwards.  Kept for later report.  */
 
 
   /* Map the nonterminals to their new index: useful first, useless
      afterwards.  Kept for later report.  */
 

-  short *nontermmap = XCALLOC (short, nvars) - ntokens;
+  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))
   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++;
+      {
+       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.  */
   {
 
 
   /* Shuffle elements of tables indexed by symbol number.  */
   {

-    bucket **symbols_sorted = XMALLOC (bucket *, nvars) - ntokens;
+    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[i]->number = nontermmap[i];


@@ -316,20 +320,17 @@ nonterminals_reduce (void)
     free (symbols_sorted + ntokens);
   }
 
     free (symbols_sorted + ntokens);
   }
 

-  /* Replace all symbol numbers in valid data structures.  */
-
-  for (i = 1; i < nrules + 1; i++)
-    {
-      if (ISVAR (rules[i].precsym))
-       /* Can this happen?  */
-       rules[i].precsym = nontermmap[rules[i].precsym];
-    }
-
-  for (i = 0; i < nritems; ++i)
-    if (ISVAR (ritem[i]))
-      ritem[i] = nontermmap[ritem[i]];
-
-  start_symbol = nontermmap[start_symbol];
+  {
+    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;
 
   nsyms -= nuseless_nonterminals;
   nvars -= nuseless_nonterminals;


@@ -350,7 +351,7 @@ reduce_output (FILE *out)
       int i;
       fprintf (out, "%s\n\n", _("Useless nonterminals:"));
       for (i = 0; i < nuseless_nonterminals; ++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);
+       fprintf (out, "   %s\n", symbol_tag_get (symbols[nsyms + i]));

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


@@ -363,7 +364,7 @@ reduce_output (FILE *out)
          if (!b)
            fprintf (out, "%s\n\n", _("Terminals which are not used:"));
          b = TRUE;
          if (!b)
            fprintf (out, "%s\n\n", _("Terminals which are not used:"));
          b = TRUE;

-         fprintf (out, "   %s\n", symbols[i]->tag);
+         fprintf (out, "   %s\n", symbol_tag_get (symbols[i]));

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


@@ -375,63 +376,18 @@ reduce_output (FILE *out)
       fprintf (out, "%s\n\n", _("Useless rules:"));
       for (i = nrules + 1; i < nuseless_productions + nrules + 1; i++)
        {
       fprintf (out, "%s\n\n", _("Useless rules:"));
       for (i = nrules + 1; i < nuseless_productions + nrules + 1; i++)
        {

-         rule r;
-         fprintf (out, "#%-4d  ", rules[i].number - 1);
-         fprintf (out, "%s:", rules[i].lhs->tag);
+         item_number_t *r;
+         fprintf (out, "#%-4d  ", rules[i].user_number - 1);
+         fprintf (out, "%s:", symbol_tag_get (rules[i].lhs));

          for (r = rules[i].rhs; *r >= 0; r++)
          for (r = rules[i].rhs; *r >= 0; r++)

-           fprintf (out, " %s", symbols[*r]->tag);
+           fprintf (out, " %s", symbol_tag_get (symbols[*r]));

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

 
 
 
 
 
 


@@ -448,7 +404,7 @@ reduce_print (void)
                               nuseless_productions),
             nuseless_productions);
 
                               nuseless_productions),
             nuseless_productions);
 

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

 
   if (nuseless_nonterminals > 0)
     fprintf (stderr, ngettext ("%d useless nonterminal",
 
   if (nuseless_nonterminals > 0)
     fprintf (stderr, ngettext ("%d useless nonterminal",


@@ -489,18 +445,21 @@ reduce_grammar (void)
 
   reduce_print ();
 
 
   reduce_print ();
 

-  if (!bitset_test (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"),

-          symbols[start_symbol]->tag);
+          symbol_tag_get (symbols[axiom->number]));

 
 

-  if (nuseless_productions > 0)
-    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_nonterminals > 0)
     nonterminals_reduce ();

+  if (nuseless_productions > 0)
+    reduce_grammar_tables ();

 
   if (trace_flag)
     {
 
   if (trace_flag)
     {

-      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",