Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-22 18:53:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

* src/reduce.h: New file.

Browse Source 
Propagate its inclusion.
* src/reduce.c: Topological sort and other formatting changes.
(bool, TRUE, FALSE): Move their definition to...
* src/system.h: here.
This commit is contained in:
Akim Demaille
2000-10-02 08:04:25 +00:00
parent 8963a27bde
commit 015acc4834
5 changed files with 273 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@@ -1,3 +1,12 @@
2000-10-02 Akim Demaille <akim@epita.fr>
* src/reduce.h: New file.
Propagate its inclusion.
* src/reduce.c: Topological sort and other formatting changes.
(bool, TRUE, FALSE): Move their definition to...
* src/system.h: here.
2000-10-02 Akim Demaille <akim@epita.fr> 2000-10-02 Akim Demaille <akim@epita.fr>
* src/files.c: Formatting changes. * src/files.c: Formatting changes.

2
src/Makefile.am
View File

@@ -22,7 +22,7 @@ noinst_HEADERS = alloc.h closure.h complain.h \
derives.h \ derives.h \
files.h getargs.h gram.h lalr.h lex.h \ files.h getargs.h gram.h lalr.h lex.h \
output.h state.h \ output.h state.h \
reader.h symtab.h system.h types.h reader.h reduce.h symtab.h system.h types.h
data_DATA = bison.simple bison.hairy data_DATA = bison.simple bison.hairy

2
src/main.c
View File

@@ -28,6 +28,7 @@
#include "output.h" #include "output.h"
#include "reader.h" #include "reader.h"
#include "lalr.h" #include "lalr.h"
#include "reduce.h"
#if 0 /* XXX currently unused. */ #if 0 /* XXX currently unused. */
/* Nonzero means failure has been detected; don't write a parser file. */ /* Nonzero means failure has been detected; don't write a parser file. */
@@ -41,7 +42,6 @@ extern void berror PARAMS((const char *));
extern char *printable_version PARAMS ((int)); extern char *printable_version PARAMS ((int));
extern void reduce_grammar PARAMS ((void));
extern void set_nullable PARAMS ((void)); extern void set_nullable PARAMS ((void));
extern void free_nullable PARAMS ((void)); extern void free_nullable PARAMS ((void));
extern void generate_states PARAMS ((void)); extern void generate_states PARAMS ((void));

314
src/reduce.c
View File

