X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/fb9087861fd4b7de68fb8e86d08d4f07fd77238d..a68b1f237e63c96ee905916424013f79d01908ba:/src/closure.c diff --git a/src/closure.c b/src/closure.c index ac37b2c0..d9bc5ffa 100644 --- a/src/closure.c +++ b/src/closure.c @@ -1,49 +1,50 @@ -/* Subroutines for bison - Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc. +/* Closures for Bison + + Copyright (C) 1984, 1989, 2000-2002, 2004-2005, 2007, 2009-2012 Free + Software Foundation, Inc. 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. + This program 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 3 of the License, 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. + This program 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. */ + along with this program. If not, see . */ +#include #include "system.h" + +#include +#include +#include + +#include "closure.h" +#include "derives.h" #include "getargs.h" #include "gram.h" #include "reader.h" -#include "closure.h" -#include "derives.h" -#include "warshall.h" +#include "symtab.h" -/* ITEMSETSIZE is the size of the array ITEMSET. */ -short *itemset; -size_t itemsetsize; +/* NITEMSET is the size of the array ITEMSET. */ +item_number *itemset; +size_t nitemset; -static unsigned *ruleset; +static bitset ruleset; /* internal data. See comments before set_fderives and set_firsts. */ -static unsigned *fderives; -static unsigned *firsts; - -#define FDERIVES(Symbol) (fderives + (Symbol) * rulesetsize) -#define FIRSTS(Symbol) (firsts + (Symbol) * varsetsize) +static bitsetv fderives = NULL; +static bitsetv firsts = NULL; -/* 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; +/* Retrieve the FDERIVES/FIRSTS sets of the nonterminals numbered Var. */ +#define FDERIVES(Var) fderives[(Var) - ntokens] +#define FIRSTS(Var) firsts[(Var) - ntokens] /*-----------------. @@ -51,34 +52,37 @@ static int varsetsize; `-----------------*/ static void -print_closure (int n) +print_closure (char const *title, item_number *array, size_t size) { - int i; - fprintf (stderr, "n = %d\n", n); - for (i = 0; i < itemsetsize; ++i) - fprintf (stderr, " %d\n", itemset[i]); - fprintf (stderr, "\n\n"); + size_t i; + fprintf (stderr, "Closure: %s\n", title); + for (i = 0; i < size; ++i) + { + item_number *rp; + fprintf (stderr, " %2d: .", array[i]); + for (rp = &ritem[array[i]]; *rp >= 0; ++rp) + fprintf (stderr, " %s", symbols[*rp]->tag); + fprintf (stderr, " (rule %d)\n", -*rp - 1); + } + fputs ("\n\n", stderr); } static void print_firsts (void) { - int i; - int j; - unsigned *rowp; + symbol_number i, j; fprintf (stderr, "FIRSTS\n"); - for (i = ntokens; i < nsyms; i++) { - fprintf (stderr, "\t%s firsts\n", tags[i]); - - rowp = FIRSTS (i - ntokens); - - for (j = 0; j < nvars; j++) - if (BITISSET (rowp, j)) - fprintf (stderr, "\t\t%d (%s)\n", j + ntokens, tags[j + ntokens]); + bitset_iterator iter; + fprintf (stderr, "\t%s firsts\n", symbols[i]->tag); + BITSET_FOR_EACH (iter, FIRSTS (i), j, 0) + { + fprintf (stderr, "\t\t%s\n", + symbols[j + ntokens]->tag); + } } fprintf (stderr, "\n\n"); } @@ -88,67 +92,55 @@ static void print_fderives (void) { int i; - int j; - unsigned *rp; + rule_number r; fprintf (stderr, "FDERIVES\n"); - for (i = ntokens; i < nsyms; i++) { - fprintf (stderr, "\t%s derives\n", tags[i]); - rp = FDERIVES (i); - - for (j = 0; j <= nrules; j++) - if (BITISSET (rp, j)) - fprintf (stderr, "\t\t%d (%s)\n", j, tags[j]); + bitset_iterator iter; + fprintf (stderr, "\t%s derives\n", symbols[i]->tag); + BITSET_FOR_EACH (iter, FDERIVES (i), r, 0) + { + fprintf (stderr, "\t\t%3d ", r); + rule_rhs_print (&rules[r], 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. | -`-------------------------------------------------------------------*/ +/*------------------------------------------------------------------. +| Set FIRSTS to be an NVARS array of NVARS bitsets 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] in first[5 - ntokens] (= FIRST | +| (5)) is set. | +`------------------------------------------------------------------*/ static void set_firsts (void) { - unsigned *row; - int symbol; - short *sp; - int rowsize; + symbol_number i, j; - int i; + firsts = bitsetv_create (nvars, nvars, BITSET_FIXED); - varsetsize = rowsize = WORDSIZE (nvars); - - firsts = XCALLOC (unsigned, nvars * rowsize); - - 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); - } - } - - row += rowsize; - } - - RTC (firsts, nvars); - - if (trace_flag) + for (j = 0; derives[i - ntokens][j]; ++j) + { + item_number sym = derives[i - ntokens][j]->rhs[0]; + if (ISVAR (sym)) + bitset_set (FIRSTS (i), sym - ntokens); + } + + if (trace_flag & trace_sets) + bitsetv_matrix_dump (stderr, "RTC: Firsts Input", firsts); + bitsetv_reflexive_transitive_closure (firsts); + if (trace_flag & trace_sets) + bitsetv_matrix_dump (stderr, "RTC: Firsts Output", firsts); + + if (trace_flag & trace_sets) print_firsts (); } @@ -165,61 +157,33 @@ set_firsts (void) static void set_fderives (void) { - unsigned *rrow; - unsigned *vrow; - int j; - unsigned cword; - short *rp; - int b; - - int ruleno; - int i; + symbol_number i, j; + rule_number k; - fderives = XCALLOC (unsigned, nvars * rulesetsize) - ntokens * rulesetsize; + fderives = bitsetv_create (nvars, nrules, BITSET_FIXED); set_firsts (); - rrow = FDERIVES (ntokens); + for (i = ntokens; i < nsyms; ++i) + for (j = ntokens; j < nsyms; ++j) + if (bitset_test (FIRSTS (i), j - ntokens)) + for (k = 0; derives[j - ntokens][k]; ++k) + bitset_set (FDERIVES (i), derives[j - ntokens][k]->number); - for (i = ntokens; i < nsyms; i++) - { - vrow = FIRSTS (i - ntokens); - 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; - } - - if (trace_flag) + if (trace_flag & trace_sets) print_fderives (); - XFREE (firsts); + bitsetv_free (firsts); } + void -new_closure (int n) +new_closure (unsigned int n) { - itemset = XCALLOC (short, n); + itemset = xnmalloc (n, sizeof *itemset); - rulesetsize = WORDSIZE (nrules + 1); - ruleset = XCALLOC (unsigned, rulesetsize); + ruleset = bitset_create (nrules, BITSET_FIXED); set_fderives (); } @@ -227,85 +191,58 @@ new_closure (int n) void -closure (short *core, int n) +closure (item_number *core, size_t n) { - int ruleno; - short *csp; + /* Index over CORE. */ + size_t c; - int itemno; - int i; + /* A bit index over RULESET. */ + rule_number ruleno; - 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); - } + bitset_iterator iter; - if (n == 0) - { - for (i = 0; i < rulesetsize; ++i) - ruleset[i] = FDERIVES (start_symbol)[i]; - } - else - { - for (i = 0; i < rulesetsize; ++i) - ruleset[i] = 0; + if (trace_flag & trace_sets) + print_closure ("input", core, n); - for (i = 0; i < n; ++i) - { - int symbol = ritem[core[i]]; - if (ISVAR (symbol)) - { - int j; - for (j = 0; j < rulesetsize; ++j) - ruleset[j] |= FDERIVES (symbol)[j]; - } - } - } + bitset_zero (ruleset); + + for (c = 0; c < n; ++c) + if (ISVAR (ritem[core[c]])) + bitset_or (ruleset, ruleset, FDERIVES (ritem[core[c]])); - ruleno = 0; - itemsetsize = 0; - csp = core; - for (i = 0; i < rulesetsize; ++i) + /* core is sorted on item index in ritem, which is sorted on rule number. + Compute itemset with the same sort. */ + nitemset = 0; + c = 0; + BITSET_FOR_EACH (iter, ruleset, ruleno, 0) { - int word = ruleset[i]; - if (word == 0) - { - ruleno += BITS_PER_WORD; - } - else + item_number itemno = rules[ruleno].rhs - ritem; + while (c < n && core[c] < itemno) { - int b; - - for (b = 0; b < BITS_PER_WORD; b++) - { - if (word & (1 << b)) - { - itemno = rule_table[ruleno].rhs; - while (csp < (core + n) && *csp < itemno) - itemset[itemsetsize++] = *csp++; - itemset[itemsetsize++] = itemno; - } - - ruleno++; - } + itemset[nitemset] = core[c]; + nitemset++; + c++; } - } + itemset[nitemset] = itemno; + nitemset++; + }; - while (csp < (core + n)) - itemset[itemsetsize++] = *csp++; + while (c < n) + { + itemset[nitemset] = core[c]; + nitemset++; + c++; + } - if (trace_flag) - print_closure (n); + if (trace_flag & trace_sets) + print_closure ("output", itemset, nitemset); } void free_closure (void) { - XFREE (itemset); - XFREE (ruleset); - XFREE (fderives + ntokens * rulesetsize); + free (itemset); + bitset_free (ruleset); + bitsetv_free (fderives); }