Stop storing rules from 1 to nrules + 1.

[bison.git] / src / LR0.c

diff --git a/src/LR0.c b/src/LR0.c
index 4beca5bef9c1bac16eb75685e771c726169bb0b4..80f69a9eda9af33cacdba037daf4415d4e1b65fb 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -1,5 +1,5 @@
 /* Generate the nondeterministic finite state machine for bison,
 /* Generate the nondeterministic finite state machine for bison,

-   Copyright 1984, 1986, 1989, 2000, 2001  Free Software Foundation, Inc.
+   Copyright 1984, 1986, 1989, 2000, 2001, 2002  Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -23,6 +23,10 @@
    The entry point is generate_states.  */
 
 #include "system.h"
    The entry point is generate_states.  */
 
 #include "system.h"

+#include "bitset.h"
+#include "quotearg.h"
+#include "symtab.h"
+#include "gram.h"

 #include "getargs.h"
 #include "reader.h"
 #include "gram.h"
 #include "getargs.h"
 #include "reader.h"
 #include "gram.h"


@@ -33,35 +37,66 @@
 #include "lalr.h"
 #include "reduce.h"
 
 #include "lalr.h"
 #include "reduce.h"
 

-int nstates;
-int final_state;
-static state_t *first_state = NULL;
-static shifts *first_shift = NULL;
+typedef struct state_list_s
+{
+  struct state_list_s *next;
+  state_t *state;
+} state_list_t;
+
+static state_list_t *first_state = NULL;
+static state_list_t *last_state = NULL;
+
+
+/*------------------------------------------------------------------.
+| A state was just discovered from another state.  Queue it for     |
+| later examination, in order to find its transitions.  Return it.  |
+`------------------------------------------------------------------*/
+
+static state_t *
+state_list_append (symbol_number_t symbol,
+                  size_t core_size, item_number_t *core)
+{
+  state_list_t *node = XMALLOC (state_list_t, 1);
+  state_t *state = state_new (symbol, core_size, core);
+
+  if (trace_flag)
+    fprintf (stderr, "state_list_append (state = %d, symbol = %d (%s))\n",
+            nstates, symbol, symbols[symbol]->tag);

 
 

-static state_t *this_state = NULL;
-static state_t *last_state = NULL;
-static shifts *last_shift = NULL;
+  /* If this is the eoftoken, and this is not the initial state, then
+     this is the final state.  */
+  if (symbol == 0 && first_state)
+    final_state = state;
+
+  node->next = NULL;
+  node->state = state;
+
+  if (!first_state)
+    first_state = node;
+  if (last_state)
+    last_state->next = node;
+  last_state = node;
+
+  return state;
+}

 
 static int nshifts;
 
 static int nshifts;

-static short *shift_symbol = NULL;
+static symbol_number_t *shift_symbol = NULL;

 
 static short *redset = NULL;
 
 static short *redset = NULL;

-static short *shiftset = NULL;
+static state_number_t *shiftset = NULL;

 
 

-static short **kernel_base = NULL;
+static item_number_t **kernel_base = NULL;

 static int *kernel_size = NULL;
 static int *kernel_size = NULL;

