* 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.

diff --git a/ChangeLog b/ChangeLog
index 1449cd1c5e13aa02e11518aaa3ca6a1ee03f7300..4f700c3d72d7c7963ca52fa40d9d97439ff11929 100644 (file)
--- a/ChangeLog
+++ b/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.
 2007-05-27  Joel E. Denny  <jdenny@ces.clemson.edu>
 
        Don't depend on C99 features.

diff --git a/src/lalr.c b/src/lalr.c
index af6ac9ef6bcb639a6db48dbbc5a958f33051c02f..94f6624d7a908e93b340327eee85636236880a5c 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -340,7 +340,6 @@ compute_lookahead_tokens (void)
 static int
 state_lookahead_tokens_count (state *s)
 {
 static int
 state_lookahead_tokens_count (state *s)
 {

-  int k;

   int n_lookahead_tokens = 0;
   reductions *rp = s->reductions;
   transitions *sp = s->transitions;
   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,
   /* 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
   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;
 
     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;
 }
 
   return n_lookahead_tokens;
 }
 

diff --git a/src/state.h b/src/state.h
index c2ebe9cd59aafa6b3f814877b17ead5fae556d7f..2d67bb7c31b6b0e6fa19d9fc7927d48a9c5107bd 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -202,7 +202,8 @@ struct state
   reductions *reductions;
   errs *errs;
 
   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,
   char consistent;
 
   /* If some conflicts were solved thanks to precedence/associativity,