* m4/prereq.m4: Update, from Coreutils 4.5.1.

[bison.git] / src / tables.c

diff --git a/src/tables.c b/src/tables.c
index 91461b29bfb397b466d69d7fd4e3d7720b2268d5..47d9d6af2e97f49492191f8fb3fb0a7a68e1473f 100644 (file)
--- a/src/tables.c
+++ b/src/tables.c
@@ -239,6 +239,7 @@ static void
 conflict_row (state_t *state)
 {
   int i, j;
+  reductions_t *reds = state->reductions;
 
   if (! glr_parser)
     return;
@@ -250,14 +251,13 @@ conflict_row (state_t *state)
 
        /* Find all reductions for token J, and record all that do not
           match ACTROW[J].  */
-       for (i = 0; i < state->nlookaheads; i += 1)
-         if (bitset_test (state->lookaheads[i], j)
+       for (i = 0; i < reds->num; i += 1)
+         if (bitset_test (reds->lookaheads[i], j)
              && (actrow[j]
-                 != rule_number_as_item_number (state->lookaheads_rule[i]->number)))
+                 != rule_number_as_item_number (reds->rules[i]->number)))
            {
              assert (conflict_list_free > 0);
-             conflict_list[conflict_list_cnt]
-               = state->lookaheads_rule[i]->number + 1;
+             conflict_list[conflict_list_cnt] = reds->rules[i]->number + 1;
              conflict_list_cnt += 1;
              conflict_list_free -= 1;
            }
@@ -304,22 +304,23 @@ action_row (state_t *state)
   for (i = 0; i < ntokens; i++)
     actrow[i] = conflrow[i] = 0;
 
-  if (redp->num >= 1)
+  if (redp->lookaheads)
     {
       int j;
       bitset_iterator biter;
       /* loop over all the rules available here which require
-        lookahead */
-      for (i = state->nlookaheads - 1; i >= 0; --i)
+        lookahead (in reverse order to give precedence to the first
+        rule) */
+      for (i = redp->num - 1; i >= 0; --i)
        /* and find each token which the rule finds acceptable
           to come next */
-       BITSET_FOR_EACH (biter, state->lookaheads[i], j, 0)
+       BITSET_FOR_EACH (biter, redp->lookaheads[i], j, 0)
        {
          /* and record this rule as the rule to use if that
             token follows.  */
          if (actrow[j] != 0)
            conflicted = conflrow[j] = 1;
-         actrow[j] = rule_number_as_item_number (state->lookaheads_rule[i]->number);
+         actrow[j] = rule_number_as_item_number (redp->rules[i]->number);
        }
     }
 
@@ -359,10 +360,10 @@ action_row (state_t *state)
       else
        {
          int max = 0;
-         for (i = 0; i < state->nlookaheads; i++)
+         for (i = 0; i < redp->num; i++)
            {
              int count = 0;
-             rule_t *rule = state->lookaheads_rule[i];
+             rule_t *rule = redp->rules[i];
              symbol_number_t j;
 
              for (j = 0; j < ntokens; j++)
@@ -393,16 +394,6 @@ action_row (state_t *state)
        }
     }
 
-  /* Find the rules which are reduced.  */
-  if (!glr_parser)
-    {
-      for (i = 0; i < ntokens; i++)
-       if (actrow[i] < 0 && actrow[i] != ACTION_MIN)
-         rules[item_number_as_rule_number (actrow[i])].useful = TRUE;
-      if (default_rule)
-       default_rule->useful = TRUE;
-    }
-
   /* If have no default rule, the default is an error.
      So replace any action which says "error" with "use default".  */
 
@@ -476,7 +467,9 @@ static void
 token_actions (void)
 {
   state_number_t i;
+  symbol_number_t j;
   rule_number_t r;
+
   int nconflict = conflicts_total_count ();
 
   yydefact = XCALLOC (rule_number_t, nstates);
@@ -484,9 +477,7 @@ token_actions (void)
   actrow = XCALLOC (action_t, ntokens);
   conflrow = XCALLOC (unsigned int, ntokens);
 
-  /* Now that the parser was computed, we can find which rules are
-     really reduced, and which are not because of SR or RR conflicts.
-     */
+  /* Find the rules which are reduced.  */
   if (!glr_parser)
     for (r = 0; r < nrules; ++r)
       rules[r].useful = FALSE;
@@ -505,17 +496,19 @@ token_actions (void)
       rule_t *default_rule = action_row (states[i]);
       yydefact[i] = default_rule ? default_rule->number + 1 : 0;
       save_row (i);
-    }
 
-  if (!glr_parser)
-    for (r = 0; r < nrules ; ++r)
-      if (!rules[r].useful)
+      /* Now that the parser was computed, we can find which rules are
+        really reduced, and which are not because of SR or RR
+        conflicts.  */
+      if (!glr_parser)
        {
-         LOCATION_PRINT (stderr, rules[r].location);
-         fprintf (stderr, ": %s: %s: ",
-                  _("warning"), _("rule never reduced because of conflicts"));
-         rule_print (&rules[r], stderr);
+         for (j = 0; j < ntokens; ++j)
+           if (actrow[j] < 0 && actrow[j] != ACTION_MIN)
+             rules[item_number_as_rule_number (actrow[j])].useful = TRUE;
+         if (yydefact[i])
+           rules[yydefact[i] - 1].useful = TRUE;
        }
+    }
 
   free (actrow);
   free (conflrow);
@@ -732,7 +725,7 @@ pack_vector (vector_number_t vector)
       for (k = 0; ok && k < t; k++)
        {
          loc = j + state_number_as_int (from[k]);
-         if (loc > (int) table_size)
+         if (loc >= (int) table_size)
            table_grow (loc);
 
          if (table[loc] != 0)
@@ -839,16 +832,6 @@ pack_table (void)
   base_ninf = table_ninf_remap (base, nvectors, BASE_MIN);
   table_ninf = table_ninf_remap (table, high + 1, ACTION_MIN);
 
-  for (i = 0; i < nvectors; i++)
-    {
-      XFREE (froms[i]);
-      XFREE (tos[i]);
-      XFREE (conflict_tos[i]);
-    }
-
-  free (froms);
-  free (tos);
-  free (conflict_tos);
   free (pos);
 }
 
@@ -862,6 +845,8 @@ pack_table (void)
 void
 tables_generate (void)
 {
+  int i;
+
   /* That's a poor way to make sure the sizes are properly corelated,
      in particular the signedness is not taking into account, but it's
      not useless.  */
@@ -877,8 +862,6 @@ tables_generate (void)
   width = XCALLOC (base_t, nvectors);
 
   token_actions ();
-  bitsetv_free (LA);
-  free (LArule);
 
   goto_actions ();
   XFREE (goto_map + ntokens);
@@ -892,6 +875,17 @@ tables_generate (void)
 
   free (tally);
   free (width);
+
+  for (i = 0; i < nvectors; i++)
+    {
+      XFREE (froms[i]);
+      XFREE (tos[i]);
+      XFREE (conflict_tos[i]);
+    }
+
+  free (froms);
+  free (tos);
+  free (conflict_tos);
 }