tests: AT_YYERROR_DEFINE: prepare for list of ints.

[bison.git] / src / lalr.c

diff --git a/src/lalr.c b/src/lalr.c
index 0101149833cad5f3380bd3044f24a609a6c52115..98661544ff40d57d7f8ef17664f3c1d74b707e7c 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -1,7 +1,7 @@
 /* Compute lookahead criteria for Bison.
 
-   Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004, 2005,
-   2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1986, 1989, 2000-2012 Free Software Foundation,
+   Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -19,8 +19,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
-/* Compute how to make the finite state machine deterministic; find
-   which rules need lookahead in each state, and which lookahead
+/* Find which rules need lookahead in each state, and which lookahead
    tokens they accept.  */
 
 #include <config.h>
@@ -28,7 +27,6 @@
 
 #include <bitset.h>
 #include <bitsetv.h>
-#include <quotearg.h>
 
 #include "LR0.h"
 #include "complain.h"
@@ -36,7 +34,7 @@
 #include "getargs.h"
 #include "gram.h"
 #include "lalr.h"
-#include "muscle_tab.h"
+#include "muscle-tab.h"
 #include "nullable.h"
 #include "reader.h"
 #include "relation.h"
@@ -328,7 +326,7 @@ compute_lookahead_tokens (void)
 `----------------------------------------------------*/
 
 static int
-state_lookahead_tokens_count (state *s, bool default_rule_only_for_accept)
+state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept)
 {
   int n_lookahead_tokens = 0;
   reductions *rp = s->reductions;
@@ -344,14 +342,15 @@ state_lookahead_tokens_count (state *s, bool default_rule_only_for_accept)
   /* 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'.  However, for states that have any rules, treat only
-     the accepting state as consistent (since there is never a lookahead
-     token that makes sense there, and so no lookahead token should be
-     read) if the user has otherwise disabled default rules.  */
+     `consistent'.  However, do not treat a state with any reductions as
+     consistent unless it is the accepting state (because there is never
+     a lookahead token that makes sense there, and so no lookahead token
+     should be read) if the user has otherwise disabled default
+     reductions.  */
   if (rp->num > 1
       || (rp->num == 1 && sp->num && TRANSITION_IS_SHIFT (sp, 0))
       || (rp->num == 1 && rp->rules[0]->number != 0
-          && default_rule_only_for_accept))
+          && default_reduction_only_for_accept))
     n_lookahead_tokens += rp->num;
   else
     s->consistent = 1;
@@ -369,18 +368,21 @@ initialize_LA (void)
 {
   state_number i;
   bitsetv pLA;
-  bool default_rule_only_for_accept;
+  bool default_reduction_only_for_accept;
   {
-    char *default_rules = muscle_percent_define_get ("lr.default_rules");
-    default_rule_only_for_accept = 0 == strcmp (default_rules, "accepting");
-    free (default_rules);
+    char *default_reductions =
+      muscle_percent_define_get ("lr.default-reductions");
+    default_reduction_only_for_accept =
+      0 == strcmp (default_reductions, "accepting");
+    free (default_reductions);
   }
 
   /* Compute the total number of reductions requiring a lookahead.  */
   nLA = 0;
   for (i = 0; i < nstates; i++)
     nLA +=
-      state_lookahead_tokens_count (states[i], default_rule_only_for_accept);
+      state_lookahead_tokens_count (states[i],
+                                    default_reduction_only_for_accept);
   /* Avoid having to special case 0.  */
   if (!nLA)
     nLA = 1;
@@ -392,7 +394,8 @@ initialize_LA (void)
   for (i = 0; i < nstates; i++)
     {
       int count =
-        state_lookahead_tokens_count (states[i], default_rule_only_for_accept);
+        state_lookahead_tokens_count (states[i],
+                                      default_reduction_only_for_accept);
       if (count)
        {
          states[i]->reductions->lookahead_tokens = pLA;