* 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.
* src/state.h (struct state): Word the comment for member consistent
more carefully.

ChangeLog

@@ -1,3 +1,27 @@
+2007-05-28  Joel E. Denny  <jdenny@ces.clemson.edu>
+
+	* 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.
+	* src/state.h (struct state): Word the comment for member consistent
+	more carefully.
+
 2007-05-27  Joel E. Denny  <jdenny@ces.clemson.edu>
 
 	Don't depend on C99 features.

src/lalr.c

@@ -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 &&
+      || (rp->num == 1 && sp->num && TRANSITION_IS_SHIFT (sp, 0)))
-	  !TRANSITION_IS_DISABLED (sp, 0) && 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;
 }
 

src/state.h

@@ -202,7 +202,8 @@ struct state
   reductions *reductions;
   errs *errs;
 
-  /* Nonzero if no lookahead is needed to decide what to do in state S.  */
+  /* If non-zero, then no lookahead sets on reduce actions are needed to
+     decide what to do in state S.  */
   char consistent;
 
   /* If some conflicts were solved thanks to precedence/associativity,