X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/80dac38c5eb3b95412a6c99c9dbe976ac963c01b..d1a1114f7f257f89887ea5825ba0d896dfaa747b:/src/state.c diff --git a/src/state.c b/src/state.c index a1e83f38..71914025 100644 --- a/src/state.c +++ b/src/state.c @@ -1,5 +1,5 @@ /* Type definitions for nondeterministic finite state machine for bison, - Copyright 2001 Free Software Foundation, Inc. + Copyright (C) 2001, 2002 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -20,63 +20,341 @@ #include "system.h" +#include "hash.h" +#include "complain.h" +#include "gram.h" #include "state.h" -/*---------------------------------. -| Create a new array of N shitfs. | -`---------------------------------*/ -#define SHIFTS_ALLOC(Nshifts) \ - (shifts *) xcalloc ((unsigned) (sizeof (shifts) \ - + (Nshifts - 1) * sizeof (short)), 1) + /*-------------------. + | Shifts and Gotos. | + `-------------------*/ -shifts * -shifts_new (int n) + +/*---------------------------------------. +| Create a new array of N shifts/gotos. | +`---------------------------------------*/ + +#define TRANSITIONS_ALLOC(Num) \ + (transitions_t *) xcalloc ((sizeof (transitions_t) \ + + (Num - 1) * sizeof (state_t *)), 1) + +static transitions_t * +transitions_new (int num, state_t **the_states) { - shifts *res = SHIFTS_ALLOC (n); - res->nshifts = n; + transitions_t *res = TRANSITIONS_ALLOC (num); + res->num = num; + memcpy (res->states, the_states, num * sizeof (the_states[0])); return res; } +/*-------------------------------------------------------------------. +| Return the state such these TRANSITIONS contain a shift/goto to it | +| on SYMBOL. Aborts if none found. | +`-------------------------------------------------------------------*/ + +state_t * +transitions_to (transitions_t *shifts, symbol_number_t s) +{ + int j; + for (j = 0; j < shifts->num; j++) + if (TRANSITION_SYMBOL (shifts, j) == s) + return shifts->states[j]; + abort (); +} + + + /*--------------------. + | Error transitions. | + `--------------------*/ + + /*-------------------------------. | Create a new array of N errs. | `-------------------------------*/ -#define ERRS_ALLOC(Nerrs) \ - (errs *) xcalloc ((unsigned) (sizeof (errs) \ - + (Nerrs - 1) * sizeof (short)), 1) +#define ERRS_ALLOC(Nerrs) \ + (errs_t *) xcalloc ((sizeof (errs_t) \ + + (Nerrs - 1) * sizeof (symbol_t *)), 1) -errs * -errs_new (int n) +errs_t * +errs_new (int num, symbol_t **tokens) { - errs *res = ERRS_ALLOC (n); - res->nerrs = n; + errs_t *res = ERRS_ALLOC (num); + res->num = num; + memcpy (res->symbols, tokens, num * sizeof (tokens[0])); return res; } -errs * -errs_dup (errs *src) -{ - errs *res = errs_new (src->nerrs); - memcpy (res->errs, src->errs, src->nerrs); - return res; -} + + + /*-------------. + | Reductions. | + `-------------*/ + /*-------------------------------------. | Create a new array of N reductions. | `-------------------------------------*/ -#define REDUCTIONS_ALLOC(Nreductions) \ - (reductions *) xcalloc ((unsigned) (sizeof (reductions) \ - + (Nreductions - 1) * sizeof (short)), 1) +#define REDUCTIONS_ALLOC(Nreductions) \ + (reductions_t *) xcalloc ((sizeof (reductions_t) \ + + (Nreductions - 1) * sizeof (rule_t *)), 1) + +static reductions_t * +reductions_new (int num, rule_t **reductions) +{ + reductions_t *res = REDUCTIONS_ALLOC (num); + res->num = num; + memcpy (res->rules, reductions, num * sizeof (reductions[0])); + res->lookaheads = NULL; + return res; +} + + + + /*---------. + | States. | + `---------*/ + + +state_number_t nstates = 0; +/* FINAL_STATE is properly set by new_state when it recognizes its + accessing symbol: $end. */ +state_t *final_state = NULL; + +#define STATE_ALLOC(Nitems) \ + (state_t *) xcalloc ((sizeof (state_t) \ + + (Nitems - 1) * sizeof (item_number_t)), 1) + +/*------------------------------------------------------------------. +| Create a new state with ACCESSING_SYMBOL, for those items. Store | +| it in the state hash table. | +`------------------------------------------------------------------*/ -reductions * -reductions_new (int n) +state_t * +state_new (symbol_number_t accessing_symbol, + size_t core_size, item_number_t *core) { - reductions *res = REDUCTIONS_ALLOC (n); - res->nreds = n; + state_t *res; + + if (nstates >= STATE_NUMBER_MAX) + fatal (_("too many states (max %d)"), STATE_NUMBER_MAX); + + res = STATE_ALLOC (core_size); + res->accessing_symbol = accessing_symbol; + res->number = nstates; + ++nstates; + res->solved_conflicts = NULL; + + res->nitems = core_size; + memcpy (res->items, core, core_size * sizeof (core[0])); + + state_hash_insert (res); + return res; } + + +/*-------------. +| Free STATE. | +`-------------*/ + +static void +state_free (state_t *state) +{ + free (state->transitions); + free (state->reductions); + free (state->errs); + free (state); +} + + +/*-------------------------------. +| Set the transitions of STATE. | +`-------------------------------*/ + +void +state_transitions_set (state_t *state, int num, state_t **transitions) +{ + assert (!state->transitions); + state->transitions = transitions_new (num, transitions); +} + + +/*------------------------------. +| Set the reductions of STATE. | +`------------------------------*/ + +void +state_reductions_set (state_t *state, int num, rule_t **reductions) +{ + assert (!state->reductions); + state->reductions = reductions_new (num, reductions); +} + + +int +state_reduction_find (state_t *state, rule_t *rule) +{ + int i; + reductions_t *reds = state->reductions; + for (i = 0; i < reds->num; ++i) + if (reds->rules[i] == rule) + return i; + return -1; +} + + +/*------------------------. +| Set the errs of STATE. | +`------------------------*/ + +void +state_errs_set (state_t *state, int num, symbol_t **tokens) +{ + assert (!state->errs); + state->errs = errs_new (num, tokens); +} + + + +/*--------------------------------------------------------------. +| Print on OUT all the lookaheads such that this STATE wants to | +| reduce this RULE. | +`--------------------------------------------------------------*/ + +void +state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out) +{ + /* Find the reduction we are handling. */ + reductions_t *reds = state->reductions; + int red = state_reduction_find (state, rule); + + /* Print them if there are. */ + if (reds->lookaheads && red != -1) + { + bitset_iterator biter; + int k; + int not_first = 0; + fprintf (out, " ["); + BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0) + fprintf (out, "%s%s", + not_first++ ? ", " : "", + symbols[k]->tag); + fprintf (out, "]"); + } +} + + +/*----------------------. +| A state hash table. | +`----------------------*/ + +/* Initial capacity of states hash table. */ +#define HT_INITIAL_CAPACITY 257 + +static struct hash_table *state_table = NULL; + +/* Two states are equal if they have the same core items. */ +static bool +state_compare (const state_t *s1, const state_t *s2) +{ + int i; + + if (s1->nitems != s2->nitems) + return FALSE; + + for (i = 0; i < s1->nitems; ++i) + if (s1->items[i] != s2->items[i]) + return FALSE; + + return TRUE; +} + +static unsigned int +state_hash (const state_t *state, unsigned int tablesize) +{ + /* Add up the state's item numbers to get a hash key. */ + int key = 0; + int i; + for (i = 0; i < state->nitems; ++i) + key += state->items[i]; + return key % tablesize; +} + + +/*-------------------------------. +| Create the states hash table. | +`-------------------------------*/ + +void +state_hash_new (void) +{ + state_table = hash_initialize (HT_INITIAL_CAPACITY, + NULL, + (Hash_hasher) state_hash, + (Hash_comparator) state_compare, + (Hash_data_freer) NULL); +} + + +/*---------------------------------------------. +| Free the states hash table, not the states. | +`---------------------------------------------*/ + +void +state_hash_free (void) +{ + hash_free (state_table); +} + + +/*---------------------------------------. +| Insert STATE in the state hash table. | +`---------------------------------------*/ + +void +state_hash_insert (state_t *state) +{ + hash_insert (state_table, state); +} + + +/*------------------------------------------------------------------. +| Find the state associated to the CORE, and return it. If it does | +| not exist yet, return NULL. | +`------------------------------------------------------------------*/ + +state_t * +state_hash_lookup (size_t core_size, item_number_t *core) +{ + state_t *probe = STATE_ALLOC (core_size); + state_t *entry; + + probe->nitems = core_size; + memcpy (probe->items, core, core_size * sizeof (core[0])); + entry = hash_lookup (state_table, probe); + free (probe); + return entry; +} + +/* All the decorated states, indexed by the state number. */ +state_t **states = NULL; + + +/*----------------------. +| Free all the states. | +`----------------------*/ + +void +states_free (void) +{ + state_number_t i; + for (i = 0; i < nstates; ++i) + state_free (states[i]); + free (states); +}