Sync with GNU tar.

[bison.git] / src / LR0.c

diff --git a/src/LR0.c b/src/LR0.c
index 2b78dd03c76c53a6242862283d7e10294614a1a9..d7134aab58da102102259c2515e5410e7264cb57 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,7 +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 "symtab.h"

+#include "gram.h"

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


@@ -34,40 +37,66 @@
 #include "lalr.h"
 #include "reduce.h"
 
 #include "lalr.h"
 #include "reduce.h"
 

-int nstates;
-/* Initialize the final state to -1, otherwise, it might be set to 0
-   by default, and since we don't compute the reductions of the final
-   state, we end up not computing the reductions of the initial state,
-   which is of course needed.
+typedef struct state_list_s
+{
+  struct state_list_s *next;
+  state_t *state;
+} state_list_t;

 
 

-   FINAL_STATE is properly set by new_state when it recognizes the
-   accessing symbol: EOF.  */
-int final_state = -1;
-static state_t *first_state = NULL;
+static state_list_t *first_state = NULL;
+static state_list_t *last_state = NULL;

 
 

-static state_t *this_state = NULL;
-static state_t *last_state = NULL;

 
 

-static int nshifts;
-static short *shift_symbol = NULL;
+/*------------------------------------------------------------------.
+| A state was just discovered from another state.  Queue it for     |
+| later examination, in order to find its transitions.  Return it.  |
+`------------------------------------------------------------------*/

 
 

-static short *redset = NULL;
-static short *shiftset = NULL;
+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);

 
 

-static short **kernel_base = NULL;
-static int *kernel_size = NULL;
-static short *kernel_items = NULL;
+  if (trace_flag & trace_automaton)
+    fprintf (stderr, "state_list_append (state = %d, symbol = %d (%s))\n",
+            nstates, symbol, symbols[symbol]->tag);
+
+  /* If this is the endtoken, and this is not the initial state, then
+     this is the final state.  */
+  if (symbol == 0 && first_state)
+    final_state = state;

 
 

-/* hash table for states, to recognize equivalent ones.  */
+  node->next = NULL;
+  node->state = state;

 
 

-#define        STATE_HASH_SIZE 1009
-static state_t **state_hash = NULL;
+  if (!first_state)
+    first_state = node;
+  if (last_state)
+    last_state->next = node;
+  last_state = node;
+
+  return state;
+}
+
+static int nshifts;
+static symbol_number_t *shift_symbol = NULL;
+
+static rule_t **redset = NULL;
+static state_t **shiftset = NULL;
+
+static item_number_t **kernel_base = NULL;
+static int *kernel_size = 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


@@ -76,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; i < nritems; ++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++)


@@ -110,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_t *, nsyms);
+  redset = XCALLOC (rule_t *, nrules);
+  state_hash_new ();
+  shift_symbol = XCALLOC (symbol_number_t, nsyms);

 }
 
 
 }
 
 