-static short *kernel_items = NULL;
-
-/* hash table for states, to recognize equivalent ones.  */
-
-#define        STATE_HASH_SIZE 1009
-static state_t **state_hash = NULL;
+static item_number_t *kernel_items = NULL;

 
 \f
 static void
 allocate_itemsets (void)
 {
 
 \f
 static void
 allocate_itemsets (void)
 {

-  int i;
+  symbol_number_t i;
+  rule_number_t r;
+  item_number_t *rhsp;

 
   /* Count the number of occurrences of all the symbols in RITEMS.
      Note that useless productions (hence useless nonterminals) are
 
   /* Count the number of occurrences of all the symbols in RITEMS.
      Note that useless productions (hence useless nonterminals) are


@@ -70,22 +105,22 @@ allocate_itemsets (void)
   int count = 0;
   short *symbol_count = XCALLOC (short, nsyms + nuseless_nonterminals);
 
   int count = 0;
   short *symbol_count = XCALLOC (short, nsyms + nuseless_nonterminals);
 

-  for (i = 0; ritem[i]; ++i)
-    if (ritem[i] > 0)
+  for (r = 0; r < nrules; ++r)
+    for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)

       {
        count++;
       {
        count++;

-       symbol_count[ritem[i]]++;
+       symbol_count[*rhsp]++;

       }
 
   /* See comments before new_itemsets.  All the vectors of items
      live inside KERNEL_ITEMS.  The number of active items after
      some symbol cannot be more than the number of times that symbol
       }
 
   /* See comments before new_itemsets.  All the vectors of items
      live inside KERNEL_ITEMS.  The number of active items after
      some symbol cannot be more than the number of times that symbol

-     appears as an item, which is symbol_count[symbol].
+     appears as an item, which is SYMBOL_COUNT[SYMBOL].

      We allocate that much space for each symbol.  */
 
      We allocate that much space for each symbol.  */
 

-  kernel_base = XCALLOC (short *, nsyms);
+  kernel_base = XCALLOC (item_number_t *, nsyms);

   if (count)
   if (count)

-    kernel_items = XCALLOC (short, count);
+    kernel_items = XCALLOC (item_number_t, count);

 
   count = 0;
   for (i = 0; i < nsyms; i++)
 
   count = 0;
   for (i = 0; i < nsyms; i++)


@@ -104,9 +139,10 @@ allocate_storage (void)
 {
   allocate_itemsets ();
 
 {
   allocate_itemsets ();
 

-  shiftset = XCALLOC (short, nsyms);
-  redset = XCALLOC (short, nrules + 1);
-  state_hash = XCALLOC (state_t *, STATE_HASH_SIZE);
+  shiftset = XCALLOC (state_number_t, nsyms);
+  redset = XCALLOC (short, nrules);
+  state_hash_new ();
+  shift_symbol = XCALLOC (symbol_number_t, nsyms);

 }
 
 
 }
 
 


@@ -119,145 +155,73 @@ free_storage (void)
   free (kernel_base);
   free (kernel_size);
   XFREE (kernel_items);
   free (kernel_base);
   free (kernel_size);
   XFREE (kernel_items);

-  free (state_hash);
+  state_hash_free ();

 }
 
 
 
 
 }
 
 
 
 

-/*----------------------------------------------------------------.
-| Find which symbols can be shifted in the current state, and for |
-| each one record which items would be active after that shift.   |
-| Uses the contents of itemset.                                   |
-|                                                                 |
-| shift_symbol is set to a vector of the symbols that can be      |
-| shifted.  For each symbol in the grammar, kernel_base[symbol]   |
-| points to a vector of item numbers activated if that symbol is  |
-| shifted, and kernel_size[symbol] is their numbers.              |
-`----------------------------------------------------------------*/
+/*---------------------------------------------------------------.
+| Find which symbols can be shifted in STATE, and for each one   |
+| record which items would be active after that shift.  Uses the |
+| contents of itemset.                                           |
+|                                                                |
+| shift_symbol is set to a vector of the symbols that can be     |
+| shifted.  For each symbol in the grammar, kernel_base[symbol]  |
+| points to a vector of item numbers activated if that symbol is |
+| shifted, and kernel_size[symbol] is their numbers.             |
+`---------------------------------------------------------------*/

 
 static void
 
 static void

