X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/17ee7397a87c4c4ccd45f956e0b88b824a3689f9..728c4be290a95081c272ca917c54987135cde7e3:/src/state.c diff --git a/src/state.c b/src/state.c index 3ff2a261..3ba592bf 100644 --- a/src/state.c +++ b/src/state.c @@ -1,5 +1,7 @@ /* Type definitions for nondeterministic finite state machine for Bison. - Copyright (C) 2001, 2002 Free Software Foundation, Inc. + + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software + Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -15,10 +17,10 @@ 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. */ - + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ +#include #include "system.h" #include @@ -33,38 +35,36 @@ `-------------------*/ -/*---------------------------------------. -| Create a new array of N shifts/gotos. | -`---------------------------------------*/ - -#define TRANSITIONS_ALLOC(Num) \ - (transitions *) xcalloc ((sizeof (transitions) \ - + (Num - 1) * sizeof (state *)), \ - 1) +/*-----------------------------------------. +| Create a new array of NUM shifts/gotos. | +`-----------------------------------------*/ static transitions * transitions_new (int num, state **the_states) { - transitions *res = TRANSITIONS_ALLOC (num); + size_t states_size = num * sizeof *the_states; + transitions *res = xmalloc (offsetof (transitions, states) + states_size); res->num = num; - memcpy (res->states, the_states, num * sizeof (the_states[0])); + memcpy (res->states, the_states, states_size); return res; } -/*-------------------------------------------------------------------. -| Return the state such these TRANSITIONS contain a shift/goto to it | -| on S. Abort if none found. | -`-------------------------------------------------------------------*/ +/*-------------------------------------------------------. +| Return the state such that SHIFTS contain a shift/goto | +| to it on SYM. Abort if none found. | +`-------------------------------------------------------*/ state * -transitions_to (transitions *shifts, symbol_number s) +transitions_to (transitions *shifts, symbol_number sym) { int j; - for (j = 0; j < shifts->num; j++) - if (TRANSITION_SYMBOL (shifts, j) == s) - return shifts->states[j]; - abort (); + for (j = 0; ; j++) + { + aver (j < shifts->num); + if (TRANSITION_SYMBOL (shifts, j) == sym) + return shifts->states[j]; + } } @@ -73,20 +73,17 @@ transitions_to (transitions *shifts, symbol_number s) `--------------------*/ -/*-------------------------------. -| Create a new array of N errs. | -`-------------------------------*/ - -#define ERRS_ALLOC(Nerrs) \ - ((errs *) xcalloc ((sizeof (errs) + (Nerrs - 1) * sizeof (symbol *)), 1)) - +/*---------------------------------. +| Create a new array of NUM errs. | +`---------------------------------*/ errs * errs_new (int num, symbol **tokens) { - errs *res = ERRS_ALLOC (num); + size_t symbols_size = num * sizeof *tokens; + errs *res = xmalloc (offsetof (errs, symbols) + symbols_size); res->num = num; - memcpy (res->symbols, tokens, num * sizeof (tokens[0])); + memcpy (res->symbols, tokens, symbols_size); return res; } @@ -98,21 +95,18 @@ errs_new (int num, symbol **tokens) `-------------*/ -/*-------------------------------------. -| Create a new array of N reductions. | -`-------------------------------------*/ - -#define REDUCTIONS_ALLOC(Nreductions) \ - (reductions *) xcalloc ((sizeof (reductions) \ - + (Nreductions - 1) * sizeof (rule *)), 1) +/*---------------------------------------. +| Create a new array of NUM reductions. | +`---------------------------------------*/ static reductions * reductions_new (int num, rule **reds) { - reductions *res = REDUCTIONS_ALLOC (num); + size_t rules_size = num * sizeof *reds; + reductions *res = xmalloc (offsetof (reductions, rules) + rules_size); res->num = num; - memcpy (res->rules, reds, num * sizeof (reds[0])); - res->lookaheads = NULL; + res->lookahead_tokens = NULL; + memcpy (res->rules, reds, rules_size); return res; } @@ -128,10 +122,6 @@ state_number nstates = 0; accessing symbol: $end. */ state *final_state = NULL; -#define STATE_ALLOC(Nitems) \ - (state *) xcalloc ((sizeof (state) \ - + (Nitems - 1) * sizeof (item_number)), \ - 1) /*------------------------------------------------------------------. | Create a new state with ACCESSING_SYMBOL, for those items. Store | @@ -140,21 +130,24 @@ state *final_state = NULL; state * state_new (symbol_number accessing_symbol, - size_t core_size, item_number *core) + size_t nitems, item_number *core) { state *res; + size_t items_size = nitems * sizeof *core; - if (STATE_NUMBER_MAXIMUM <= nstates) - abort (); + aver (nstates < STATE_NUMBER_MAXIMUM); - res = STATE_ALLOC (core_size); + res = xmalloc (offsetof (state, items) + items_size); + res->number = nstates++; res->accessing_symbol = accessing_symbol; - res->number = nstates; - ++nstates; + res->transitions = NULL; + res->reductions = NULL; + res->errs = NULL; + res->consistent = 0; res->solved_conflicts = NULL; - res->nitems = core_size; - memcpy (res->items, core, core_size * sizeof (core[0])); + res->nitems = nitems; + memcpy (res->items, core, items_size); state_hash_insert (res); @@ -183,8 +176,7 @@ state_free (state *s) void state_transitions_set (state *s, int num, state **trans) { - if (s->transitions) - abort (); + aver (!s->transitions); s->transitions = transitions_new (num, trans); } @@ -196,8 +188,7 @@ state_transitions_set (state *s, int num, state **trans) void state_reductions_set (state *s, int num, rule **reds) { - if (s->reductions) - abort (); + aver (!s->reductions); s->reductions = reductions_new (num, reds); } @@ -221,44 +212,44 @@ state_reduction_find (state *s, rule *r) void state_errs_set (state *s, int num, symbol **tokens) { - if (s->errs) - abort (); + aver (!s->errs); s->errs = errs_new (num, tokens); } -/*-----------------------------------------------------. -| Print on OUT all the lookaheads such that S wants to | -| reduce R. | -`-----------------------------------------------------*/ +/*--------------------------------------------------. +| Print on OUT all the lookahead tokens such that S | +| wants to reduce R. | +`--------------------------------------------------*/ void -state_rule_lookaheads_print (state *s, rule *r, FILE *out) +state_rule_lookahead_tokens_print (state *s, rule *r, FILE *out) { /* Find the reduction we are handling. */ reductions *reds = s->reductions; int red = state_reduction_find (s, r); /* Print them if there are. */ - if (reds->lookaheads && red != -1) + if (reds->lookahead_tokens && red != -1) { bitset_iterator biter; int k; - int not_first = 0; + char const *sep = ""; fprintf (out, " ["); - BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0) - fprintf (out, "%s%s", - not_first++ ? ", " : "", - symbols[k]->tag); + BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0) + { + fprintf (out, "%s%s", sep, symbols[k]->tag); + sep = ", "; + } fprintf (out, "]"); } } -/*----------------------. +/*---------------------. | A state hash table. | -`----------------------*/ +`---------------------*/ /* Initial capacity of states hash table. */ #define HT_INITIAL_CAPACITY 257 @@ -266,10 +257,10 @@ state_rule_lookaheads_print (state *s, rule *r, FILE *out) static struct hash_table *state_table = NULL; /* Two states are equal if they have the same core items. */ -static bool +static inline bool state_compare (state const *s1, state const *s2) { - int i; + size_t i; if (s1->nitems != s2->nitems) return false; @@ -281,17 +272,29 @@ state_compare (state const *s1, state const *s2) return true; } -static unsigned int -state_hash (state const *s, unsigned int tablesize) +static bool +state_comparator (void const *s1, void const *s2) +{ + return state_compare (s1, s2); +} + +static inline size_t +state_hash (state const *s, size_t tablesize) { /* Add up the state's item numbers to get a hash key. */ - int key = 0; - int i; + size_t key = 0; + size_t i; for (i = 0; i < s->nitems; ++i) key += s->items[i]; return key % tablesize; } +static size_t +state_hasher (void const *s, size_t tablesize) +{ + return state_hash (s, tablesize); +} + /*-------------------------------. | Create the states hash table. | @@ -302,9 +305,9 @@ state_hash_new (void) { state_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, - (Hash_hasher) state_hash, - (Hash_comparator) state_compare, - (Hash_data_freer) NULL); + state_hasher, + state_comparator, + NULL); } @@ -336,18 +339,65 @@ state_hash_insert (state *s) `------------------------------------------------------------------*/ state * -state_hash_lookup (size_t core_size, item_number *core) +state_hash_lookup (size_t nitems, item_number *core) { - state *probe = STATE_ALLOC (core_size); + size_t items_size = nitems * sizeof *core; + state *probe = xmalloc (offsetof (state, items) + items_size); state *entry; - probe->nitems = core_size; - memcpy (probe->items, core, core_size * sizeof (core[0])); + probe->nitems = nitems; + memcpy (probe->items, core, items_size); entry = hash_lookup (state_table, probe); free (probe); return entry; } + +/*--------------------------------------------------------. +| Record S and all states reachable from S in REACHABLE. | +`--------------------------------------------------------*/ + +static void +state_record_reachable_states (state *s, bitset reachable) +{ + if (bitset_test (reachable, s->number)) + return; + bitset_set (reachable, s->number); + { + int i; + for (i = 0; i < s->transitions->num; ++i) + if (!TRANSITION_IS_DISABLED (s->transitions, i)) + state_record_reachable_states (s->transitions->states[i], reachable); + } +} + +void +state_remove_unreachable_states (state_number old_to_new[]) +{ + state_number nstates_reachable = 0; + bitset reachable = bitset_create (nstates, BITSET_FIXED); + state_record_reachable_states (states[0], reachable); + { + state_number i; + for (i = 0; i < nstates; ++i) + { + if (bitset_test (reachable, states[i]->number)) + { + states[nstates_reachable] = states[i]; + states[nstates_reachable]->number = nstates_reachable; + old_to_new[i] = nstates_reachable++; + } + else + { + state_free (states[i]); + old_to_new[i] = nstates; + } + } + } + nstates = nstates_reachable; + bitset_free (reachable); +} + /* All the decorated states, indexed by the state number. */ state **states = NULL;