@@ -125,173 +155,97 @@ 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;
 
 {
   int i;
 

-  if (trace_flag)
+  if (trace_flag & trace_automaton)

     fprintf (stderr, "Entering new_itemsets, state = %d\n",
     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.                                                       |
+| Find 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 state_t *
 `-----------------------------------------------------------------*/
 
 static state_t *

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

 {
 {

-  state_t *p;
-
-  if (trace_flag)
-    fprintf (stderr, "Entering new_state, state = %d, symbol = %d (%s)\n",
-            this_state->number, symbol, symbols[symbol]->tag);
-
-  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++;
-
-  /* If this is the eoftoken, then this is the final state. */
-  if (symbol == 0)
-    final_state = p->number;
-
-  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.        |
-`--------------------------------------------------------------*/
-
-static int
-get_state (int symbol)
-{
-  int key;
-  int i;

   state_t *sp;
 
   state_t *sp;
 

-  if (trace_flag)
-    fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",
-            this_state->number, symbol, symbols[symbol]->tag);
+  if (trace_flag & trace_automaton)
+    fprintf (stderr, "Entering get_state, symbol = %d (%s)\n",
+            symbol, symbols[symbol]->tag);

 
 

-  /* 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];
+  sp = state_hash_lookup (core_size, core);
+  if (!sp)
+    sp = state_list_append (symbol, core_size, core);

 
 

-  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);
-    }
-
-  if (trace_flag)
+  if (trace_flag & trace_automaton)

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

-  return sp->number;
+  return sp;

 }
 
 }
 

-/*------------------------------------------------------------------.
-| Use the information computed by new_itemsets to find the state    |
-| numbers reached by each shift transition from the current state.  |
-|                                                                   |
-| shiftset is set up as a vector of state numbers of those states.  |
-`------------------------------------------------------------------*/
+/*---------------------------------------------------------------.
+| Use the information computed by new_itemsets to find the state |
+| numbers reached by each shift transition from STATE.           |
+|                                                                |
+| SHIFTSET is set up as a vector 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)
+  if (trace_flag & trace_automaton)

     fprintf (stderr, "Entering append_states, state = %d\n",
     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 */
 


@@ -308,28 +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);
-  shortcpy (p->shifts, shiftset, nshifts);
-  this_state->shifts = p;
+    {
+      symbol = shift_symbol[i];
+      shiftset[i] = get_state (symbol,
+                              kernel_size[symbol], kernel_base[symbol]);
+    }

 }
 
 
 }
 
 


@@ -340,56 +277,57 @@ save_shifts (void)
 `----------------------------------------------------------------*/
 
 static void
 `----------------------------------------------------------------*/
 
 static void

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

 {
   int count = 0;
   int i;
 
 {
   int count = 0;
   int i;
 

-  /* If this is the final state, we want it to have no reductions at
-     all, although it has one for `START_SYMBOL EOF .'.  */
-  if (this_state->number == final_state)
-    return;
-

   /* Find and count the active items that represent ends of rules. */
   /* Find and count the active items that represent ends of rules. */

-  for (i = 0; i < nitemset; ++i)
+  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++] = &rules[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.  */

-  this_state->reductions = reductions_new (count);
-  shortcpy (this_state->reductions->rules, redset, count);
+  state_reductions_set (state, count, redset);

 }
 
 \f
 }
 
 \f

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

 
 static void
 
 static void

-set_state_table (void)
+set_states (void)

 {
 {

-  state_t *sp;
-  state_table = XCALLOC (state_t *, nstates);
+  states = XCALLOC (state_t *, nstates);

 
 

-  for (sp = first_state; sp; sp = sp->next)
+  while (first_state)

     {
     {

+      state_list_t *this = first_state;
+

       /* Pessimization, but simplification of the code: make sure all
       /* Pessimization, but simplification of the code: make sure all

-        the states have a shifts, errs, and reductions, even if
-        reduced to 0.  */
-      if (!sp->shifts)
-       sp->shifts = shifts_new (0);
-      if (!sp->errs)
-       sp->errs = errs_new (0);
-      if (!sp->reductions)
-       sp->reductions = reductions_new (0);
-
-      state_table[sp->number] = sp;
+        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.                                         |


@@ -398,40 +336,50 @@ set_state_table (void)
 void
 generate_states (void)
 {
 void
 generate_states (void)
 {

+  state_list_t *list = NULL;

   allocate_storage ();
   new_closure (nritems);
   allocate_storage ();
   new_closure (nritems);

-  new_states ();

 
 

-  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)

     {
     {

-      if (trace_flag)
+      state_t *state = list->state;
+      if (trace_flag & trace_automaton)

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

-                this_state->number,
-                symbols[this_state->accessing_symbol]->tag);
+                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 STATE_TABLE. */
-  set_state_table ();
+  /* Set up STATES. */
+  set_states ();

 }
 }