consistent states and error transitions

[Joel E. Denny]

I'd like to commit the following.  I'd appreciate a second pair of eyes to 
be sure my assumptions are correct.

Index: ChangeLog
===================================================================
RCS file: /sources/bison/bison/ChangeLog,v
retrieving revision 1.1702
diff -p -u -r1.1702 ChangeLog
--- ChangeLog   26 May 2007 20:08:18 -0000      1.1702
+++ ChangeLog   26 May 2007 22:13:39 -0000
@@ -15,6 +15,26 @@
        * doc/bison.texinfo (Prologue Alternatives): Mention that directives
        in the rules section must be terminated by semicolons.
 
+       * src/lalr.c (state_lookahead_tokens_count): For code readability,
+       move the check for disabled transitions to an aver since conflict
+       resolution hasn't happened yet.
+
+       * src/lalr.c (state_lookahead_tokens_count): Remove the check that
+       labels a state as inconsistent just because it has error transitions.
+       The original form of this check appeared in revision 1.1 of lalr.c,
+       which was committed on 1991-12-21.  Now (at least), changing the
+       consistency label on such a state appears to have no useful effect in
+       any of the places it is examined, which I enumerate below.  The key
+       point to understanding each item in this enumeration is that a state
+       with an error transition is labelled consistent in the first place only
+       if it has no rules, so the check cannot matter for states that have
+       rules.  (1) Labelling a state as inconsistent will cause set_conflicts
+       to try to identify its conflicts, and a state must have *rules* to have
+       conflicts.  (2) Labelling a state as inconsistent will affect how
+       action_row sets the default *rule* for the state.  (3) Labelling a
+       state as inconsistent will cause build_relations to add lookback edges
+       to *rules* in that state.
+
 2007-05-20  Joel E. Denny  <address@hidden>
 
        Extend the front-end API for %define variables to more completely
Index: src/lalr.c
===================================================================
RCS file: /sources/bison/bison/src/lalr.c,v
retrieving revision 1.113
diff -p -u -r1.113 lalr.c
--- src/lalr.c  8 May 2007 05:03:53 -0000       1.113
+++ src/lalr.c  26 May 2007 22:13:40 -0000
@@ -340,7 +340,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 +347,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;
 }