-new_itemsets (void)
+new_itemsets (state_t *state)

 {
   int i;
 
   if (trace_flag)
     fprintf (stderr, "Entering new_itemsets, state = %d\n",
 {
   int i;
 
   if (trace_flag)
     fprintf (stderr, "Entering new_itemsets, state = %d\n",

-            this_state->number);
+            state->number);

 
   for (i = 0; i < nsyms; i++)
     kernel_size[i] = 0;
 
 
   for (i = 0; i < nsyms; i++)
     kernel_size[i] = 0;
 

-  shift_symbol = XCALLOC (short, nsyms);

   nshifts = 0;
 
   nshifts = 0;
 

-  for (i = 0; i < nitemset; ++i)
-    {
-      int symbol = ritem[itemset[i]];
-      if (symbol > 0)
-       {
-         if (!kernel_size[symbol])
-           {
-             shift_symbol[nshifts] = symbol;
-             nshifts++;
-           }
-
-         kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1;
-         kernel_size[symbol]++;
-       }
-    }
+  for (i = 0; i < nritemset; ++i)
+    if (ritem[itemset[i]] >= 0)
+      {
+       symbol_number_t symbol
+         = item_number_as_symbol_number (ritem[itemset[i]]);
+       if (!kernel_size[symbol])
+         {
+           shift_symbol[nshifts] = symbol;
+           nshifts++;
+         }
+
+       kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1;
+       kernel_size[symbol]++;
+      }

 }
 
 
 
 }
 
 
 

-/*-----------------------------------------------------------------.
-| Subroutine of get_state.  Create a new state for those items, if |
-| necessary.                                                       |
-`-----------------------------------------------------------------*/
-
-static state_t *
-new_state (int symbol)
-{
-  state_t *p;
-
-  if (trace_flag)
-    fprintf (stderr, "Entering new_state, state = %d, symbol = %d (%s)\n",
-            this_state->number, symbol, tags[symbol]);
-
-  if (nstates >= MAXSHORT)
-    fatal (_("too many states (max %d)"), MAXSHORT);
-
-  p = STATE_ALLOC (kernel_size[symbol]);
-  p->accessing_symbol = symbol;
-  p->number = nstates;
-  p->nitems = kernel_size[symbol];
-
-  shortcpy (p->items, kernel_base[symbol], kernel_size[symbol]);
-
-  last_state->next = p;
-  last_state = p;
-  nstates++;
-
-  return p;
-}
-
-

 /*--------------------------------------------------------------.
 | Find the state number for the state we would get to (from the |
 | current state) by shifting symbol.  Create a new state if no  |
 | equivalent one exists already.  Used by append_states.        |
 `--------------------------------------------------------------*/
 
 /*--------------------------------------------------------------.
 | Find the state number for the state we would get to (from the |
 | current state) by shifting symbol.  Create a new state if no  |
 | equivalent one exists already.  Used by append_states.        |
 `--------------------------------------------------------------*/
 