@@ -1,5 +1,5 @@
/* Grammar reduction for Bison. /* Grammar reduction for Bison.
Copyright (C) 1988, 1989 Free Software Foundation, Inc. Copyright (C) 1988, 1989, 2000 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler. This file is part of Bison, the GNU Compiler Compiler.
@@ -19,15 +19,11 @@ the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */ Boston, MA 02111-1307, USA. */
/* /* Reduce the grammar: Find and eliminate unreachable terminals,
* Reduce the grammar: Find and eliminate unreachable terminals, nonterminals, and productions. David S. Bakin. */
* nonterminals, and productions. David S. Bakin.
*/
/* /* Don't eliminate unreachable terminals: They may be used by the
* Don't eliminate unreachable terminals: They may be used by the user's user's parser. */
* parser.
*/
#include "system.h" #include "system.h"
#include "getargs.h" #include "getargs.h"
@@ -35,49 +31,27 @@ Boston, MA 02111-1307, USA. */
#include "gram.h" #include "gram.h"
#include "alloc.h" #include "alloc.h"
#include "complain.h" #include "complain.h"
#include "reduce.h"
extern char **tags; /* reader.c */ extern char **tags; /* reader.c */
static int statisticsflag; /* XXXXXXX */ static int statisticsflag; /* XXXXXXX */
extern int fixed_outfiles; extern int fixed_outfiles;
#ifndef TRUE
#define TRUE (1)
#define FALSE (0)
#endif
typedef int bool;
typedef unsigned *BSet; typedef unsigned *BSet;
typedef short *rule; typedef short *rule;
/* /* N is set of all nonterminals which are not useless. P is set of
* N is set of all nonterminals which are not useless. P is set of all rules all rules which have no useless nonterminals in their RHS. V is
* which have no useless nonterminals in their RHS. V is the set of all the set of all accessible symbols. */
* accessible symbols.
*/
static BSet N, P, V, V1; static BSet N, P, V, V1;
static int nuseful_productions, nuseless_productions, static int nuseful_productions;
nuseful_nonterminals, nuseless_nonterminals; static int nuseless_productions;
static int nuseful_nonterminals;
static int nuseless_nonterminals;
extern void reduce_grammar PARAMS((void));
static bool bits_equal PARAMS((BSet, BSet, int));
static int nbits PARAMS((unsigned));
static int bits_size PARAMS((BSet, int));
static void useless_nonterminals PARAMS((void));
static void inaccessable_symbols PARAMS((void));
static void reduce_grammar_tables PARAMS((void));
static void print_results PARAMS((void));
static void print_notices PARAMS((void));
#if 0 /* XXX currently unused. */
static void dump_grammar PARAMS((void));
#endif
static bool static bool
bits_equal (BSet L, BSet R, int n) bits_equal (BSet L, BSet R, int n)
{ {
@@ -95,7 +69,8 @@ nbits (unsigned i)
{ {
int count = 0; int count = 0;
while (i != 0) { while (i != 0)
{
i ^= (i & ((unsigned) (-(int) i))); i ^= (i & ((unsigned) (-(int) i)));
++count; ++count;
} }
@@ -113,67 +88,11 @@ bits_size (BSet S, int n)
return count; return count;
} }
void /*-------------------------------------------------------------------.
reduce_grammar (void) | Another way to do this would be with a set for each production and |
{ | then do subset tests against N0, but even for the C grammar the |
bool reduced; | whole reducing process takes only 2 seconds on my 8Mhz AT. |
`-------------------------------------------------------------------*/
/* 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);
useless_nonterminals();
inaccessable_symbols();
reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0);
if (verboseflag)
print_results();
if (reduced == FALSE)
goto done_reducing;
print_notices();
if (!BITISSET(N, start_symbol - ntokens))
fatal (_("Start symbol %s does not derive any sentence"),
tags[start_symbol]);
reduce_grammar_tables();
#if 0
if (verboseflag)
{
fprintf(foutput, "REDUCED GRAMMAR\n\n");
dump_grammar();
}
#endif
/**/ statisticsflag = FALSE; /* someday getopts should handle this */
if (statisticsflag == TRUE)
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);
}
/*
* Another way to do this would be with a set for each production and then do
* subset tests against N0, but even for the C grammar the whole reducing
* process takes only 2 seconds on my 8Mhz AT.
*/
static bool static bool
useful_production (int i, BSet N0) useful_production (int i, BSet N0)
@@ -181,10 +100,8 @@ useful_production (int i, BSet N0)
rule r; rule r;
short n; short n;
/* /* A production is useful if all of the nonterminals in its appear
* A production is useful if all of the nonterminals in its RHS in the set of useful nonterminals. */
* appear in the set of useful nonterminals.
*/
for (r = &ritem[rrhs[i]]; *r > 0; r++) for (r = &ritem[rrhs[i]]; *r > 0; r++)
if (ISVAR (n = *r)) if (ISVAR (n = *r))
@@ -194,7 +111,9 @@ useful_production (int i, BSet N0)
} }
/* Remember that rules are 1-origin, symbols are 0-origin. */ /*---------------------------------------------------------.
| Remember that rules are 1-origin, symbols are 0-origin. |
`---------------------------------------------------------*/
static void static void
useless_nonterminals (void) useless_nonterminals (void)
@@ -202,30 +121,26 @@ useless_nonterminals (void)
BSet Np, Ns; BSet Np, Ns;
int i, n; int i, n;
/* /* N is set as built. Np is set being built this iteration. P is
* N is set as built. Np is set being built this iteration. P is set set of all productions which have a RHS all in N. */
* of all productions which have a RHS all in N.
*/
Np = NEW2 (WORDSIZE (nvars), unsigned); Np = NEW2 (WORDSIZE (nvars), unsigned);
/* /* The set being computed is a set of nonterminals which can derive
* The set being computed is a set of nonterminals which can derive the empty string or strings consisting of all terminals. At each
* the empty string or strings consisting of all terminals. At each iteration a nonterminal is added to the set if there is a
* iteration a nonterminal is added to the set if there is a production with that nonterminal as its LHS for which all the
* production with that nonterminal as its LHS for which all the nonterminals in its RHS are already in the set. Iterate until
* nonterminals in its RHS are already in the set. Iterate until the the set being computed remains unchanged. Any nonterminals not
* set being computed remains unchanged. Any nonterminals not in the in the set at that point are useless in that they will never be
* set at that point are useless in that they will never be used in used in deriving a sentence of the language.
* deriving a sentence of the language.
* This iteration doesn't use any special traversal over the
* This iteration doesn't use any special traversal over the productions. A set is kept of all productions for which all the
* productions. A set is kept of all productions for which all the nonterminals in the RHS are in useful. Only productions not in
* nonterminals in the RHS are in useful. Only productions not in this set are scanned on each iteration. At the end, this set is
* this set are scanned on each iteration. At the end, this set is saved to be used when finding useful productions: only
* saved to be used when finding useful productions: only productions productions in this set will appear in the final grammar. */
* in this set will appear in the final grammar.
*/
n = 0; n = 0;
while (1) while (1)
@@ -252,7 +167,8 @@ useless_nonterminals (void)
FREE (N); FREE (N);
N = Np; N = Np;
} }
static void static void
inaccessable_symbols (void) inaccessable_symbols (void)
{ {
@@ -261,30 +177,28 @@ inaccessable_symbols (void)
short t; short t;
rule r; rule r;
/* /* Find out which productions are reachable and which symbols are
* Find out which productions are reachable and which symbols are used. Starting with an empty set of productions and a set of
* used. Starting with an empty set of productions and a set of symbols which only has the start symbol in it, iterate over all
* symbols which only has the start symbol in it, iterate over all productions until the set of productions remains unchanged for an
* productions until the set of productions remains unchanged for an iteration. For each production which has a LHS in the set of
* iteration. For each production which has a LHS in the set of reachable symbols, add the production to the set of reachable
* reachable symbols, add the production to the set of reachable productions, and add all of the nonterminals in the RHS of the
* productions, and add all of the nonterminals in the RHS of the production to the set of reachable symbols.
* production to the set of reachable symbols.
* Consider only the (partially) reduced grammar which has only
* Consider only the (partially) reduced grammar which has only nonterminals in N and productions in P.
* nonterminals in N and productions in P.
* The result is the set P of productions in the reduced grammar,
* The result is the set P of productions in the reduced grammar, and and the set V of symbols in the reduced grammar.
* the set V of symbols in the reduced grammar.
* Although this algorithm also computes the set of terminals which
* Although this algorithm also computes the set of terminals which are are reachable, no terminal will be deleted from the grammar. Some
* reachable, no terminal will be deleted from the grammar. Some terminals might not be in the grammar but might be generated by
* terminals might not be in the grammar but might be generated by semantic routines, and so the user might want them available with
* semantic routines, and so the user might want them available with specified numbers. (Is this true?) However, the nonreachable
* specified numbers. (Is this true?) However, the nonreachable terminals are printed (if running in verbose mode) so that the
* terminals are printed (if running in verbose mode) so that the user user can know. */
* can know.
*/
Vp = NEW2 (WORDSIZE (nsyms), unsigned); Vp = NEW2 (WORDSIZE (nsyms), unsigned);
Pp = NEW2 (WORDSIZE (nrules + 1), unsigned); Pp = NEW2 (WORDSIZE (nrules + 1), unsigned);
@@ -302,13 +216,11 @@ inaccessable_symbols (void)
Vp[i] = V[i]; Vp[i] = V[i];
for (i = 1; i <= nrules; i++) for (i = 1; i <= nrules; i++)
{ {
if (!BITISSET(Pp, i) && BITISSET(P, i) && if (!BITISSET (Pp, i) && BITISSET (P, i) && BITISSET (V, rlhs[i]))
BITISSET(V, rlhs[i]))
{ {
for (r = &ritem[rrhs[i]]; *r >= 0; r++) for (r = &ritem[rrhs[i]]; *r >= 0; r++)
{ {
if (ISTOKEN(t = *r) if (ISTOKEN (t = *r) || BITISSET (N, t - ntokens))
|| BITISSET(N, t - ntokens))
{ {
SETBIT (Vp, t); SETBIT (Vp, t);
} }
@@ -351,7 +263,7 @@ inaccessable_symbols (void)
if (rprecsym[i] != 0) if (rprecsym[i] != 0)
SETBIT (V1, rprecsym[i]); SETBIT (V1, rprecsym[i]);
} }
static void static void
reduce_grammar_tables (void) reduce_grammar_tables (void)
{ {
@@ -385,7 +297,9 @@ reduce_grammar_tables (void)
ritem[ni++] = ritem[pi++]; ritem[ni++] = ritem[pi++];
ritem[ni++] = -np; ritem[ni++] = -np;
} }
} else { }
else
{
while (ritem[ni++] >= 0); while (ritem[ni++] >= 0);
} }
} }
@@ -394,10 +308,8 @@ reduce_grammar_tables (void)
nrules -= nuseless_productions; nrules -= nuseless_productions;
nitems = ni; nitems = ni;
/* /* Is it worth it to reduce the amount of memory for the
* Is it worth it to reduce the amount of memory for the grammar? Probably not. */
* grammar? Probably not.
*/
} }
#endif /* 0 */ #endif /* 0 */
@@ -426,11 +338,9 @@ reduce_grammar_tables (void)
short *nontermmap; short *nontermmap;
rule r; rule r;
/* /* Create a map of nonterminal number to new nonterminal
* create a map of nonterminal number to new nonterminal number. -1 in the map means it was useless and is being
* number. -1 in the map means it was useless and is being eliminated. */
* eliminated.
*/
nontermmap = NEW2 (nvars, short) - ntokens; nontermmap = NEW2 (nvars, short) - ntokens;
for (i = ntokens; i < nsyms; i++) for (i = ntokens; i < nsyms; i++)
@@ -451,7 +361,9 @@ reduce_grammar_tables (void)
sassoc[n] = sassoc[i]; sassoc[n] = sassoc[i];
sprec[n] = sprec[i]; sprec[n] = sprec[i];
tags[n] = tags[i]; tags[n] = tags[i];
} else { }
else
{
free (tags[i]); free (tags[i]);
} }
} }
@@ -480,7 +392,7 @@ reduce_grammar_tables (void)
free (&nontermmap[ntokens]); free (&nontermmap[ntokens]);
} }
} }
static void static void
print_results (void) print_results (void)
{ {
@@ -544,8 +456,7 @@ dump_grammar (void)
fprintf (foutput, _("Variables\n---------\n\n")); fprintf (foutput, _("Variables\n---------\n\n"));
fprintf (foutput, _("Value Sprec Sassoc Tag\n")); fprintf (foutput, _("Value Sprec Sassoc Tag\n"));
for (i = ntokens; i < nsyms; i++) for (i = ntokens; i < nsyms; i++)
fprintf(foutput, "%5d %5d %5d %s\n", fprintf (foutput, "%5d %5d %5d %s\n", i, sprec[i], sassoc[i], tags[i]);
i, sprec[i], sassoc[i], tags[i]);
fprintf (foutput, "\n\n"); fprintf (foutput, "\n\n");
fprintf (foutput, _("Rules\n-----\n\n")); fprintf (foutput, _("Rules\n-----\n\n"));
for (i = 1; i <= nrules; i++) for (i = 1; i <= nrules; i++)
@@ -567,6 +478,7 @@ dump_grammar (void)
} }
fprintf (foutput, "\n\n"); fprintf (foutput, "\n\n");
} }
#endif #endif
@@ -590,9 +502,65 @@ print_notices (void)
if (nuseless_productions > 0) if (nuseless_productions > 0)
{ {
fprintf (stderr, _("%d useless rule%s"), fprintf (stderr, _("%d useless rule%s"),
nuseless_productions, nuseless_productions, (nuseless_productions == 1 ? "" : "s"));
(nuseless_productions == 1 ? "" : "s"));
} }
fprintf (stderr, "\n"); fprintf (stderr, "\n");
fflush (stderr); fflush (stderr);
} }
void
reduce_grammar (void)
{
bool reduced;
/* 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);
useless_nonterminals ();
inaccessable_symbols ();
reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0);
if (verboseflag)
print_results ();
if (reduced == FALSE)
goto done_reducing;
print_notices ();
if (!BITISSET (N, start_symbol - ntokens))
fatal (_("Start symbol %s does not derive any sentence"),
tags[start_symbol]);
reduce_grammar_tables ();
#if 0
if (verboseflag)
{
fprintf (foutput, "REDUCED GRAMMAR\n\n");
dump_grammar ();
}
#endif
statisticsflag = FALSE; /* someday getopts should handle this */
if (statisticsflag == TRUE)
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);
}

11
src/system.h
View File

@@ -148,3 +148,14 @@ extern int errno;
#define SETBIT(x, i) ((x)[(i)/BITS_PER_WORD] |= (1<<((i) % BITS_PER_WORD))) #define SETBIT(x, i) ((x)[(i)/BITS_PER_WORD] |= (1<<((i) % BITS_PER_WORD)))
#define RESETBIT(x, i) ((x)[(i)/BITS_PER_WORD] &= ~(1<<((i) % BITS_PER_WORD))) #define RESETBIT(x, i) ((x)[(i)/BITS_PER_WORD] &= ~(1<<((i) % BITS_PER_WORD)))
#define BITISSET(x, i) (((x)[(i)/BITS_PER_WORD] & (1<<((i) % BITS_PER_WORD))) != 0) #define BITISSET(x, i) (((x)[(i)/BITS_PER_WORD] & (1<<((i) % BITS_PER_WORD))) != 0)
/*-----------.
| Booleans. |
`-----------*/
#ifndef TRUE
# define TRUE (1)
# define FALSE (0)
#endif
typedef int bool;