Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-21 18:23:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

(struct state_list): Renamed from struct state_list_s.

Browse Source 
(state_list): Renamed from state_list_t.
This commit is contained in:
Paul Eggert
2002-12-11 05:29:17 +00:00
parent 7c612afb7e
commit add6614e2b
1 changed files with 91 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
src/LR0.c
View File

@@ -25,28 +25,30 @@
The entry point is generate_states. */ The entry point is generate_states. */
#include "system.h" #include "system.h"
#include "bitset.h"
#include "quotearg.h" #include <bitset.h>
#include "symtab.h" #include <quotearg.h>
#include "gram.h"
#include "getargs.h"
#include "reader.h"
#include "gram.h"
#include "state.h"
#include "complain.h"
#include "closure.h"
#include "LR0.h" #include "LR0.h"
#include "closure.h"
#include "complain.h"
#include "getargs.h"
#include "gram.h"
#include "gram.h"
#include "lalr.h" #include "lalr.h"
#include "reader.h"
#include "reduce.h" #include "reduce.h"
#include "state.h"
#include "symtab.h"
typedef struct state_list_s typedef struct state_list
{ {
struct state_list_s *next; struct state_list *next;
state_t *state; state *state;
} state_list_t; } state_list;
static state_list_t *first_state = NULL; static state_list *first_state = NULL;
static state_list_t *last_state = NULL; static state_list *last_state = NULL;
/*------------------------------------------------------------------. /*------------------------------------------------------------------.
@@ -54,24 +56,23 @@ static state_list_t *last_state = NULL;
| later examination, in order to find its transitions. Return it. | | later examination, in order to find its transitions. Return it. |
`------------------------------------------------------------------*/ `------------------------------------------------------------------*/
static state_t * static state *
state_list_append (symbol_number_t symbol, state_list_append (symbol_number sym, size_t core_size, item_number *core)
size_t core_size, item_number_t *core)
{ {
state_list_t *node = XMALLOC (state_list_t, 1); state_list *node = XMALLOC (state_list, 1);
state_t *state = state_new (symbol, core_size, core); state *s = state_new (sym, core_size, core);
if (trace_flag & trace_automaton) if (trace_flag & trace_automaton)
fprintf (stderr, "state_list_append (state = %d, symbol = %d (%s))\n", fprintf (stderr, "state_list_append (state = %d, symbol = %d (%s))\n",
nstates, symbol, symbols[symbol]->tag); nstates, sym, symbols[sym]->tag);
/* If this is the endtoken, and this is not the initial state, then /* If this is the endtoken, and this is not the initial state, then
this is the final state. */ this is the final state. */
if (symbol == 0 && first_state) if (sym == 0 && first_state)
final_state = state; final_state = s;
node->next = NULL; node->next = NULL;
node->state = state; node->state = s;
if (!first_state) if (!first_state)
first_state = node; first_state = node;
@@ -79,26 +80,26 @@ state_list_append (symbol_number_t symbol,
last_state->next = node; last_state->next = node;
last_state = node; last_state = node;
return state; return s;
} }
static int nshifts; static int nshifts;
static symbol_number_t *shift_symbol = NULL; static symbol_number *shift_symbol = NULL;
static rule_t **redset = NULL; static rule **redset = NULL;
static state_t **shiftset = NULL; static state **shiftset = NULL;
static item_number_t **kernel_base = NULL; static item_number **kernel_base = NULL;
static int *kernel_size = NULL; static int *kernel_size = NULL;
static item_number_t *kernel_items = NULL; static item_number *kernel_items = NULL;
static void static void
allocate_itemsets (void) allocate_itemsets (void)
{ {
symbol_number_t i; symbol_number i;
rule_number_t r; rule_number r;
item_number_t *rhsp; item_number *rhsp;
/* Count the number of occurrences of all the symbols in RITEMS. /* Count the number of occurrences of all the symbols in RITEMS.
Note that useless productions (hence useless nonterminals) are Note that useless productions (hence useless nonterminals) are
@@ -116,13 +117,13 @@ allocate_itemsets (void)
/* See comments before new_itemsets. All the vectors of items /* See comments before new_itemsets. All the vectors of items
live inside KERNEL_ITEMS. The number of active items after live inside KERNEL_ITEMS. The number of active items after
some symbol cannot be more than the number of times that symbol some symbol S cannot be more than the number of times that S
appears as an item, which is SYMBOL_COUNT[SYMBOL]. appears as an item, which is SYMBOL_COUNT[S].
We allocate that much space for each symbol. */ We allocate that much space for each symbol. */
kernel_base = XCALLOC (item_number_t *, nsyms); kernel_base = XCALLOC (item_number *, nsyms);
if (count) if (count)
kernel_items = XCALLOC (item_number_t, count); kernel_items = XCALLOC (item_number, count);
count = 0; count = 0;
for (i = 0; i < nsyms; i++) for (i = 0; i < nsyms; i++)
@@ -141,10 +142,10 @@ allocate_storage (void)
{ {
allocate_itemsets (); allocate_itemsets ();
shiftset = XCALLOC (state_t *, nsyms); shiftset = XCALLOC (state *, nsyms);
redset = XCALLOC (rule_t *, nrules); redset = XCALLOC (rule *, nrules);
state_hash_new (); state_hash_new ();
shift_symbol = XCALLOC (symbol_number_t, nsyms); shift_symbol = XCALLOC (symbol_number, nsyms);
} }
@@ -164,7 +165,7 @@ free_storage (void)
/*---------------------------------------------------------------. /*---------------------------------------------------------------.
| Find which symbols can be shifted in STATE, and for each one | | Find which symbols can be shifted in S, and for each one |
| record which items would be active after that shift. Uses the | | record which items would be active after that shift. Uses the |
| contents of itemset. | | contents of itemset. |
| | | |
@@ -175,13 +176,12 @@ free_storage (void)
`---------------------------------------------------------------*/ `---------------------------------------------------------------*/
static void static void
new_itemsets (state_t *state) new_itemsets (state *s)
{ {
int i; int i;
if (trace_flag & trace_automaton) if (trace_flag & trace_automaton)
fprintf (stderr, "Entering new_itemsets, state = %d\n", fprintf (stderr, "Entering new_itemsets, state = %d\n", s->number);
state->number);
for (i = 0; i < nsyms; i++) for (i = 0; i < nsyms; i++)
kernel_size[i] = 0; kernel_size[i] = 0;
@@ -191,39 +191,38 @@ new_itemsets (state_t *state)
for (i = 0; i < nritemset; ++i) for (i = 0; i < nritemset; ++i)
if (ritem[itemset[i]] >= 0) if (ritem[itemset[i]] >= 0)
{ {
symbol_number_t symbol symbol_number sym = item_number_as_symbol_number (ritem[itemset[i]]);
= item_number_as_symbol_number (ritem[itemset[i]]); if (!kernel_size[sym])
if (!kernel_size[symbol])
{ {
shift_symbol[nshifts] = symbol; shift_symbol[nshifts] = sym;
nshifts++; nshifts++;
} }
kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1; kernel_base[sym][kernel_size[sym]] = itemset[i] + 1;
kernel_size[symbol]++; kernel_size[sym]++;
} }
} }
/*-----------------------------------------------------------------. /*--------------------------------------------------------------.
| Find the state we would get to (from the current state) by | | Find the state we would get to (from the current state) by |
| shifting SYMBOL. Create a new state if no equivalent one exists | | shifting SYM. Create a new state if no equivalent one exists |
| already. Used by append_states. | | already. Used by append_states. |
`-----------------------------------------------------------------*/ `--------------------------------------------------------------*/
static state_t * static state *
get_state (symbol_number_t symbol, size_t core_size, item_number_t *core) get_state (symbol_number sym, size_t core_size, item_number *core)
{ {
state_t *sp; state *sp;
if (trace_flag & trace_automaton) if (trace_flag & trace_automaton)
fprintf (stderr, "Entering get_state, symbol = %d (%s)\n", fprintf (stderr, "Entering get_state, symbol = %d (%s)\n",
symbol, symbols[symbol]->tag); sym, symbols[sym]->tag);
sp = state_hash_lookup (core_size, core); sp = state_hash_lookup (core_size, core);
if (!sp) if (!sp)
sp = state_list_append (symbol, core_size, core); sp = state_list_append (sym, core_size, core);
if (trace_flag & trace_automaton) if (trace_flag & trace_automaton)
fprintf (stderr, "Exiting get_state => %d\n", sp->number); fprintf (stderr, "Exiting get_state => %d\n", sp->number);
@@ -233,41 +232,34 @@ get_state (symbol_number_t symbol, size_t core_size, item_number_t *core)
/*---------------------------------------------------------------. /*---------------------------------------------------------------.
| Use the information computed by new_itemsets to find the state | | Use the information computed by new_itemsets to find the state |
| numbers reached by each shift transition from STATE. | | numbers reached by each shift transition from S. |
| | | |
| SHIFTSET is set up as a vector of those states. | | SHIFTSET is set up as a vector of those states. |
`---------------------------------------------------------------*/ `---------------------------------------------------------------*/
static void static void
append_states (state_t *state) append_states (state *s)
{ {
int i; int i;
int j;
symbol_number_t symbol;
if (trace_flag & trace_automaton) if (trace_flag & trace_automaton)
fprintf (stderr, "Entering append_states, state = %d\n", fprintf (stderr, "Entering append_states, state = %d\n", s->number);
state->number);
/* first sort shift_symbol into increasing order */ /* First sort shift_symbol into increasing order. */
for (i = 1; i < nshifts; i++) for (i = 1; i < nshifts; i++)
{ {
symbol = shift_symbol[i]; symbol_number sym = shift_symbol[i];
j = i; int j;
while (j > 0 && shift_symbol[j - 1] > symbol) for (j = i; 0 < j && sym < shift_symbol [j - 1]; j--)
{ shift_symbol[j] = shift_symbol[j - 1];
shift_symbol[j] = shift_symbol[j - 1]; shift_symbol[j] = sym;
j--;
}
shift_symbol[j] = symbol;
} }
for (i = 0; i < nshifts; i++) for (i = 0; i < nshifts; i++)
{ {
symbol = shift_symbol[i]; symbol_number sym = shift_symbol[i];
shiftset[i] = get_state (symbol, shiftset[i] = get_state (sym, kernel_size[sym], kernel_base[sym]);
kernel_size[symbol], kernel_base[symbol]);
} }
} }
@@ -279,7 +271,7 @@ append_states (state_t *state)
`----------------------------------------------------------------*/ `----------------------------------------------------------------*/
static void static void
save_reductions (state_t *state) save_reductions (state *s)
{ {
int count = 0; int count = 0;
int i; int i;
@@ -293,7 +285,7 @@ save_reductions (state_t *state)
} }
/* Make a reductions structure and copy the data into it. */ /* Make a reductions structure and copy the data into it. */
state_reductions_set (state, count, redset); state_reductions_set (s, count, redset);
} }
@@ -304,23 +296,23 @@ save_reductions (state_t *state)
static void static void
set_states (void) set_states (void)
{ {
states = XCALLOC (state_t *, nstates); states = XCALLOC (state *, nstates);
while (first_state) while (first_state)
{ {
state_list_t *this = first_state; state_list *this = first_state;
/* Pessimization, but simplification of the code: make sure all /* Pessimization, but simplification of the code: make sure all
the states have valid transitions and reductions members, the states have valid transitions and reductions members,
even if reduced to 0. It is too soon for errs, which are even if reduced to 0. It is too soon for errs, which are
computed later, but set_conflicts. */ computed later, but set_conflicts. */
state_t *state = this->state; state *s = this->state;
if (!state->transitions) if (!s->transitions)
state_transitions_set (state, 0, 0); state_transitions_set (s, 0, 0);
if (!state->reductions) if (!s->reductions)
state_reductions_set (state, 0, 0); state_reductions_set (s, 0, 0);
states[state->number] = state; states[s->number] = s;
first_state = this->next; first_state = this->next;
free (this); free (this);
@@ -338,7 +330,7 @@ set_states (void)
void void
generate_states (void) generate_states (void)
{ {
state_list_t *list = NULL; state_list *list = NULL;
allocate_storage (); allocate_storage ();
new_closure (nritems); new_closure (nritems);
@@ -352,28 +344,28 @@ generate_states (void)
while (list) while (list)
{ {
state_t *state = list->state; state *s = list->state;
if (trace_flag & trace_automaton) if (trace_flag & trace_automaton)
fprintf (stderr, "Processing state %d (reached by %s)\n", fprintf (stderr, "Processing state %d (reached by %s)\n",
state->number, s->number,
symbols[state->accessing_symbol]->tag); symbols[s->accessing_symbol]->tag);
/* Set up ruleset and itemset for the transitions out of this /* Set up ruleset and itemset for the transitions out of this
state. ruleset gets a 1 bit for each rule that could reduce state. ruleset gets a 1 bit for each rule that could reduce
now. itemset gets a vector of all the items that could be now. itemset gets a vector of all the items that could be
accepted next. */ accepted next. */
closure (state->items, state->nitems); closure (s->items, s->nitems);
/* Record the reductions allowed out of this state. */ /* Record the reductions allowed out of this state. */
save_reductions (state); save_reductions (s);
/* Find the itemsets of the states that shifts can reach. */ /* Find the itemsets of the states that shifts can reach. */
new_itemsets (state); new_itemsets (s);
/* Find or create the core structures for those states. */ /* Find or create the core structures for those states. */
append_states (state); append_states (s);
/* Create the shifts structures for the shifts to those states, /* Create the shifts structures for the shifts to those states,
now that the state numbers transitioning to are known. */ now that the state numbers transitioning to are known. */
state_transitions_set (state, nshifts, shiftset); state_transitions_set (s, nshifts, shiftset);
/* States are queued when they are created; process them all. /* states are queued when they are created; process them all.
*/ */
list = list->next; list = list->next;
} }