-static int
-get_state (int symbol)
+static state_number_t
+get_state (symbol_number_t symbol, size_t core_size, item_number_t *core)

 {
 {

-  int key;
-  int i;

   state_t *sp;
 
   if (trace_flag)
   state_t *sp;
 
   if (trace_flag)

-    fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",
-            this_state->number, symbol, tags[symbol]);
-
-  /* Add up the target state's active item numbers to get a hash key.
-     */
-  key = 0;
-  for (i = 0; i < kernel_size[symbol]; ++i)
-    key += kernel_base[symbol][i];
-  key = key % STATE_HASH_SIZE;
-  sp = state_hash[key];
-
-  if (sp)
-    {
-      int found = 0;
-      while (!found)
-       {
-         if (sp->nitems == kernel_size[symbol])
-           {
-             found = 1;
-             for (i = 0; i < kernel_size[symbol]; ++i)
-               if (kernel_base[symbol][i] != sp->items[i])
-                 found = 0;
-           }
-
-         if (!found)
-           {
-             if (sp->link)
-               {
-                 sp = sp->link;
-               }
-             else              /* bucket exhausted and no match */
-               {
-                 sp = sp->link = new_state (symbol);
-                 found = 1;
-               }
-           }
-       }
-    }
-  else                         /* bucket is empty */
-    {
-      state_hash[key] = sp = new_state (symbol);
-    }
+    fprintf (stderr, "Entering get_state, symbol = %d (%s)\n",
+            symbol, symbols[symbol]->tag);
+
+  sp = state_hash_lookup (core_size, core);
+  if (!sp)
+    sp = state_list_append (symbol, core_size, core);

 
   if (trace_flag)
     fprintf (stderr, "Exiting get_state => %d\n", sp->number);
 
   if (trace_flag)
     fprintf (stderr, "Exiting get_state => %d\n", sp->number);


@@ -267,21 +231,21 @@ get_state (int symbol)
 
 /*------------------------------------------------------------------.
 | 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 the current state.  |
+| numbers reached by each shift transition from STATE.              |

 |                                                                   |
 |                                                                   |

-| shiftset is set up as a vector of state numbers of those states.  |
+| SHIFTSET is set up as a vector of state numbers of those states.  |

 `------------------------------------------------------------------*/
 
 static void
 `------------------------------------------------------------------*/
 
 static void

-append_states (void)
+append_states (state_t *state)

 {
   int i;
   int j;
 {
   int i;
   int j;

-  int symbol;
+  symbol_number_t symbol;

 
   if (trace_flag)
     fprintf (stderr, "Entering append_states, state = %d\n",
 
   if (trace_flag)
     fprintf (stderr, "Entering append_states, state = %d\n",

-            this_state->number);
+            state->number);

 
   /* first sort shift_symbol into increasing order */
 
 
   /* first sort shift_symbol into increasing order */
 


@@ -298,248 +262,11 @@ append_states (void)
     }
 
   for (i = 0; i < nshifts; i++)
     }
 
   for (i = 0; i < nshifts; i++)

-    shiftset[i] = get_state (shift_symbol[i]);
-}
-
-
-static void
-new_states (void)
-{
-  first_state = last_state = this_state = STATE_ALLOC (0);
-  nstates = 1;
-}
-
-
-/*------------------------------------------------------------.
-| Save the NSHIFTS of SHIFTSET into the current linked list.  |
-`------------------------------------------------------------*/
-
-static void
-save_shifts (void)
-{
-  shifts *p = shifts_new (nshifts);
-
-  p->number = this_state->number;
-  shortcpy (p->shifts, shiftset, nshifts);
-  this_state->shifts = p;
-
-  if (last_shift)
-    last_shift->next = p;
-  else
-    first_shift = p;
-  last_shift = p;
-}
-
-
-/*------------------------------------------------------------------.
-| Subroutine of augment_automaton.  Create the next-to-final state, |
-| to which a shift has already been made in the initial state.      |
-|                                                                   |
-| The task of this state consists in shifting (actually, it's a     |
-| goto, but shifts and gotos are both stored in SHIFTS) the start   |
-| symbols, hence the name.                                          |
-`------------------------------------------------------------------*/
-
-static void
-insert_start_shifting_state (void)
-{
-  state_t *statep;
-  shifts *sp;
-
-  statep = STATE_ALLOC (0);
-  statep->number = nstates;
-
-  /* The distinctive feature of this state from the
-     eof_shifting_state, is that it is labeled as post-start-symbol
-     shifting.  I fail to understand why this state, and the
-     post-start-start can't be merged into one.  But it does fail if
-     you try. --akim */
-  statep->accessing_symbol = start_symbol;
-
-  last_state->next = statep;
-  last_state = statep;
-
-  /* Make a shift from this state to (what will be) the final state.  */
-  sp = shifts_new (1);
-  statep->shifts = sp;
-  sp->number = nstates++;
-  sp->shifts[0] = nstates;
-
-  last_shift->next = sp;
-  last_shift = sp;
-}
-
-
-/*-----------------------------------------------------------------.
-| Subroutine of augment_automaton.  Create the final state, which  |
-| shifts `0', the end of file.  The initial state shifts the start |
-| symbol, and goes to here.                                        |
-`-----------------------------------------------------------------*/
-
-static void
-insert_eof_shifting_state (void)
-{
-  state_t *statep;
-  shifts *sp;
-
-  /* Make the final state--the one that follows a shift from the
-     next-to-final state.
-     The symbol for that shift is 0 (end-of-file).  */
-  statep = STATE_ALLOC (0);
-  statep->number = nstates;
-
-  last_state->next = statep;
-  last_state = statep;
-
-  /* Make the shift from the final state to the termination state.  */
-  sp = shifts_new (1);
-  statep->shifts = sp;
-  sp->number = nstates++;
-  sp->shifts[0] = nstates;
-
-  last_shift->next = sp;
-  last_shift = sp;
-}
-
-
-/*---------------------------------------------------------------.
-| Subroutine of augment_automaton.  Create the accepting state.  |
-`---------------------------------------------------------------*/
-
-static void
-insert_accepting_state (void)
-{
-  state_t *statep;
-
-   /* Note that the variable `final_state' refers to what we sometimes
-      call the termination state.  */
-  final_state = nstates;
-
-  /* Make the termination state.  */
-  statep = STATE_ALLOC (0);
-  statep->number = nstates++;
-  last_state->next = statep;
-  last_state = statep;
-}
-
-
-
-
-
-/*------------------------------------------------------------------.
-| Make sure that the initial state has a shift that accepts the     |
-| grammar's start symbol and goes to the next-to-final state, which |
-| has a shift going to the final state, which has a shift to the    |
-| termination state.  Create such states and shifts if they don't   |
-| happen to exist already.                                          |
-`------------------------------------------------------------------*/
-
-static void
-augment_automaton (void)
-{
-  if (!first_state->shifts->nshifts)
-    {
-      /* The first state has no shifts.  Make one shift, from the
-        initial state to the next-to-final state.  */
-
-      shifts *sp = shifts_new (1);
-      first_state->shifts = sp;
-      sp->shifts[0] = nstates;
-
-      /* Initialize the chain of shifts with sp.  */
-      first_shift = sp;
-      last_shift = sp;
-
-      /* Create the next-to-final state, with shift to
-         what will be the final state.  */
-      insert_start_shifting_state ();
-    }
-  else

     {
     {

-      state_t *statep = first_state->next;
-      /* The states reached by shifts from FIRST_STATE are numbered
-        1..(SP->NSHIFTS).  Look for one reached by START_SYMBOL.
-        This is typical of `start: start ... ;': there is a state
-        with the item `start: start . ...'.  We want to add a `shift
-        on EOF to eof-shifting state here.  */
-      while (statep->accessing_symbol != start_symbol
-            && statep->number < first_state->shifts->nshifts)
-       statep = statep->next;
-
-      if (statep->accessing_symbol == start_symbol)
-       {
-         /* We already have STATEP, a next-to-final state for `start:
-            start . ...'.  Make sure it has a shift to what will be
-            the final state.  */
-         int i;
-
-         /* Find the shift that leads to this STATEP. */
-         shifts *sp = first_state->shifts;
-         shifts *sp1 = NULL;
-         shifts *sp2 = NULL;
-         while (sp->number < statep->number)
-           {
-             sp1 = sp;
-             sp = sp->next;
-           }
-
-         sp2 = shifts_new (sp->nshifts + 1);
-         sp2->number = statep->number;
-         statep->shifts = sp2;
-         sp2->shifts[0] = nstates;
-         for (i = sp->nshifts; i > 0; i--)
-           sp2->shifts[i] = sp->shifts[i - 1];
-
-         /* Patch sp2 into the chain of shifts in place of sp,
-            following sp1.  */
-         sp2->next = sp->next;
-         sp1->next = sp2;
-         if (sp == last_shift)
-           last_shift = sp2;
-         XFREE (sp);
-
-         insert_eof_shifting_state ();
-       }
-      else
-       {
-         /* There is no state for `start: start . ...'. */
-         int i, k;
-         shifts *sp = first_state->shifts;
-         shifts *sp2 = NULL;
-
-         /* There is no next-to-final state as yet.  */
-         /* Add one more shift in first_shift,
-            going to the next-to-final state (yet to be made).  */
-         sp2 = shifts_new (sp->nshifts + 1);
-         first_state->shifts = sp2;
-         /* Stick this shift into the vector at the proper place.  */
-         statep = first_state->next;
-         for (k = 0, i = 0; i < sp->nshifts; k++, i++)
-           {
-             if (statep->accessing_symbol > start_symbol && i == k)
-               sp2->shifts[k++] = nstates;
-             sp2->shifts[k] = sp->shifts[i];
-             statep = statep->next;
-           }
-         if (i == k)
-           sp2->shifts[k++] = nstates;
-
-         /* Patch sp2 into the chain of shifts
-            in place of sp, at the beginning.  */
-         sp2->next = sp->next;
-         first_shift = sp2;
-         if (last_shift == sp)
-           last_shift = sp2;
-
-         XFREE (sp);
-
-         /* Create the next-to-final state, with shift to what will
-            be the final state.  Corresponds to `start: start . ...'.  */
-         insert_start_shifting_state ();
-       }
+      symbol = shift_symbol[i];
+      shiftset[i] = get_state (symbol,
+                              kernel_size[symbol], kernel_base[symbol]);

     }
     }

-
-  insert_accepting_state ();

 }
 
 
 }
 
 


