Regen.

[bison.git] / src / state.c

diff --git a/src/state.c b/src/state.c
index bdf2586b22429e492bac771276a84bbc5137c942..b258ceeb6b9f096889c72de4e2c6319874660c4e 100644 (file)
--- a/src/state.c
+++ b/src/state.c
@@ -35,12 +35,12 @@
 | Create a new array of N shifts/gotos.  |
 `---------------------------------------*/
 
 | 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 *
 
 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;
 {
   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)
   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 ();
 }
 
   abort ();
 }
 


@@ -76,11 +76,11 @@ transitions_to (transitions_t *shifts, symbol_number_t s)
 
 #define ERRS_ALLOC(Nerrs)                              \
   (errs_t *) xcalloc ((sizeof (errs_t)                 \
 
 #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_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;
 {
   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.  |
 `-------------------------------------*/
 
 | 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 *
 
 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]));
 {
   reductions_t *res = REDUCTIONS_ALLOC (num);
   res->num = num;
   memcpy (res->rules, reductions, num * sizeof (reductions[0]));

+  res->lookaheads = NULL;

   return res;
 }
 
   return res;
 }
 


@@ -126,8 +127,8 @@ state_number_t nstates = 0;
 state_t *final_state = NULL;
 
 #define STATE_ALLOC(Nitems)                                            \
 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 |
 
 /*------------------------------------------------------------------.
 | Create a new state with ACCESSING_SYMBOL, for those items.  Store |


@@ -177,7 +178,7 @@ state_free (state_t *state)
 `-------------------------------*/
 
 void
 `-------------------------------*/
 
 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);
 {
   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
 `------------------------------*/
 
 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);
 }
 
 
 {
   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
 /*------------------------.
 | 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);
 {
   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)
 {
 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.  */
 
   /* Print them if there are.  */

-  if (nlookaheads)
+  if (reds->lookaheads && red != -1)

     {
     {

+      bitset_iterator biter;
+      int k;
+      int not_first = 0;

       fprintf (out, "  [");
       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, "]");
     }
 }
       fprintf (out, "]");
     }
 }


@@ -257,13 +266,13 @@ state_compare (const state_t *s1, const state_t *s2)
   int i;
 
   if (s1->nitems != s2->nitems)
   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])
 
   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
 }
 
 static unsigned int