X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/c7ca99d4b03860bb258914fbc228272031eec77c..87ceef7346e3e217534007843d45f88d65ab3f04:/src/state.c?ds=sidebyside diff --git a/src/state.c b/src/state.c index 874c5863..3ff2a261 100644 --- a/src/state.c +++ b/src/state.c @@ -1,5 +1,5 @@ -/* Type definitions for nondeterministic finite state machine for bison, - Copyright (C) 2001, 2002 Free Software Foundation, Inc. +/* Type definitions for nondeterministic finite state machine for Bison. + Copyright (C) 2001, 2002 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -20,7 +20,9 @@ #include "system.h" -#include "hash.h" + +#include + #include "complain.h" #include "gram.h" #include "state.h" @@ -35,19 +37,35 @@ | Create a new array of N shifts/gotos. | `---------------------------------------*/ -#define SHIFTS_ALLOC(Nshifts) \ - (shifts *) xcalloc ((unsigned) (sizeof (shifts) \ - + (Nshifts - 1) * sizeof (short)), 1) +#define TRANSITIONS_ALLOC(Num) \ + (transitions *) xcalloc ((sizeof (transitions) \ + + (Num - 1) * sizeof (state *)), \ + 1) -shifts * -shifts_new (int n) +static transitions * +transitions_new (int num, state **the_states) { - shifts *res = SHIFTS_ALLOC (n); - res->nshifts = n; + transitions *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 S. Abort if none found. | +`-------------------------------------------------------------------*/ + +state * +transitions_to (transitions *shifts, symbol_number s) +{ + int j; + for (j = 0; j < shifts->num; j++) + if (TRANSITION_SYMBOL (shifts, j) == s) + return shifts->states[j]; + abort (); +} /*--------------------. @@ -59,25 +77,16 @@ shifts_new (int n) | Create a new array of N errs. | `-------------------------------*/ -#define ERRS_ALLOC(Nerrs) \ - (errs *) xcalloc ((unsigned) (sizeof (errs) \ - + (Nerrs - 1) * sizeof (short)), 1) - - -errs * -errs_new (int n) -{ - errs *res = ERRS_ALLOC (n); - res->nerrs = n; - return res; -} +#define ERRS_ALLOC(Nerrs) \ + ((errs *) xcalloc ((sizeof (errs) + (Nerrs - 1) * sizeof (symbol *)), 1)) errs * -errs_dup (errs *src) +errs_new (int num, symbol **tokens) { - errs *res = errs_new (src->nerrs); - memcpy (res->errs, src->errs, src->nerrs * sizeof (src->errs[0])); + errs *res = ERRS_ALLOC (num); + res->num = num; + memcpy (res->symbols, tokens, num * sizeof (tokens[0])); return res; } @@ -93,15 +102,17 @@ errs_dup (errs *src) | 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 *) xcalloc ((sizeof (reductions) \ + + (Nreductions - 1) * sizeof (rule *)), 1) -reductions * -reductions_new (int n) +static reductions * +reductions_new (int num, rule **reds) { - reductions *res = REDUCTIONS_ALLOC (n); - res->nreds = n; + reductions *res = REDUCTIONS_ALLOC (num); + res->num = num; + memcpy (res->rules, reds, num * sizeof (reds[0])); + res->lookaheads = NULL; return res; } @@ -112,27 +123,29 @@ reductions_new (int n) `---------*/ -state_number_t nstates = 0; +state_number nstates = 0; /* FINAL_STATE is properly set by new_state when it recognizes its - accessing symbol: EOF. */ -state_t *final_state = NULL; + accessing symbol: $end. */ +state *final_state = NULL; #define STATE_ALLOC(Nitems) \ - (state_t *) xcalloc ((unsigned) (sizeof (state_t) \ - + (Nitems - 1) * sizeof (item_number_t)), 1) + (state *) xcalloc ((sizeof (state) \ + + (Nitems - 1) * sizeof (item_number)), \ + 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, - size_t core_size, item_number_t *core) +state * +state_new (symbol_number accessing_symbol, + size_t core_size, item_number *core) { - state_t *res; + state *res; - if (nstates >= STATE_NUMBER_MAX) - fatal (_("too many states (max %d)"), STATE_NUMBER_MAX); + if (STATE_NUMBER_MAXIMUM <= nstates) + abort (); res = STATE_ALLOC (core_size); res->accessing_symbol = accessing_symbol; @@ -143,38 +156,101 @@ 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; } -/*--------------------------------------------------------------. -| Print on OUT all the lookaheads such that this STATE wants to | -| reduce this RULE. | -`--------------------------------------------------------------*/ +/*---------. +| Free S. | +`---------*/ + +static void +state_free (state *s) +{ + free (s->transitions); + free (s->reductions); + free (s->errs); + free (s); +} + + +/*---------------------------. +| Set the transitions of S. | +`---------------------------*/ + +void +state_transitions_set (state *s, int num, state **trans) +{ + if (s->transitions) + abort (); + s->transitions = transitions_new (num, trans); +} + + +/*--------------------------. +| Set the reductions of S. | +`--------------------------*/ + +void +state_reductions_set (state *s, int num, rule **reds) +{ + if (s->reductions) + abort (); + s->reductions = reductions_new (num, reds); +} + + +int +state_reduction_find (state *s, rule *r) +{ + int i; + reductions *reds = s->reductions; + for (i = 0; i < reds->num; ++i) + if (reds->rules[i] == r) + return i; + return -1; +} + + +/*--------------------. +| Set the errs of S. | +`--------------------*/ void -state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out) +state_errs_set (state *s, int num, symbol **tokens) { - int j, k; - int nlookaheads = 0; - /* Count the number of lookaheads corresponding to this rule. */ - for (j = 0; j < state->nlookaheads; ++j) - for (k = 0; k < ntokens; ++k) - if (bitset_test (state->lookaheads[j], k) - && state->lookaheads_rule[j]->number == rule->number) - nlookaheads++; + if (s->errs) + abort (); + s->errs = errs_new (num, tokens); +} + + + +/*-----------------------------------------------------. +| Print on OUT all the lookaheads such that S wants to | +| reduce R. | +`-----------------------------------------------------*/ + +void +state_rule_lookaheads_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 (nlookaheads) + if (reds->lookaheads && red != -1) { + bitset_iterator biter; + int k; + int not_first = 0; fprintf (out, " ["); - for (j = 0; j < state->nlookaheads; ++j) - for (k = 0; k < ntokens; ++k) - if (bitset_test (state->lookaheads[j], k) - && state->lookaheads_rule[j]->number == rule->number) - fprintf (out, "%s%s", - symbol_tag_get (symbols[k]), - --nlookaheads ? ", " : ""); + BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0) + fprintf (out, "%s%s", + not_first++ ? ", " : "", + symbols[k]->tag); fprintf (out, "]"); } } @@ -191,28 +267,28 @@ 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) +state_compare (state const *s1, state const *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 -state_hash (const state_t *state, unsigned int tablesize) +state_hash (state const *s, 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]; + for (i = 0; i < s->nitems; ++i) + key += s->items[i]; return key % tablesize; } @@ -243,14 +319,14 @@ state_hash_free (void) } -/*---------------------------------------. -| Insert STATE in the state hash table. | -`---------------------------------------*/ +/*-----------------------------------. +| Insert S in the state hash table. | +`-----------------------------------*/ void -state_hash_insert (state_t *state) +state_hash_insert (state *s) { - hash_insert (state_table, state); + hash_insert (state_table, s); } @@ -259,11 +335,11 @@ state_hash_insert (state_t *state) | not exist yet, return NULL. | `------------------------------------------------------------------*/ -state_t * -state_hash_lookup (size_t core_size, item_number_t *core) +state * +state_hash_lookup (size_t core_size, item_number *core) { - state_t *probe = STATE_ALLOC (core_size); - state_t *entry; + state *probe = STATE_ALLOC (core_size); + state *entry; probe->nitems = core_size; memcpy (probe->items, core, core_size * sizeof (core[0])); @@ -273,7 +349,7 @@ state_hash_lookup (size_t core_size, item_number_t *core) } /* All the decorated states, indexed by the state number. */ -state_t **states = NULL; +state **states = NULL; /*----------------------. @@ -283,14 +359,8 @@ state_t **states = NULL; void states_free (void) { - state_number_t i; - + state_number 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); }