X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/613f5e1a895b0742c9b6c5e9461e4cf3f7389d7e..dd31e17d7e415d3be8fc603f752f7e975297bcc2:/src/closure.c diff --git a/src/closure.c b/src/closure.c index 02d275a7..929aa777 100644 --- a/src/closure.c +++ b/src/closure.c @@ -1,38 +1,40 @@ -/* Subroutines for bison - Copyright (C) 1984, 1989, 2000, 2001, 2002 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 <http://www.gnu.org/licenses/>. */ +#include <config.h> #include "system.h" -#include "quotearg.h" -#include "bitset.h" -#include "bitsetv.h" -#include "bitsetv-print.h" + +#include <bitset.h> +#include <bitsetv-print.h> +#include <bitsetv.h> + +#include "closure.h" +#include "derives.h" #include "getargs.h" -#include "symtab.h" #include "gram.h" #include "reader.h" -#include "closure.h" -#include "derives.h" +#include "symtab.h" /* NITEMSET is the size of the array ITEMSET. */ -item_number_t *itemset; -int nritemset; +item_number *itemset; +size_t nitemset; static bitset ruleset; @@ -50,16 +52,16 @@ static bitsetv firsts = NULL; `-----------------*/ static void -print_closure (const char *title, item_number_t *array, size_t size) +print_closure (char const *title, item_number *array, size_t size) { size_t i; fprintf (stderr, "Closure: %s\n", title); for (i = 0; i < size; ++i) { - item_number_t *rp; + item_number *rp; fprintf (stderr, " %2d: .", array[i]); for (rp = &ritem[array[i]]; *rp >= 0; ++rp) - fprintf (stderr, " %s", symbols[*rp]->tag); + fprintf (stderr, " %s", symbols[*rp]->tag); fprintf (stderr, " (rule %d)\n", -*rp - 1); } fputs ("\n\n", stderr); @@ -69,7 +71,7 @@ print_closure (const char *title, item_number_t *array, size_t size) static void print_firsts (void) { - symbol_number_t i, j; + symbol_number i, j; fprintf (stderr, "FIRSTS\n"); for (i = ntokens; i < nsyms; i++) @@ -77,10 +79,10 @@ print_firsts (void) 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, "\t\t%s\n", + symbols[j + ntokens]->tag); + } } fprintf (stderr, "\n\n"); } @@ -90,7 +92,7 @@ static void print_fderives (void) { int i; - rule_number_t r; + rule_number r; fprintf (stderr, "FDERIVES\n"); for (i = ntokens; i < nsyms; i++) @@ -98,13 +100,10 @@ print_fderives (void) bitset_iterator iter; fprintf (stderr, "\t%s derives\n", symbols[i]->tag); BITSET_FOR_EACH (iter, FDERIVES (i), r, 0) - { - item_number_t *rhsp = NULL; - fprintf (stderr, "\t\t%d:", r - 1); - for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp) - fprintf (stderr, " %s", symbols[*rhsp]->tag); - fputc ('\n', stderr); - } + { + fprintf (stderr, "\t\t%3d ", r); + rule_rhs_print (&rules[r], stderr); + } } fprintf (stderr, "\n\n"); } @@ -123,25 +122,25 @@ print_fderives (void) static void set_firsts (void) { - symbol_number_t i, j; + symbol_number i, j; firsts = bitsetv_create (nvars, nvars, BITSET_FIXED); for (i = ntokens; i < nsyms; i++) - for (j = 0; derives[i][j] >= 0; ++j) + for (j = 0; derives[i - ntokens][j]; ++j) { - int symbol = rules[derives[i][j]].rhs[0]; - if (ISVAR (symbol)) - bitset_set (FIRSTS (i), symbol - ntokens); + item_number sym = derives[i - ntokens][j]->rhs[0]; + if (ISVAR (sym)) + bitset_set (FIRSTS (i), sym - ntokens); } - if (trace_flag) + if (trace_flag & trace_sets) bitsetv_matrix_dump (stderr, "RTC: Firsts Input", firsts); bitsetv_reflexive_transitive_closure (firsts); - if (trace_flag) + if (trace_flag & trace_sets) bitsetv_matrix_dump (stderr, "RTC: Firsts Output", firsts); - if (trace_flag) + if (trace_flag & trace_sets) print_firsts (); } @@ -158,20 +157,20 @@ set_firsts (void) static void set_fderives (void) { - symbol_number_t i, j; - rule_number_t k; + symbol_number i, j; + rule_number k; - fderives = bitsetv_create (nvars, nrules + 1, BITSET_FIXED); + fderives = bitsetv_create (nvars, nrules, BITSET_FIXED); set_firsts (); for (i = ntokens; i < nsyms; ++i) for (j = ntokens; j < nsyms; ++j) if (bitset_test (FIRSTS (i), j - ntokens)) - for (k = 0; derives[j][k] > 0; ++k) - bitset_set (FDERIVES (i), derives[j][k]); + for (k = 0; derives[j - ntokens][k]; ++k) + bitset_set (FDERIVES (i), derives[j - ntokens][k]->number); - if (trace_flag) + if (trace_flag & trace_sets) print_fderives (); bitsetv_free (firsts); @@ -180,11 +179,11 @@ set_fderives (void) void -new_closure (int n) +new_closure (unsigned int n) { - itemset = XCALLOC (item_number_t, n); + itemset = xnmalloc (n, sizeof *itemset); - ruleset = bitset_create (nrules + 1, BITSET_FIXED); + ruleset = bitset_create (nrules, BITSET_FIXED); set_fderives (); } @@ -192,17 +191,17 @@ new_closure (int n) void -closure (item_number_t *core, int n) +closure (item_number *core, size_t n) { /* Index over CORE. */ - int c; + size_t c; /* A bit index over RULESET. */ - rule_number_t ruleno; + rule_number ruleno; bitset_iterator iter; - if (trace_flag) + if (trace_flag & trace_sets) print_closure ("input", core, n); bitset_zero (ruleset); @@ -211,37 +210,39 @@ closure (item_number_t *core, int n) if (ISVAR (ritem[core[c]])) bitset_or (ruleset, ruleset, FDERIVES (ritem[core[c]])); - nritemset = 0; + /* 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) { - item_number_t itemno = rules[ruleno].rhs - ritem; + item_number itemno = rules[ruleno].rhs - ritem; while (c < n && core[c] < itemno) - { - itemset[nritemset] = core[c]; - nritemset++; - c++; - } - itemset[nritemset] = itemno; - nritemset++; + { + itemset[nitemset] = core[c]; + nitemset++; + c++; + } + itemset[nitemset] = itemno; + nitemset++; }; while (c < n) { - itemset[nritemset] = core[c]; - nritemset++; + itemset[nitemset] = core[c]; + nitemset++; c++; } - if (trace_flag) - print_closure ("output", itemset, nritemset); + if (trace_flag & trace_sets) + print_closure ("output", itemset, nitemset); } void free_closure (void) { - XFREE (itemset); + free (itemset); bitset_free (ruleset); bitsetv_free (fderives); }