X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/742e4900c8b05c8c1f56985288141c890f1e9c73..9987d1b3cce14fd74c4bc382048254697c2de945:/src/lalr.c?ds=inline

diff --git a/src/lalr.c b/src/lalr.c
index e7f51455..15213422 100644
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -1,24 +1,22 @@
 /* Compute lookahead criteria for Bison.
 
    Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004, 2005,
-   2006 Free Software Foundation, Inc.
+   2006, 2007 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
-   Bison is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
 
-   Bison is distributed in the hope that it will be useful,
+   This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with Bison; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 /* Compute how to make the finite state machine deterministic; find
@@ -56,7 +54,7 @@ typedef struct goto_list
 } goto_list;
 
 
-/* LA is a LR by NTOKENS matrix of bits.  LA[l, i] is 1 if the rule
+/* LA is an NLA by NTOKENS matrix of bits.  LA[l, i] is 1 if the rule
    LArule[l] is applicable in the appropriate state when the next
    token is symbol i.  If LA[l, i] and LA[l, j] are both 1 for i != j,
    it is a conflict.  */
@@ -94,7 +92,7 @@ set_goto_map (void)
 	  ngotos++;
 
 	  /* Abort if (ngotos + 1) would overflow.  */
-	  assert (ngotos != GOTO_NUMBER_MAXIMUM);
+	  aver (ngotos != GOTO_NUMBER_MAXIMUM);
 
 	  goto_map[TRANSITION_SYMBOL (sp, i) - ntokens]++;
 	}
@@ -153,7 +151,7 @@ map_goto (state_number s0, symbol_number sym)
 
   for (;;)
     {
-      assert (low <= high);
+      aver (low <= high);
       middle = (low + high) / 2;
       s = from_state[middle];
       if (s == s0)
@@ -340,7 +338,6 @@ compute_lookahead_tokens (void)
 static int
 state_lookahead_tokens_count (state *s)
 {
-  int k;
   int n_lookahead_tokens = 0;
   reductions *rp = s->reductions;
   transitions *sp = s->transitions;
@@ -348,21 +345,17 @@ state_lookahead_tokens_count (state *s)
   /* We need a lookahead either to distinguish different
      reductions (i.e., there are two or more), or to distinguish a
      reduction from a shift.  Otherwise, it is straightforward,
-     and the state is `consistent'.  */
+     and the state is `consistent'.  There is no need to check that
+     transition 0 hasn't been disabled before checking if it is a
+     shift since transitions are only disabled during conflict
+     resolution, and that hasn't happened yet.  */
+  aver (sp->num == 0 || !TRANSITION_IS_DISABLED (sp, 0));
   if (rp->num > 1
-      || (rp->num == 1 && sp->num &&
-	  !TRANSITION_IS_DISABLED (sp, 0) && TRANSITION_IS_SHIFT (sp, 0)))
+      || (rp->num == 1 && sp->num && TRANSITION_IS_SHIFT (sp, 0)))
     n_lookahead_tokens += rp->num;
   else
     s->consistent = 1;
 
-  for (k = 0; k < sp->num; k++)
-    if (!TRANSITION_IS_DISABLED (sp, k) && TRANSITION_IS_ERROR (sp, k))
-      {
-	s->consistent = 0;
-	break;
-      }
-
   return n_lookahead_tokens;
 }
 
@@ -453,6 +446,40 @@ lalr (void)
 }
 
 
+void
+lalr_update_state_numbers (state_number old_to_new[], state_number nstates_old)
+{
+  goto_number ngotos_reachable = 0;
+  symbol_number nonterminal = 0;
+  aver (nsyms == nvars + ntokens);
+  {
+    goto_number i;
+    for (i = 0; i < ngotos; ++i)
+      {
+        while (i == goto_map[nonterminal])
+          goto_map[nonterminal++] = ngotos_reachable;
+        /* If old_to_new[from_state[i]] = nstates_old, remove this goto
+           entry.  */
+        if (old_to_new[from_state[i]] != nstates_old)
+          {
+            /* from_state[i] is not removed, so it and thus to_state[i] are
+               reachable, so to_state[i] != nstates_old.  */
+            aver (old_to_new[to_state[i]] != nstates_old);
+            from_state[ngotos_reachable] = old_to_new[from_state[i]];
+            to_state[ngotos_reachable] = old_to_new[to_state[i]];
+            ++ngotos_reachable;
+          }
+      }
+  }
+  while (nonterminal <= nvars)
+    {
+      aver (ngotos == goto_map[nonterminal]);
+      goto_map[nonterminal++] = ngotos_reachable;
+    }
+  ngotos = ngotos_reachable;
+}
+
+
 void
 lalr_free (void)
 {