X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7db2ed2d82f65d980ab93645e288b0b75c74e3e6..78bcec17c82fe777c90f86717773de35bb5018e7:/src/state.c?ds=sidebyside

diff --git a/src/state.c b/src/state.c
index 92180895..b258ceeb 100644
--- a/src/state.c
+++ b/src/state.c
@@ -35,12 +35,12 @@
 | Create a new array of N shifts/gotos.  |
 `---------------------------------------*/
 
-#define TRANSITIONS_ALLOC(Num)					\
-  (transitions_t *) xcalloc ((sizeof (transitions_t) 			\
-                                  + (Num - 1) * sizeof (state_number_t)), 1)
+#define TRANSITIONS_ALLOC(Num)						\
+  (transitions_t *) xcalloc ((sizeof (transitions_t)			\
+                                  + (Num - 1) * sizeof (state_t *)), 1)
 
 static transitions_t *
-transitions_new (int num, state_number_t *the_states)
+transitions_new (int num, state_t **the_states)
 {
   transitions_t *res = TRANSITIONS_ALLOC (num);
   res->num = num;
@@ -60,7 +60,7 @@ transitions_to (transitions_t *shifts, symbol_number_t s)
   int j;
   for (j = 0; j < shifts->num; j++)
     if (TRANSITION_SYMBOL (shifts, j) == s)
-      return states[shifts->states[j]];
+      return shifts->states[j];
   abort ();
 }
 
@@ -76,11 +76,11 @@ transitions_to (transitions_t *shifts, symbol_number_t s)
 
 #define ERRS_ALLOC(Nerrs)				\
   (errs_t *) xcalloc ((sizeof (errs_t)			\
-                      + (Nerrs - 1) * sizeof (symbol_number_t)), 1)
+                      + (Nerrs - 1) * sizeof (symbol_t *)), 1)
 
 
 errs_t *
-errs_new (int num, symbol_number_t *tokens)
+errs_new (int num, symbol_t **tokens)
 {
   errs_t *res = ERRS_ALLOC (num);
   res->num = num;
@@ -100,16 +100,17 @@ errs_new (int num, symbol_number_t *tokens)
 | Create a new array of N reductions.  |
 `-------------------------------------*/
 
-#define REDUCTIONS_ALLOC(Nreductions)				\
-  (reductions_t *) xcalloc ((sizeof (reductions_t)		\
-                            + (Nreductions - 1) * sizeof (rule_number_t)), 1)
+#define REDUCTIONS_ALLOC(Nreductions)                          \
+  (reductions_t *) xcalloc ((sizeof (reductions_t)             \
+                            + (Nreductions - 1) * sizeof (rule_t *)), 1)
 
 static reductions_t *
-reductions_new (int num, rule_number_t *reductions)
+reductions_new (int num, rule_t **reductions)
 {
   reductions_t *res = REDUCTIONS_ALLOC (num);
   res->num = num;
   memcpy (res->rules, reductions, num * sizeof (reductions[0]));
+  res->lookaheads = NULL;
   return res;
 }
 
@@ -122,12 +123,12 @@ reductions_new (int num, rule_number_t *reductions)
 
 state_number_t nstates = 0;
 /* FINAL_STATE is properly set by new_state when it recognizes its
-   accessing symbol: EOF.  */
+   accessing symbol: $end.  */
 state_t *final_state = NULL;
 
 #define STATE_ALLOC(Nitems)						\
-  (state_t *) xcalloc ((unsigned) (sizeof (state_t) 			\
-                                  + (Nitems - 1) * sizeof (item_number_t)), 1)
+  (state_t *) xcalloc ((sizeof (state_t) 		       		\
+			+ (Nitems - 1) * sizeof (item_number_t)), 1)
 
 /*------------------------------------------------------------------.
 | Create a new state with ACCESSING_SYMBOL, for those items.  Store |
@@ -177,7 +178,7 @@ state_free (state_t *state)
 `-------------------------------*/
 
 void
-state_transitions_set (state_t *state, int num, state_number_t *transitions)
+state_transitions_set (state_t *state, int num, state_t **transitions)
 {
   assert (!state->transitions);
   state->transitions = transitions_new (num, transitions);
@@ -189,19 +190,31 @@ state_transitions_set (state_t *state, int num, state_number_t *transitions)
 `------------------------------*/
 
 void
-state_reductions_set (state_t *state, int num, rule_number_t *reductions)
+state_reductions_set (state_t *state, int num, rule_t **reductions)
 {
   assert (!state->reductions);
   state->reductions = reductions_new (num, reductions);
 }
 
 
+int
+state_reduction_find (state_t *state, rule_t *rule)
+{
+  int i;
+  reductions_t *reds = state->reductions;
+  for (i = 0; i < reds->num; ++i)
+    if (reds->rules[i] == rule)
+      return i;
+  return -1;
+}
+
+
 /*------------------------.
 | Set the errs of STATE.  |
 `------------------------*/
 
 void
-state_errs_set (state_t *state, int num, symbol_number_t *tokens)
+state_errs_set (state_t *state, int num, symbol_t **tokens)
 {
   assert (!state->errs);
   state->errs = errs_new (num, tokens);
@@ -217,25 +230,21 @@ state_errs_set (state_t *state, int num, symbol_number_t *tokens)
 void
 state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out)
 {
-  int j, k;
-  bitset_iterator biter;
-  int nlookaheads = 0;
-  /* Count the number of lookaheads corresponding to this rule.  */
-  for (j = 0; j < state->nlookaheads; ++j)
-    BITSET_FOR_EACH (biter, state->lookaheads[j], k, 0)
-      if (state->lookaheads_rule[j]->number == rule->number)
-	nlookaheads++;
+  /* Find the reduction we are handling.  */
+  reductions_t *reds = state->reductions;
+  int red = state_reduction_find (state, rule);
 
   /* Print them if there are.  */
-  if (nlookaheads)
+  if (reds->lookaheads && red != -1)
     {
+      bitset_iterator biter;
+      int k;
+      int not_first = 0;
       fprintf (out, "  [");
-      for (j = 0; j < state->nlookaheads; ++j)
-	BITSET_FOR_EACH (biter, state->lookaheads[j], k, 0)
-	  if (state->lookaheads_rule[j]->number == rule->number)
-	    fprintf (out, "%s%s",
-		     symbols[k]->tag,
-		     --nlookaheads ? ", " : "");
+      BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0)
+	fprintf (out, "%s%s",
+		 not_first++ ? ", " : "",
+		 symbols[k]->tag);
       fprintf (out, "]");
     }
 }
@@ -257,13 +266,13 @@ state_compare (const state_t *s1, const state_t *s2)
   int i;
 
   if (s1->nitems != s2->nitems)
-    return FALSE;
+    return false;
 
   for (i = 0; i < s1->nitems; ++i)
     if (s1->items[i] != s2->items[i])
-      return FALSE;
+      return false;
 
-  return TRUE;
+  return true;
 }
 
 static unsigned int