/* Grammar reduction for Bison.
- Copyright 1988, 1989, 2000 Free Software Foundation, Inc.
+ Copyright 1988, 1989, 2000, 2001 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
#include "getargs.h"
#include "files.h"
#include "gram.h"
-#include "xalloc.h"
#include "complain.h"
#include "reduce.h"
#include "reader.h"
/* 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++)
+ for (r = &ritem[rule_table[i].rhs]; *r > 0; r++)
if (ISVAR (n = *r))
if (!BITISSET (N0, n - ntokens))
return FALSE;
useless_nonterminals (void)
{
BSet Np, Ns;
- int i, n;
+ 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. */
saved to be used when finding useful productions: only
productions in this set will appear in the final grammar. */
- n = 0;
while (1)
{
for (i = WORDSIZE (nvars) - 1; i >= 0; i--)
{
if (useful_production (i, N))
{
- SETBIT (Np, rlhs[i] - ntokens);
+ SETBIT (Np, rule_table[i].lhs - ntokens);
SETBIT (P, i);
}
}
inaccessable_symbols (void)
{
BSet Vp, Vs, Pp;
- int i, n;
+ int i;
short t;
rule r;
SETBIT (V, start_symbol);
- n = 0;
while (1)
{
for (i = WORDSIZE (nsyms) - 1; i >= 0; i--)
Vp[i] = V[i];
for (i = 1; i <= nrules; i++)
{
- if (!BITISSET (Pp, i) && BITISSET (P, i) && BITISSET (V, rlhs[i]))
+ if (!BITISSET (Pp, i) && BITISSET (P, i) && BITISSET (V, rule_table[i].lhs))
{
- for (r = &ritem[rrhs[i]]; *r >= 0; r++)
+ for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
{
if (ISTOKEN (t = *r) || BITISSET (N, t - ntokens))
{
/* 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]);
+ if (rule_table[i].precsym != 0)
+ SETBIT (V1, rule_table[i].precsym);
}
static void
np++;
if (pn != np)
{
- rlhs[np] = rlhs[pn];
+ rule_table[np].lhs = rule_table[pn].lhs;
rline[np] = rline[pn];
- rprec[np] = rprec[pn];
- rassoc[np] = rassoc[pn];
- rrhs[np] = rrhs[pn];
- if (rrhs[np] != ni)
+ 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 = rrhs[np];
- rrhs[np] = ni;
+ pi = rule_table[np].rhs;
+ rule_table[np].rhs = ni;
while (ritem[pi] >= 0)
ritem[ni++] = ritem[pi++];
ritem[ni++] = -np;
{
if (!BITISSET (P, pn))
{
- rlhs[pn] = -1;
+ rule_table[pn].lhs = -1;
}
}
}
for (i = 1; i <= nrules; i++)
{
/* Ignore the rules disabled above. */
- if (rlhs[i] >= 0)
- rlhs[i] = nontermmap[rlhs[i]];
- if (ISVAR (rprecsym[i]))
+ if (rule_table[i].lhs >= 0)
+ rule_table[i].lhs = nontermmap[rule_table[i].lhs];
+ if (ISVAR (rule_table[i].precsym))
/* Can this happen? */
- rprecsym[i] = nontermmap[rprecsym[i]];
+ rule_table[i].precsym = nontermmap[rule_table[i].precsym];
}
for (r = ritem; *r; r++)
}
}
-static void
-print_results (void)
+
+/*-----------------------------------------------------------------.
+| Ouput the detailed results of the reductions. For FILE.output. |
+`-----------------------------------------------------------------*/
+
+void
+reduce_output (FILE *out)
{
int i;
-/* short j; JF unused */
rule r;
bool b;
if (nuseless_nonterminals > 0)
{
- obstack_sgrow (&output_obstack, _("Useless nonterminals:"));
- obstack_sgrow (&output_obstack, "\n\n");
+ fprintf (out, _("Useless nonterminals:"));
+ fprintf (out, "\n\n");
for (i = ntokens; i < nsyms; i++)
if (!BITISSET (V, i))
- obstack_fgrow1 (&output_obstack, " %s\n", tags[i]);
+ fprintf (out, " %s\n", tags[i]);
}
b = FALSE;
for (i = 0; i < ntokens; i++)
{
if (!b)
{
- obstack_sgrow (&output_obstack, "\n\n");
- obstack_sgrow (&output_obstack,
- _("Terminals which are not used:"));
- obstack_sgrow (&output_obstack, "\n\n");
+ fprintf (out, "\n\n");
+ fprintf (out, _("Terminals which are not used:"));
+ fprintf (out, "\n\n");
b = TRUE;
}
- obstack_fgrow1 (&output_obstack, " %s\n", tags[i]);
+ fprintf (out, " %s\n", tags[i]);
}
}
if (nuseless_productions > 0)
{
- obstack_sgrow (&output_obstack, "\n\n");
- obstack_sgrow (&output_obstack, _("Useless rules:"));
- obstack_sgrow (&output_obstack, "\n\n");
+ fprintf (out, "\n\n");
+ fprintf (out, _("Useless rules:"));
+ fprintf (out, "\n\n");
for (i = 1; i <= nrules; i++)
{
if (!BITISSET (P, i))
{
- obstack_fgrow1 (&output_obstack, "#%-4d ", i);
- obstack_fgrow1 (&output_obstack, "%s :\t", tags[rlhs[i]]);
- for (r = &ritem[rrhs[i]]; *r >= 0; r++)
- obstack_fgrow1 (&output_obstack, " %s", tags[*r]);
- obstack_sgrow (&output_obstack, ";\n");
+ 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)
- obstack_sgrow (&output_obstack, "\n\n");
+ fprintf (out, "\n\n");
}
\f
#if 0 /* XXX currently unused. */
static void
-dump_grammar (void)
+dump_grammar (FILE *out)
{
int i;
rule r;
- obstack_fgrow5 (&output_obstack,
+ fprintf (out,
"ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d\n\n",
ntokens, nvars, nsyms, nrules, nitems);
- obstack_sgrow (&output_obstack,
- _("Variables\n---------\n\n"));
- obstack_sgrow (&output_obstack,
- _("Value Sprec Sassoc Tag\n"));
+ fprintf (out, _("Variables\n---------\n\n"));
+ fprintf (out, _("Value Sprec Sassoc Tag\n"));
for (i = ntokens; i < nsyms; i++)
- obstack_fgrow4 (&output_obstack,
- "%5d %5d %5d %s\n", i, sprec[i], sassoc[i], tags[i]);
- obstack_sgrow (&output_obstack, "\n\n");
- obstack_sgrow (&output_obstack, _("Rules\n-----\n\n"));
+ 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++)
{
- obstack_fgrow5 (&output_obstack, "%-5d(%5d%5d)%5d : (@%-5d)",
- i, rprec[i], rassoc[i], rlhs[i], rrhs[i]);
- for (r = &ritem[rrhs[i]]; *r > 0; r++)
- obstack_fgrow1 (&output_obstack, "%5d", *r);
- obstack_fgrow1 (&output_obstack, " [%d]\n", -(*r));
+ 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));
}
- obstack_sgrow (&output_obstack, "\n\n");
- obstack_sgrow (&output_obstack,
- _("Rules interpreted\n-----------------\n\n"));
+ fprintf (out, "\n\n");
+ fprintf (out, _("Rules interpreted\n-----------------\n\n"));
for (i = 1; i <= nrules; i++)
{
- obstack_fgrow2 (&output_obstack, "%-5d %s :", i, tags[rlhs[i]]);
- for (r = &ritem[rrhs[i]]; *r > 0; r++)
- obstack_fgrow1 (&output_obstack, " %s", tags[*r]);
- obstack_grow1 (&output_obstack, '\n');
+ 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);
}
- obstack_sgrow (&output_obstack, "\n\n");
+ fprintf (out, "\n\n");
}
#endif
+
+/*-------------------------------.
+| Report the results to STDERR. |
+`-------------------------------*/
+
static void
-print_notices (void)
+reduce_print (void)
{
if (yacc_flag && nuseless_productions)
fprintf (stderr, _("%d rules never reduced\n"), nuseless_productions);
reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0);
- if (verbose_flag)
- print_results ();
-
- if (reduced == FALSE)
- goto done_reducing;
+ if (!reduced)
+ return;
- print_notices ();
+ reduce_print ();
if (!BITISSET (N, start_symbol - ntokens))
fatal (_("Start symbol %s does not derive any sentence"),
#if 0
if (verbose_flag)
{
- obstack_fgrow1 (&output_obstack, "REDUCED GRAMMAR\n\n");
+ fprintf (out, "REDUCED GRAMMAR\n\n");
dump_grammar ();
}
#endif
(nvars == 1 ? "" : "s"),
nrules,
(nrules == 1 ? "" : "s"));
+}
-done_reducing:
- /* Free the global sets used to compute the reduced grammar */
+/*-----------------------------------------------------------.
+| Free the global sets used to compute the reduced grammar. |
+`-----------------------------------------------------------*/
+
+void
+reduce_free (void)
+{
XFREE (N);
XFREE (V);
+ XFREE (V1);
XFREE (P);
}
projects / bison.git / blobdiff