@@ -550,95 +277,62 @@ augment_automaton (void)
 `----------------------------------------------------------------*/
 
 static void
 `----------------------------------------------------------------*/
 
 static void

-save_reductions (void)
+save_reductions (state_t *state)

 {
 {

-  int count;
+  int count = 0;

   int i;
 
   int i;
 

-  /* Find and count the active items that represent ends of rules. */
+  /* If this is the final state, we want it to have no reductions at
+     all, although it has one for `START_SYMBOL EOF .'.  */
+  if (final_state && state->number == final_state->number)
+    return;

 
 

-  count = 0;
-  for (i = 0; i < nitemset; ++i)
+  /* Find and count the active items that represent ends of rules. */
+  for (i = 0; i < nritemset; ++i)

     {
       int item = ritem[itemset[i]];
       if (item < 0)
     {
       int item = ritem[itemset[i]];
       if (item < 0)

-       redset[count++] = -item;
+       redset[count++] = item_number_as_rule_number (item);

     }
 
   /* Make a reductions structure and copy the data into it.  */
     }
 
   /* Make a reductions structure and copy the data into it.  */

-
-  if (count)
-    {
-      reductions *p = REDUCTIONS_ALLOC (count);
-      p->nreds = count;
-      shortcpy (p->rules, redset, count);
-
-      this_state->reductions = p;
-    }
+  state_reductions_set (state, count, redset);

 }
 
 \f
 }
 
 \f

