]> git.saurik.com Git - bison.git/blobdiff - src/LR0.c
* src/reader.c (grammar_rule_begin, previous_rule, current_rule):
[bison.git] / src / LR0.c
index 3fa5ba5bda947b1bf76a52e0ece86e5d1126f681..efe9589ac946e7f657bf6ba39abec5da42566642 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.
 
    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"
 #include "complain.h"
 #include "closure.h"
 #include "LR0.h"
 #include "complain.h"
 #include "closure.h"
 #include "LR0.h"
+#include "lalr.h"
 #include "reduce.h"
 
 #include "reduce.h"
 
-int nstates;
-int final_state;
-core *first_state = NULL;
-shifts *first_shift = NULL;
-reductions *first_reduction = NULL;
+unsigned int nstates = 0;
+/* 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.
+
+   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 core *this_state = NULL;
-static core *last_state = NULL;
-static shifts *last_shift = NULL;
-static reductions *last_reduction = NULL;
+static state_t *this_state = NULL;
+static state_t *last_state = NULL;
 
 static int nshifts;
 
 static int nshifts;
-static short *shift_symbol = NULL;
+static symbol_number_t *shift_symbol = NULL;
 
 static short *redset = NULL;
 static short *shiftset = NULL;
 
 
 static short *redset = NULL;
 static short *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;
+static item_number_t *kernel_items = NULL;
 
 /* hash table for states, to recognize equivalent ones.  */
 
 
 /* hash table for states, to recognize equivalent ones.  */
 
-#define        STATE_TABLE_SIZE        1009
-static core **state_table = NULL;
+#define        STATE_HASH_SIZE 1009
+static state_t **state_hash = NULL;
 
 \f
 static void
 allocate_itemsets (void)
 {
 
 \f
 static void
 allocate_itemsets (void)
 {
-  int i;
+  int i, 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
@@ -71,11 +80,11 @@ 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 = 1; r < nrules + 1; ++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
       }
 
   /* See comments before new_itemsets.  All the vectors of items
@@ -84,9 +93,9 @@ allocate_itemsets (void)
      appears as an item, which is symbol_count[symbol].
      We allocate that much space for each symbol.  */
 
      appears as an item, which is symbol_count[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++)
@@ -107,7 +116,8 @@ allocate_storage (void)
 
   shiftset = XCALLOC (short, nsyms);
   redset = XCALLOC (short, nrules + 1);
 
   shiftset = XCALLOC (short, nsyms);
   redset = XCALLOC (short, nrules + 1);
-  state_table = XCALLOC (core *, STATE_TABLE_SIZE);
+  state_hash = XCALLOC (state_t *, STATE_HASH_SIZE);
+  shift_symbol = XCALLOC (symbol_number_t, nsyms);
 }
 
 
 }
 
 
@@ -120,7 +130,7 @@ free_storage (void)
   free (kernel_base);
   free (kernel_size);
   XFREE (kernel_items);
   free (kernel_base);
   free (kernel_size);
   XFREE (kernel_items);
-  free (state_table);
+  free (state_hash);
 }
 
 
 }
 
 
@@ -149,24 +159,22 @@ new_itemsets (void)
   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]++;
+      }
 }
 
 
 }
 
 
@@ -176,27 +184,38 @@ new_itemsets (void)
 | necessary.                                                       |
 `-----------------------------------------------------------------*/
 
 | necessary.                                                       |
 `-----------------------------------------------------------------*/
 
