X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/c6f1a33c06db52ed122d0922885602cf37f99941..c97011bfc1cabd3f7aa8e263f83d9e8a18a262bf:/src/tables.c?ds=inline

diff --git a/src/tables.c b/src/tables.c
index 91461b29..47d9d6af 100644
--- 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);
 }