-/*--------------------.
-| Build STATE_TABLE.  |
-`--------------------*/
+/*---------------.
+| Build STATES.  |
+`---------------*/

 
 static void
 
 static void

-set_state_table (void)
+set_states (void)

 {
 {

-  /* NSTATES + 1 because lookahead for the pseudo state number NSTATES
-     might be used (see conflicts.c).  It is too opaque for me to
-     provide a probably less hacky implementation. --akim */
-  state_table = XCALLOC (state_t *, nstates + 1);
-
-  {
-    state_t *sp;
-    for (sp = first_state; sp; sp = sp->next)
-      state_table[sp->number] = sp;
-  }
-
-  /* Pessimization, but simplification of the code: make sure all the
-     states have a shifts, even if reduced to 0 shifts.  */
-  {
-    int i;
-    for (i = 0; i < nstates; i++)
-      if (!state_table[i]->shifts)
-       state_table[i]->shifts = shifts_new (0);
-  }
-
-  /* Initializing the lookaheads members.  Please note that it must be
-     performed after having set some of the other members which are
-     used below.  Change with extreme caution.  */
-  {
-    int i;
-    int count = 0;
-    for (i = 0; i < nstates; i++)
-      {
-       int k;
-       reductions *rp = state_table[i]->reductions;
-       shifts *sp = state_table[i]->shifts;
-
-       state_table[i]->lookaheads = count;
-
-       if (rp
-           && (rp->nreds > 1 || (sp->nshifts && SHIFT_IS_SHIFT (sp, 0))))
-         count += rp->nreds;
-       else
-         state_table[i]->consistent = 1;
-
-       for (k = 0; k < sp->nshifts; k++)
-         if (SHIFT_IS_ERROR (sp, k))
-           {
-             state_table[i]->consistent = 0;
-             break;
-           }
-      }
+  states = XCALLOC (state_t *, nstates);

 
 

-    /* Seems to be needed by conflicts.c. */
-    state_table[nstates] = STATE_ALLOC (0);
-    state_table[nstates]->lookaheads = count;
-  }
+  while (first_state)
+    {
+      state_list_t *this = first_state;
+
+      /* Pessimization, but simplification of the code: make sure all
+        the states have valid transitions and reductions members,
+        even if reduced to 0.  It is too soon for errs, which are
+        computed later, but set_conflicts.  */
+      state_t *state = this->state;
+      if (!state->transitions)
+       state_transitions_set (state, 0, 0);
+      if (!state->reductions)
+       state_reductions_set (state, 0, 0);
+
+      states[state->number] = state;
+
+      first_state = this->next;
+      free (this);
+    }
+  first_state = NULL;
+  last_state = NULL;

 }
 
 }
 