-static core *
-new_state (int symbol)
+static state_t *
+new_state (symbol_number_t symbol, size_t core_size, item_number_t *core)
 {
 {
-  core *p;
+  state_t *p;
 
   if (trace_flag)
     fprintf (stderr, "Entering new_state, state = %d, symbol = %d (%s)\n",
 
   if (trace_flag)
     fprintf (stderr, "Entering new_state, state = %d, symbol = %d (%s)\n",
-            this_state->number, symbol, tags[symbol]);
+            nstates, symbol, quotearg_style (escape_quoting_style,
+                                             symbols[symbol]->tag));
 
 
-  if (nstates >= MAXSHORT)
-    fatal (_("too many states (max %d)"), MAXSHORT);
+  if (nstates >= SHRT_MAX)
+    fatal (_("too many states (max %d)"), SHRT_MAX);
 
 
-  p = CORE_ALLOC (kernel_size[symbol]);
+  p = STATE_ALLOC (core_size);
   p->accessing_symbol = symbol;
   p->number = nstates;
   p->accessing_symbol = symbol;
   p->number = nstates;
-  p->nitems = kernel_size[symbol];
+  p->solved_conflicts = NULL;
+
+  p->nitems = core_size;
+  memcpy (p->items, core, core_size * sizeof (core[0]));
 
 
-  shortcpy (p->items, kernel_base[symbol], kernel_size[symbol]);
+  /* 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 = p->number;
 
 
-  last_state->next = p;
+  if (!first_state)
+    first_state = p;
+  if (last_state)
+    last_state->next = p;
   last_state = p;
   last_state = p;
+
   nstates++;
 
   return p;
   nstates++;
 
   return p;
@@ -210,34 +229,35 @@ new_state (int symbol)
 `--------------------------------------------------------------*/
 
 static int
 `--------------------------------------------------------------*/
 
 static int
-get_state (int symbol)
+get_state (symbol_number_t symbol, size_t core_size, item_number_t *core)
 {
   int key;
 {
   int key;
-  int i;
-  core *sp;
+  size_t i;
+  state_t *sp;
 
   if (trace_flag)
     fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",
 
   if (trace_flag)
     fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",
-            this_state->number, symbol, tags[symbol]);
+            this_state->number, symbol, quotearg_style (escape_quoting_style,
+                                             symbols[symbol]->tag));
 
   /* Add up the target state's active item numbers to get a hash key.
      */
   key = 0;
 
   /* 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_TABLE_SIZE;
-  sp = state_table[key];
+  for (i = 0; i < core_size; ++i)
+    key += core[i];
+  key = key % STATE_HASH_SIZE;
+  sp = state_hash[key];
 
   if (sp)
     {
       int found = 0;
       while (!found)
        {
 
   if (sp)
     {
       int found = 0;
       while (!found)
        {
-         if (sp->nitems == kernel_size[symbol])
+         if (sp->nitems == core_size)
            {
              found = 1;
            {
              found = 1;
-             for (i = 0; i < kernel_size[symbol]; ++i)
-               if (kernel_base[symbol][i] != sp->items[i])
+             for (i = 0; i < core_size; ++i)
+               if (core[i] != sp->items[i])
                  found = 0;
            }
 
                  found = 0;
            }
 
@@ -249,7 +269,7 @@ get_state (int symbol)
                }
              else              /* bucket exhausted and no match */
                {
                }
              else              /* bucket exhausted and no match */
                {
-                 sp = sp->link = new_state (symbol);
+                 sp = sp->link = new_state (symbol, core_size, core);
                  found = 1;
                }
            }
                  found = 1;
                }
            }
@@ -257,7 +277,7 @@ get_state (int symbol)
     }
   else                         /* bucket is empty */
     {
     }
   else                         /* bucket is empty */
     {
-      state_table[key] = sp = new_state (symbol);
+      state_hash[key] = sp = new_state (symbol, core_size, core);
     }
 
   if (trace_flag)
     }
 
   if (trace_flag)
@@ -278,7 +298,7 @@ append_states (void)
 {
   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",
@@ -299,15 +319,21 @@ append_states (void)
     }
 
   for (i = 0; i < nshifts; i++)
     }
 
   for (i = 0; i < nshifts; i++)
-    shiftset[i] = get_state (shift_symbol[i]);
+    {
+      symbol = shift_symbol[i];
+      shiftset[i] = get_state (symbol,
+                              kernel_size[symbol], kernel_base[symbol]);
+    }
 }
 
 
 static void
 new_states (void)
 {
 }
 
 
 static void
 new_states (void)
 {
-  first_state = last_state = this_state = CORE_ALLOC (0);
-  nstates = 1;
+  /* The 0 at the lhs is the index of the item of this initial rule.  */
+  kernel_base[0][0] = 0;
+  kernel_size[0] = 1;
+  this_state = new_state (0, kernel_size[0], kernel_base[0]);
 }
 
 
 }
 
 
@@ -319,208 +345,8 @@ static void
 save_shifts (void)
 {
   shifts *p = shifts_new (nshifts);
 save_shifts (void)
 {
   shifts *p = shifts_new (nshifts);
-
-  p->number = this_state->number;
-
-  shortcpy (p->shifts, shiftset, nshifts);
-
-  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.      |
-`------------------------------------------------------------------*/
-
-static void
-insert_start_shift (void)
-{
-  core *statep;
-  shifts *sp;
-
-  statep = CORE_ALLOC (0);
-  statep->number = nstates;
-  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);
-  sp->number = nstates++;
-  sp->shifts[0] = nstates;
-
-  last_shift->next = sp;
-  last_shift = sp;
-}
-
-
-/*------------------------------------------------------------------.
-| 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)
-{
-  core *statep;
-  shifts *sp;
-  shifts *sp1 = NULL;
-
-  sp = first_shift;
-
-  if (!sp->nshifts)
-    {
-      /* There are no shifts for any state.  Make one shift, from the
-        initial state to the next-to-final state.  */
-
-      sp = shifts_new (1);
-      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_shift ();
-    }
-  else if (sp->number == 0)
-    {
-      statep = first_state->next;
-
-      /* The states reached by shifts from FIRST_STATE are numbered
-        1..(SP->NSHIFTS).  Look for one reached by START_SYMBOL.  */
-      while (statep->accessing_symbol < start_symbol
-            && statep->number < sp->nshifts)
-       statep = statep->next;
-
-      if (statep->accessing_symbol == start_symbol)
-       {
-         /* We already have a next-to-final state.
-            Make sure it has a shift to what will be the final state.  */
-         while (sp && sp->number < statep->number)
-           {
-             sp1 = sp;
-             sp = sp->next;
-           }
-
-         if (sp && sp->number == statep->number)
-           {
-             int i;
-             shifts *sp2 = shifts_new (sp->nshifts + 1);
-             sp2->number = statep->number;
-             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);
-           }
-         else
-           {
-             shifts *sp2 = shifts_new (1);
-             sp2->number = statep->number;
-             sp2->shifts[0] = nstates;
-
-             /* Patch sp2 into the chain of shifts between sp1 and sp.  */
-             sp2->next = sp;
-             sp1->next = sp2;
-             if (sp == 0)
-               last_shift = sp2;
-           }
-       }
-      else
-       {
-         int i, k;
-         shifts *sp2;
-
-         /* 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).  */
-         sp = first_shift;
-
-         sp2 = shifts_new (sp->nshifts + 1);
-
-         /* 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.  */
-         insert_start_shift ();
-       }
-    }
-  else
-    {
-      /* The initial state didn't even have any shifts.
-        Give it one shift, to the next-to-final state.  */
-      sp = shifts_new (1);
-      sp->shifts[0] = nstates;
-
-      /* Patch sp into the chain of shifts at the beginning.  */
-      sp->next = first_shift;
-      first_shift = sp;
-
-      /* Create the next-to-final state, with shift to
-        what will be the final state.  */
-      insert_start_shift ();
-    }
-
-  /* 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 = CORE_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);
-  sp->number = nstates++;
-  sp->shifts[0] = nstates;
-  last_shift->next = sp;
-  last_shift = sp;
-
-  /* Note that the variable `final_state' refers to what we sometimes call
-     the termination state.  */
-  final_state = nstates;
-
-  /* Make the termination state.  */
-  statep = CORE_ALLOC (0);
-  statep->number = nstates++;
-  last_state->next = statep;
-  last_state = statep;
+  memcpy (p->shifts, shiftset, nshifts * sizeof (shiftset[0]));
+  this_state->shifts = p;
 }
 
 
 }
 
 
