X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/97650f4efc420eb5eb0af124f28987875e10428a..b25d88f6d2e2f4b59927aacecdc0a9e44a34b5d9:/src/state.c?ds=inline diff --git a/src/state.c b/src/state.c index 512907ff..846bdae5 100644 --- a/src/state.c +++ b/src/state.c @@ -35,12 +35,12 @@ | Create a new array of N shifts/gotos. | `---------------------------------------*/ -#define TRANSITIONS_ALLOC(Nshifts) \ - (transitions_t *) xcalloc ((unsigned) (sizeof (transitions_t) \ - + (Nshifts - 1) * sizeof (state_number_t)), 1) +#define TRANSITIONS_ALLOC(Num) \ + (transitions_t *) xcalloc ((sizeof (transitions_t) \ + + (Num - 1) * sizeof (state_t *)), 1) static transitions_t * -transitions_new (int num, state_number_t *the_states) +transitions_new (int num, state_t **the_states) { transitions_t *res = TRANSITIONS_ALLOC (num); res->num = num; @@ -60,7 +60,7 @@ 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 states[shifts->states[j]]; + return shifts->states[j]; abort (); } @@ -74,25 +74,17 @@ transitions_to (transitions_t *shifts, symbol_number_t s) | Create a new array of N errs. | `-------------------------------*/ -#define ERRS_ALLOC(Nerrs) \ - (errs_t *) xcalloc ((unsigned) (sizeof (errs_t) \ - + (Nerrs - 1) * sizeof (symbol_number_t)), 1) +#define ERRS_ALLOC(Nerrs) \ + (errs_t *) xcalloc ((sizeof (errs_t) \ + + (Nerrs - 1) * sizeof (symbol_t *)), 1) errs_t * -errs_new (int n) +errs_new (int num, symbol_t **tokens) { - errs_t *res = ERRS_ALLOC (n); - res->num = n; - return res; -} - - -errs_t * -errs_dup (errs_t *src) -{ - errs_t *res = errs_new (src->num); - memcpy (res->symbols, src->symbols, src->num * sizeof (src->symbols[0])); + errs_t *res = ERRS_ALLOC (num); + res->num = num; + memcpy (res->symbols, tokens, num * sizeof (tokens[0])); return res; } @@ -108,16 +100,17 @@ errs_dup (errs_t *src) | Create a new array of N reductions. | `-------------------------------------*/ -#define REDUCTIONS_ALLOC(Nreductions) \ - (reductions_t *) xcalloc ((unsigned) (sizeof (reductions_t) \ - + (Nreductions - 1) * sizeof (rule_number_t)), 1) +#define REDUCTIONS_ALLOC(Nreductions) \ + (reductions_t *) xcalloc ((sizeof (reductions_t) \ + + (Nreductions - 1) * sizeof (rule_t *)), 1) static reductions_t * -reductions_new (int nreductions, short *reductions) +reductions_new (int num, rule_t **reductions) { - reductions_t *res = REDUCTIONS_ALLOC (nreductions); - res->num = nreductions; - memcpy (res->rules, reductions, nreductions * sizeof (reductions[0])); + reductions_t *res = REDUCTIONS_ALLOC (num); + res->num = num; + memcpy (res->rules, reductions, num * sizeof (reductions[0])); + res->lookaheads = NULL; return res; } @@ -130,16 +123,17 @@ reductions_new (int nreductions, short *reductions) state_number_t nstates = 0; /* FINAL_STATE is properly set by new_state when it recognizes its - accessing symbol: EOF. */ + accessing symbol: $end. */ state_t *final_state = NULL; #define STATE_ALLOC(Nitems) \ - (state_t *) xcalloc ((unsigned) (sizeof (state_t) \ - + (Nitems - 1) * sizeof (item_number_t)), 1) + (state_t *) xcalloc ((sizeof (state_t) \ + + (Nitems - 1) * sizeof (item_number_t)), 1) -/*------------------------------------------------------------. -| Create a new state with ACCESSING_SYMBOL, for those items. | -`------------------------------------------------------------*/ +/*------------------------------------------------------------------. +| Create a new state with ACCESSING_SYMBOL, for those items. Store | +| it in the state hash table. | +`------------------------------------------------------------------*/ state_t * state_new (symbol_number_t accessing_symbol, @@ -147,8 +141,7 @@ state_new (symbol_number_t accessing_symbol, { state_t *res; - if (nstates >= STATE_NUMBER_MAX) - fatal (_("too many states (max %d)"), STATE_NUMBER_MAX); + assert (nstates < STATE_NUMBER_MAX); res = STATE_ALLOC (core_size); res->accessing_symbol = accessing_symbol; @@ -159,18 +152,35 @@ state_new (symbol_number_t accessing_symbol, res->nitems = core_size; memcpy (res->items, core, core_size * sizeof (core[0])); + state_hash_insert (res); + return res; } -/*--------------------------. -| Set the shifts of STATE. | -`--------------------------*/ +/*-------------. +| 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 nshifts, state_number_t *shifts) +state_transitions_set (state_t *state, int num, state_t **transitions) { - state->shifts = transitions_new (nshifts, shifts); + assert (!state->transitions); + state->transitions = transitions_new (num, transitions); } @@ -179,9 +189,34 @@ state_transitions_set (state_t *state, int nshifts, state_number_t *shifts) `------------------------------*/ void -state_reductions_set (state_t *state, int nreductions, short *reductions) +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) { - state->reductions = reductions_new (nreductions, reductions); + assert (!state->errs); + state->errs = errs_new (num, tokens); } @@ -194,28 +229,21 @@ state_reductions_set (state_t *state, int nreductions, short *reductions) void state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out) { - int j, k; - int nlookaheads = 0; - /* Count the number of lookaheads corresponding to this rule. */ - for (j = 0; j < state->nlookaheads; ++j) - BITSET_EXECUTE (state->lookaheads[j], 0, k, - { - if (state->lookaheads_rule[j]->number == rule->number) - nlookaheads++; - }); + /* Find the reduction we are handling. */ + reductions_t *reds = state->reductions; + int red = state_reduction_find (state, rule); /* Print them if there are. */ - if (nlookaheads) + if (reds->lookaheads && red != -1) { + bitset_iterator biter; + int k; + int not_first = 0; fprintf (out, " ["); - for (j = 0; j < state->nlookaheads; ++j) - BITSET_EXECUTE (state->lookaheads[j], 0, k, - { - if (state->lookaheads_rule[j]->number == rule->number) - fprintf (out, "%s%s", - symbols[k]->tag, - --nlookaheads ? ", " : ""); - }); + BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0) + fprintf (out, "%s%s", + not_first++ ? ", " : "", + symbols[k]->tag); fprintf (out, "]"); } } @@ -237,13 +265,13 @@ state_compare (const state_t *s1, const state_t *s2) int i; if (s1->nitems != s2->nitems) - return FALSE; + return false; for (i = 0; i < s1->nitems; ++i) if (s1->items[i] != s2->items[i]) - return FALSE; + return false; - return TRUE; + return true; } static unsigned int @@ -325,13 +353,7 @@ void states_free (void) { state_number_t i; - for (i = 0; i < nstates; ++i) - { - free (states[i]->shifts); - XFREE (states[i]->reductions); - free (states[i]->errs); - free (states[i]); - } - XFREE (states); + state_free (states[i]); + free (states); }