* tests/actions.at (Actions after errors): New test case.
[bison.git] / src / state.c
index 92180895c3ffd6fb02d13470d3aa147b23b41ae6..846bdae503e835be780cbccee594a01bceb0487a 100644 (file)
 | 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 |
@@ -140,8 +141,7 @@ state_new (symbol_number_t accessing_symbol,
 {
   state_t *res;
 
-  if (nstates >= STATE_NUMBER_MAX)
-    fatal (_("too many states (max %d)"), STATE_NUMBER_MAX);
+  assert (nstates < STATE_NUMBER_MAX);
 
   res = STATE_ALLOC (core_size);
   res->accessing_symbol = accessing_symbol;
@@ -177,7 +177,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 +189,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 +229,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 +265,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