X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/c49a8e71cec845d32366432b824a9317e4a80160..fbe01355c8bc8e2fd7314028008564dfa6e36647:/src/closure.c diff --git a/src/closure.c b/src/closure.c index ad349196..ab086342 100644 --- a/src/closure.c +++ b/src/closure.c @@ -1,127 +1,195 @@ /* Subroutines for bison - Copyright (C) 1984, 1989 Free Software Foundation, Inc. + Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc. -This file is part of Bison, the GNU Compiler Compiler. + This file is part of Bison, the GNU Compiler Compiler. -Bison is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. + Bison is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. -Bison is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + Bison is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. -You should have received a copy of the GNU General Public License -along with Bison; see the file COPYING. If not, write to -the Free Software Foundation, Inc., 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with Bison; see the file COPYING. If not, write to the Free + Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ +#include "system.h" +#include "getargs.h" +#include "gram.h" +#include "reader.h" +#include "closure.h" +#include "derives.h" +#include "warshall.h" -/* subroutines of file LR0.c. +/* ITEMSETSIZE is the size of the array ITEMSET. */ +short *itemset; +size_t itemsetsize; -Entry points: +static unsigned *ruleset; - closure (items, n) +/* internal data. See comments before set_fderives and set_firsts. */ +static unsigned *fderives; +static unsigned *firsts; -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. +#define FDERIVES(Symbol) (fderives + (Symbol) * rulesetsize) +#define FIRSTS(Symbol) (firsts + (Symbol) * varsetsize) -ruleset contains a bit for each rule. closure sets the bits -for all rules which could potentially describe the next input to be read. +/* number of words required to hold a bit for each rule */ +static int rulesetsize; -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. +/* number of words required to hold a bit for each variable */ +static int varsetsize; + - initialize_closure (n) +/*-----------------. +| Debugging code. | +`-----------------*/ -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. +static void +print_closure (int n) +{ + int i; + fprintf (stderr, "n = %d\n", n); + for (i = 0; i < itemsetsize; ++i) + fprintf (stderr, " %d\n", itemset[i]); + fprintf (stderr, "\n\n"); +} - finalize_closure () -Frees itemset, ruleset and internal data. +static void +print_firsts (void) +{ + int i; + int j; + unsigned *rowp; -*/ + fprintf (stderr, "FIRSTS\n"); -#include -#include "system.h" -#include "machine.h" -#include "alloc.h" -#include "gram.h" + for (i = ntokens; i < nsyms; i++) + { + fprintf (stderr, "\t%s firsts\n", tags[i]); + rowp = FIRSTS (i - ntokens); -extern short **derives; -extern char **tags; + for (j = 0; j < nvars; j++) + if (BITISSET (rowp, j)) + fprintf (stderr, "\t\t%d (%s)\n", j + ntokens, tags[j + ntokens]); + } + fprintf (stderr, "\n\n"); +} -void initialize_closure PARAMS((int)); -void set_fderives PARAMS((void)); -void set_firsts PARAMS((void)); -void closure PARAMS((short *, int)); -void finalize_closure PARAMS((void)); -extern void RTC PARAMS((unsigned *, int)); +static void +print_fderives (void) +{ + int i; + int j; + unsigned *rp; -short *itemset; -short *itemsetend; -static unsigned *ruleset; + fprintf (stderr, "FDERIVES\n"); -/* internal data. See comments before set_fderives and set_firsts. */ -static unsigned *fderives; -static unsigned *firsts; + for (i = ntokens; i < nsyms; i++) + { + fprintf (stderr, "\t%s derives\n", tags[i]); + rp = FDERIVES (i); -/* number of words required to hold a bit for each rule */ -static int rulesetsize; + for (j = 0; j <= nrules; j++) + if (BITISSET (rp, 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) +{ + unsigned *row; + int symbol; + short *sp; + int rowsize; -/* number of words required to hold a bit for each variable */ -static int varsetsize; + int i; + varsetsize = rowsize = WORDSIZE (nvars); -void -initialize_closure (int n) -{ - itemset = NEW2(n, short); + firsts = XCALLOC (unsigned, nvars * rowsize); - rulesetsize = WORDSIZE(nrules + 1); - ruleset = NEW2(rulesetsize, unsigned); + row = firsts; + for (i = ntokens; i < nsyms; i++) + { + sp = derives[i]; + while (*sp >= 0) + { + symbol = ritem[rule_table[*sp++].rhs]; + if (ISVAR (symbol)) + { + symbol -= ntokens; + SETBIT (row, symbol); + } + } - set_fderives(); -} + row += rowsize; + } + RTC (firsts, nvars); + 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 +/*-------------------------------------------------------------------. +| 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) { - register unsigned *rrow; - register unsigned *vrow; - register int j; - register unsigned cword; - register short *rp; - register int b; + unsigned *rrow; + unsigned *vrow; + int j; + unsigned cword; + short *rp; + int b; int ruleno; int i; - fderives = NEW2(nvars * rulesetsize, unsigned) - ntokens * rulesetsize; + fderives = XCALLOC (unsigned, nvars * rulesetsize) - ntokens * rulesetsize; - set_firsts(); + set_firsts (); - rrow = fderives + ntokens * rulesetsize; + rrow = FDERIVES (ntokens); for (i = ntokens; i < nsyms; i++) { - vrow = firsts + ((i - ntokens) * varsetsize); + vrow = FIRSTS (i - ntokens); cword = *vrow++; b = 0; for (j = ntokens; j < nsyms; j++) @@ -130,9 +198,7 @@ set_fderives (void) { rp = derives[j]; while ((ruleno = *rp++) > 0) - { - SETBIT(rrow, ruleno); - } + SETBIT (rrow, ruleno); } b++; @@ -146,126 +212,87 @@ set_fderives (void) rrow += rulesetsize; } -#ifdef DEBUG - print_fderives(); -#endif + if (trace_flag) + print_fderives (); - FREE(firsts); + XFREE (firsts); } + - - -/* 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. */ void -set_firsts (void) +new_closure (int n) { - register unsigned *row; -/* register int done; JF unused */ - register int symbol; - register short *sp; - register int rowsize; - - int i; + itemset = XCALLOC (short, n); - varsetsize = rowsize = WORDSIZE(nvars); - - firsts = NEW2(nvars * rowsize, unsigned); - - 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); - } - } + rulesetsize = WORDSIZE (nrules + 1); + ruleset = XCALLOC (unsigned, rulesetsize); - row += rowsize; - } - - RTC(firsts, nvars); - -#ifdef DEBUG - print_firsts(); -#endif + set_fderives (); } + void closure (short *core, int n) { - register int ruleno; - register unsigned word; - register short *csp; - register unsigned *dsp; - register unsigned *rsp; - - short *csend; - unsigned *rsend; - int symbol; + int ruleno; + short *csp; + int itemno; + int i; - rsp = ruleset; - rsend = ruleset + rulesetsize; - csend = core + n; + if (trace_flag) + { + fprintf (stderr, "Entering closure (items = {"); + for (i = 0; i < n; ++i) + fprintf (stderr, " %d ", core[i]); + fprintf (stderr, "}, nitems = %d)\n", n); + } if (n == 0) { - dsp = fderives + start_symbol * rulesetsize; - while (rsp < rsend) - *rsp++ = *dsp++; + for (i = 0; i < rulesetsize; ++i) + ruleset[i] = FDERIVES (start_symbol)[i]; } else { - while (rsp < rsend) - *rsp++ = 0; + for (i = 0; i < rulesetsize; ++i) + ruleset[i] = 0; - csp = core; - while (csp < csend) + for (i = 0; i < n; ++i) { - symbol = ritem[*csp++]; - if (ISVAR(symbol)) + int symbol = ritem[core[i]]; + if (ISVAR (symbol)) { - dsp = fderives + symbol * rulesetsize; - rsp = ruleset; - while (rsp < rsend) - *rsp++ |= *dsp++; + int j; + for (j = 0; j < rulesetsize; ++j) + ruleset[j] |= FDERIVES (symbol)[j]; } } } ruleno = 0; - itemsetend = itemset; + itemsetsize = 0; csp = core; - rsp = ruleset; - while (rsp < rsend) + for (i = 0; i < rulesetsize; ++i) { - word = *rsp++; + int word = ruleset[i]; if (word == 0) { ruleno += BITS_PER_WORD; } else { - register int b; + 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; + itemno = rule_table[ruleno].rhs; + while (csp < (core + n) && *csp < itemno) + itemset[itemsetsize++] = *csp++; + itemset[itemsetsize++] = itemno; } ruleno++; @@ -273,80 +300,18 @@ closure (short *core, int n) } } - while (csp < csend) - *itemsetend++ = *csp++; - -#ifdef DEBUG - print_closure(n); -#endif -} - - -void -finalize_closure (void) -{ - FREE(itemset); - FREE(ruleset); - FREE(fderives + ntokens * rulesetsize); -} - - - -#ifdef DEBUG + while (csp < (core + n)) + itemset[itemsetsize++] = *csp++; -print_closure(n) -int n; -{ - register short *isp; - - printf("\n\nn = %d\n\n", n); - for (isp = itemset; isp < itemsetend; isp++) - printf(" %d\n", *isp); + if (trace_flag) + print_closure (n); } void -print_firsts (void) +free_closure (void) { - register int i; - register int j; - register unsigned *rowp; - - printf(_("\n\n\nFIRSTS\n\n")); - - for (i = ntokens; i < nsyms; i++) - { - printf(_("\n\n%s firsts\n\n"), tags[i]); - - rowp = firsts + ((i - ntokens) * varsetsize); - - for (j = 0; j < nvars; j++) - if (BITISSET (rowp, j)) - printf(" %s\n", tags[j + ntokens]); - } + XFREE (itemset); + XFREE (ruleset); + XFREE (fderives + ntokens * rulesetsize); } - - -void -print_fderives (void) -{ - register int i; - register int j; - register unsigned *rp; - - printf(_("\n\n\nFDERIVES\n")); - - for (i = ntokens; i < nsyms; i++) - { - 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); - } - - fflush(stdout); -} - -#endif