+

 /*-------------------------------------------------------------------.
 | Compute the nondeterministic finite state machine (see state.h for |
 | details) from the grammar.                                         |
 /*-------------------------------------------------------------------.
 | Compute the nondeterministic finite state machine (see state.h for |
 | details) from the grammar.                                         |


@@ -647,42 +341,50 @@ set_state_table (void)
 void
 generate_states (void)
 {
 void
 generate_states (void)
 {

+  state_list_t *list = NULL;

   allocate_storage ();
   allocate_storage ();

-  new_closure (nitems);
-  new_states ();
+  new_closure (nritems);

 
 

-  while (this_state)
+  /* Create the initial state.  The 0 at the lhs is the index of the
+     item of this initial rule.  */
+  kernel_base[0][0] = 0;
+  kernel_size[0] = 1;
+  state_list_append (0, kernel_size[0], kernel_base[0]);
+
+  list = first_state;
+
+  while (list)

     {
     {

+      state_t *state = list->state;

       if (trace_flag)
        fprintf (stderr, "Processing state %d (reached by %s)\n",
       if (trace_flag)
        fprintf (stderr, "Processing state %d (reached by %s)\n",

-                this_state->number, tags[this_state->accessing_symbol]);
+                state->number,
+                symbols[state->accessing_symbol]->tag);

       /* Set up ruleset and itemset for the transitions out of this
          state.  ruleset gets a 1 bit for each rule that could reduce
          now.  itemset gets a vector of all the items that could be
          accepted next.  */
       /* Set up ruleset and itemset for the transitions out of this
          state.  ruleset gets a 1 bit for each rule that could reduce
          now.  itemset gets a vector of all the items that could be
          accepted next.  */

-      closure (this_state->items, this_state->nitems);
-      /* record the reductions allowed out of this state */
-      save_reductions ();
-      /* find the itemsets of the states that shifts can reach */
-      new_itemsets ();
-      /* find or create the core structures for those states */
-      append_states ();
-
-      /* create the shifts structures for the shifts to those states,
-         now that the state numbers transitioning to are known */
-      save_shifts ();
-
-      /* states are queued when they are created; process them all */
-      this_state = this_state->next;
+      closure (state->items, state->nitems);
+      /* Record the reductions allowed out of this state.  */
+      save_reductions (state);
+      /* Find the itemsets of the states that shifts can reach.  */
+      new_itemsets (state);
+      /* Find or create the core structures for those states.  */
+      append_states (state);
+
+      /* Create the shifts structures for the shifts to those states,
+        now that the state numbers transitioning to are known.  */
+      state_transitions_set (state, nshifts, shiftset);
+
+      /* States are queued when they are created; process them all.
+        */
+      list = list->next;

     }
 
   /* discard various storage */
   free_closure ();
   free_storage ();
 
     }
 
   /* discard various storage */
   free_closure ();
   free_storage ();
 

-  /* set up initial and final states as parser wants them */
-  augment_automaton ();
-
-  /* Set up STATE_TABLE. */
-  set_state_table ();
+  /* Set up STATES. */
+  set_states ();

 }
 }