X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/4a120d45e6a181ced2f24f2f6d23e2faa9fbd778..cb581495e689b4875c96eea8135f09d8a72eaacc:/src/closure.c diff --git a/src/closure.c b/src/closure.c index 401ddc5e..12bb5817 100644 --- a/src/closure.c +++ b/src/closure.c @@ -1,5 +1,5 @@ /* Subroutines for bison - Copyright (C) 1984, 1989, 2000 Free Software Foundation, Inc. + Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -18,345 +18,238 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ - -/* Subroutines of file LR0.c. - -Entry points: - - closure (items, n) - -Given a vector of item numbers items, of length n, set up ruleset and -itemset to indicate what rules could be run and which items could be -accepted when those items are the active ones. - -ruleset contains a bit for each rule. closure sets the bits for all -rules which could potentially describe the next input to be read. - -itemset is a vector of item numbers; itemsetend points to just beyond -the end of the part of it that is significant. closure places there -the indices of all items which represent units of input that could -arrive next. - - initialize_closure (n) - -Allocates the itemset and ruleset vectors, and precomputes useful data -so that closure can be called. n is the number of elements to -allocate for itemset. - - finalize_closure () - -Frees itemset, ruleset and internal data. - -*/ - -#include #include "system.h" -#include "machine.h" -#include "alloc.h" +#include "getargs.h" #include "gram.h" +#include "reader.h" +#include "closure.h" +#include "derives.h" +#include "warshall.h" - -extern short **derives; -extern char **tags; - -extern void initialize_closure PARAMS((int)); -extern void closure PARAMS((short *, int)); -extern void finalize_closure PARAMS((void)); - -static void set_fderives PARAMS((void)); -static void set_firsts PARAMS((void)); - -extern void RTC PARAMS((unsigned *, int)); - +/* NITEMSET is the size of the array ITEMSET. */ short *itemset; -short *itemsetend; +int nitemset; + static unsigned *ruleset; /* internal data. See comments before set_fderives and set_firsts. */ static unsigned *fderives; static unsigned *firsts; +/* Retrieve the FDERIVES/FIRSTS sets of the nonterminals numbered Var. */ +#define FDERIVES(Var) (fderives + ((Var) - ntokens) * rulesetsize) +#define FIRSTS(Var) (firsts + ((Var) - ntokens) * varsetsize) + /* number of words required to hold a bit for each rule */ static int rulesetsize; /* number of words required to hold a bit for each variable */ static int varsetsize; + -#ifdef DEBUG -static void print_closure PARAMS((int)); -static void print_fderives PARAMS((void)); -static void print_firsts PARAMS((void)); -#endif +/*-----------------. +| Debugging code. | +`-----------------*/ -void -initialize_closure (int n) +static void +print_closure (const char *title, short *array, size_t size) { - itemset = NEW2(n, short); - - rulesetsize = WORDSIZE(nrules + 1); - ruleset = NEW2(rulesetsize, unsigned); - - set_fderives(); + size_t i; + fprintf (stderr, "Closure: %s\n", title); + for (i = 0; i < size; ++i) + { + short *rp; + fprintf (stderr, " %2d: .", array[i]); + for (rp = &ritem[array[i]]; *rp > 0; ++rp) + fprintf (stderr, " %s", tags[*rp]); + fprintf (stderr, " (rule %d)\n", -*rp); + } + fputs ("\n\n", stderr); } - -/* set fderives to an nvars by nrules matrix of bits - indicating which rules can help derive the beginning of the data - for each nonterminal. For example, if symbol 5 can be derived as - the sequence of symbols 8 3 20, and one of the rules for deriving - symbol 8 is rule 4, then the [5 - ntokens, 4] bit in fderives is set. */ static void -set_fderives (void) +print_firsts (void) { - register unsigned *rrow; - register unsigned *vrow; - register int j; - register unsigned cword; - register short *rp; - register int b; - - int ruleno; - int i; - - fderives = NEW2(nvars * rulesetsize, unsigned) - ntokens * rulesetsize; - - set_firsts(); - - rrow = fderives + ntokens * rulesetsize; + int i, j; + fprintf (stderr, "FIRSTS\n"); for (i = ntokens; i < nsyms; i++) { - vrow = firsts + ((i - ntokens) * varsetsize); - cword = *vrow++; - b = 0; - for (j = ntokens; j < nsyms; j++) - { - if (cword & (1 << b)) - { - rp = derives[j]; - while ((ruleno = *rp++) > 0) - { - SETBIT(rrow, ruleno); - } - } - - b++; - if (b >= BITS_PER_WORD && j + 1 < nsyms) - { - cword = *vrow++; - b = 0; - } - } - - rrow += rulesetsize; + fprintf (stderr, "\t%s firsts\n", tags[i]); + for (j = 0; j < nvars; j++) + if (BITISSET (FIRSTS (i), j)) + fprintf (stderr, "\t\t%d (%s)\n", j + ntokens, tags[j + ntokens]); } - -#ifdef DEBUG - print_fderives(); -#endif - - FREE(firsts); + fprintf (stderr, "\n\n"); } +static void +print_fderives (void) +{ + int i; + int j; -/* set firsts to be an nvars by nvars bit matrix indicating which - items can represent the beginning of the input corresponding to - which other items. + fprintf (stderr, "FDERIVES\n"); - For example, if some rule expands symbol 5 into the sequence of - symbols 8 3 20, the symbol 8 can be the beginning of the data for - symbol 5, so the bit [8 - ntokens, 5 - ntokens] in firsts is - set. */ + for (i = ntokens; i < nsyms; i++) + { + fprintf (stderr, "\t%s derives\n", tags[i]); + for (j = 0; j <= nrules; j++) + if (BITISSET (FDERIVES (i), j)) + { + short *rhsp; + fprintf (stderr, "\t\t%d:", j); + for (rhsp = ritem + rule_table[j].rhs; *rhsp > 0; ++rhsp) + fprintf (stderr, " %s", tags[*rhsp]); + fputc ('\n', stderr); + } + } + fprintf (stderr, "\n\n"); +} + +/*-------------------------------------------------------------------. +| Set FIRSTS to be an NVARS by NVARS bit matrix indicating which | +| items can represent the beginning of the input corresponding to | +| which other items. | +| | +| For example, if some rule expands symbol 5 into the sequence of | +| symbols 8 3 20, the symbol 8 can be the beginning of the data for | +| symbol 5, so the bit [8 - ntokens, 5 - ntokens] in firsts is set. | +`-------------------------------------------------------------------*/ static void set_firsts (void) { - register unsigned *row; -/* register int done; JF unused */ - register int symbol; - register short *sp; - register int rowsize; + int i, j; - int i; - - varsetsize = rowsize = WORDSIZE(nvars); + varsetsize = WORDSIZE (nvars); - firsts = NEW2(nvars * rowsize, unsigned); + firsts = XCALLOC (unsigned, nvars * varsetsize); - row = firsts; for (i = ntokens; i < nsyms; i++) - { - sp = derives[i]; - while (*sp >= 0) - { - symbol = ritem[rrhs[*sp++]]; - if (ISVAR(symbol)) - { - symbol -= ntokens; - SETBIT(row, symbol); - } - } - - row += rowsize; - } + for (j = 0; derives[i][j] >= 0; ++j) + { + int symbol = ritem[rule_table[derives[i][j]].rhs]; + if (ISVAR (symbol)) + SETBIT (FIRSTS (i), symbol - ntokens); + } - RTC(firsts, nvars); + RTC (firsts, nvars); -#ifdef DEBUG - print_firsts (); -#endif + if (trace_flag) + print_firsts (); } +/*-------------------------------------------------------------------. +| Set FDERIVES to an NVARS by NRULES matrix of bits indicating which | +| rules can help derive the beginning of the data for each | +| nonterminal. | +| | +| For example, if symbol 5 can be derived as the sequence of symbols | +| 8 3 20, and one of the rules for deriving symbol 8 is rule 4, then | +| the [5 - NTOKENS, 4] bit in FDERIVES is set. | +`-------------------------------------------------------------------*/ -void -closure (short *core, int n) +static void +set_fderives (void) { - register int ruleno; - register unsigned word; - register short *csp; - register unsigned *dsp; - register unsigned *rsp; - - short *csend; - unsigned *rsend; - int symbol; - int itemno; + int i, j, k; - rsp = ruleset; - rsend = ruleset + rulesetsize; - csend = core + n; + fderives = XCALLOC (unsigned, nvars * rulesetsize); - if (n == 0) - { - dsp = fderives + start_symbol * rulesetsize; - while (rsp < rsend) - *rsp++ = *dsp++; - } - else - { - while (rsp < rsend) - *rsp++ = 0; - - csp = core; - while (csp < csend) - { - symbol = ritem[*csp++]; - if (ISVAR(symbol)) - { - dsp = fderives + symbol * rulesetsize; - rsp = ruleset; - while (rsp < rsend) - *rsp++ |= *dsp++; - } - } - } + set_firsts (); - ruleno = 0; - itemsetend = itemset; - csp = core; - rsp = ruleset; - while (rsp < rsend) - { - word = *rsp++; - if (word == 0) - { - ruleno += BITS_PER_WORD; - } - else - { - register int b; - - for (b = 0; b < BITS_PER_WORD; b++) - { - if (word & (1 << b)) - { - itemno = rrhs[ruleno]; - while (csp < csend && *csp < itemno) - *itemsetend++ = *csp++; - *itemsetend++ = itemno; - } - - ruleno++; - } - } - } + for (i = ntokens; i < nsyms; ++i) + for (j = ntokens; j < nsyms; ++j) + if (BITISSET (FIRSTS (i), j - ntokens)) + for (k = 0; derives[j][k] > 0; ++k) + SETBIT (FDERIVES (i), derives[j][k]); - while (csp < csend) - *itemsetend++ = *csp++; + if (trace_flag) + print_fderives (); -#ifdef DEBUG - print_closure(n); -#endif + XFREE (firsts); } - + void -finalize_closure (void) +new_closure (int n) { - FREE(itemset); - FREE(ruleset); - FREE(fderives + ntokens * rulesetsize); -} - - + itemset = XCALLOC (short, n); -#ifdef DEBUG + rulesetsize = WORDSIZE (nrules + 1); + ruleset = XCALLOC (unsigned, rulesetsize); -static void -print_closure(int n) -{ - register short *isp; - - printf ("\n\nn = %d\n\n", n); - for (isp = itemset; isp < itemsetend; isp++) - printf (" %d\n", *isp); + set_fderives (); } -static void -print_firsts (void) + +void +closure (short *core, int n) { - register int i; - register int j; - register unsigned *rowp; + /* Index over CORE. */ + int c; - printf ("\n\n\nFIRSTS\n\n"); + /* Index over RULESET. */ + int r; - for (i = ntokens; i < nsyms; i++) - { - printf ("\n\n%s firsts\n\n", tags[i]); + /* A bit index over RULESET. */ + int ruleno; - rowp = firsts + ((i - ntokens) * varsetsize); + if (trace_flag) + print_closure ("input", core, n); - for (j = 0; j < nvars; j++) - if (BITISSET (rowp, j)) - printf (" %s\n", tags[j + ntokens]); + if (n == 0) + { + for (r = 0; r < rulesetsize; ++r) + ruleset[r] = FDERIVES (start_symbol)[r]; } -} - - -static void -print_fderives (void) -{ - register int i; - register int j; - register unsigned *rp; + else + { + for (r = 0; r < rulesetsize; ++r) + ruleset[r] = 0; - printf ("\n\n\nFDERIVES\n"); + for (c = 0; c < n; ++c) + if (ISVAR (ritem[core[c]])) + for (r = 0; r < rulesetsize; ++r) + ruleset[r] |= FDERIVES (ritem[core[c]])[r]; + } - for (i = ntokens; i < nsyms; i++) + nitemset = 0; + c = 0; + for (ruleno = 0; ruleno < nrules + 1; ++ruleno) + if (BITISSET (ruleset, ruleno)) + { + int itemno = rule_table[ruleno].rhs; + while (c < n && core[c] < itemno) + { + itemset[nitemset] = core[c]; + nitemset++; + c++; + } + itemset[nitemset] = itemno; + nitemset++; + } + + while (c < n) { - printf ("\n\n%s derives\n\n", tags[i]); - rp = fderives + i * rulesetsize; - - for (j = 0; j <= nrules; j++) - if (BITISSET (rp, j)) - printf (" %d\n", j); + itemset[nitemset] = core[c]; + nitemset++; + c++; } - fflush(stdout); + if (trace_flag) + print_closure ("output", itemset, nitemset); } -#endif + +void +free_closure (void) +{ + XFREE (itemset); + XFREE (ruleset); + XFREE (fderives); +}