@@ -533,13 +359,16 @@ augment_automaton (void)
 static void
 save_reductions (void)
 {
 static void
 save_reductions (void)
 {
-  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 (this_state->number == final_state)
+    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)
@@ -547,25 +376,37 @@ save_reductions (void)
     }
 
   /* 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);
+  memcpy (this_state->reductions->rules, redset, count * sizeof (redset[0]));
+}
 
 
-  if (count)
-    {
-      reductions *p = REDUCTIONS_ALLOC (count);
-
-      p->number = this_state->number;
-      p->nreds = count;
+\f
+/*---------------.
+| Build STATES.  |
+`---------------*/
 
 
-      shortcpy (p->rules, redset, count);
+static void
+set_states (void)
+{
+  state_t *sp;
+  states = XCALLOC (state_t *, nstates);
 
 
-      if (last_reduction)
-       last_reduction->next = p;
-      else
-       first_reduction = p;
-      last_reduction = p;
+  for (sp = first_state; sp; sp = sp->next)
+    {
+      /* 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);
+
+      states[sp->number] = sp;
     }
 }
 
     }
 }
 
-\f
 /*-------------------------------------------------------------------.
 | 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.                                         |
@@ -575,14 +416,16 @@ void
 generate_states (void)
 {
   allocate_storage ();
 generate_states (void)
 {
   allocate_storage ();
-  new_closure (nitems);
+  new_closure (nritems);
   new_states ();
 
   while (this_state)
     {
       if (trace_flag)
        fprintf (stderr, "Processing state %d (reached by %s)\n",
   new_states ();
 
   while (this_state)
     {
       if (trace_flag)
        fprintf (stderr, "Processing state %d (reached by %s)\n",
-                this_state->number, tags[this_state->accessing_symbol]);
+                this_state->number,
+                quotearg_style (escape_quoting_style,
+                                symbols[this_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
       /* 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
@@ -607,6 +450,6 @@ generate_states (void)
   free_closure ();
   free_storage ();
 
   free_closure ();
   free_storage ();
 
-  /* set up initial and final states as parser wants them */
-  augment_automaton ();
+  /* Set up STATES. */
+  set_states ();
 }
 }