* src/state.h (reductions_t): Rename member `nreds' as num.

[bison.git] / src / state.c

diff --git a/src/state.c b/src/state.c
index dd8ec7500c5387e82313f81c8aad0e028c17cc88..37add6d1f37839e9992d30f3c3a8220feeca62fe 100644 (file)
--- a/src/state.c
+++ b/src/state.c
@@ -35,20 +35,34 @@
 | Create a new array of N shifts/gotos.  |
 `---------------------------------------*/
 
-#define SHIFTS_ALLOC(Nshifts)                                          \
-  (shifts_t *) xcalloc ((unsigned) (sizeof (shifts_t)                  \
+#define TRANSITIONS_ALLOC(Nshifts)                                             \
+  (transitions_t *) xcalloc ((unsigned) (sizeof (transitions_t)                        \
                                   + (Nshifts - 1) * sizeof (state_number_t)), 1)
 
-static shifts_t *
-shifts_new (int nshifts, state_number_t *shifts)
+static transitions_t *
+transitions_new (int num, state_number_t *the_states)
 {
-  shifts_t *res = SHIFTS_ALLOC (nshifts);
-  res->nshifts = nshifts;
-  memcpy (res->shifts, shifts, nshifts * sizeof (shifts[0]));
+  transitions_t *res = TRANSITIONS_ALLOC (num);
+  res->num = num;
+  memcpy (res->states, the_states, num * sizeof (the_states[0]));
   return res;
 }
 
 
+/*-------------------------------------------------------------------.
+| Return the state such these TRANSITIONS contain a shift/goto to it |
+| on SYMBOL.  Aborts if none found.                                  |
+`-------------------------------------------------------------------*/
+
+state_t *
+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]];
+  abort ();
+}
 
 
                        /*--------------------.
@@ -62,14 +76,14 @@ shifts_new (int nshifts, state_number_t *shifts)
 
 #define ERRS_ALLOC(Nerrs)                                              \
   (errs_t *) xcalloc ((unsigned) (sizeof (errs_t)                      \
-                                  + (Nerrs - 1) * sizeof (short)), 1)
+                                  + (Nerrs - 1) * sizeof (symbol_number_t)), 1)
 
 
 errs_t *
 errs_new (int n)
 {
   errs_t *res = ERRS_ALLOC (n);
-  res->nerrs = n;
+  res->num = n;
   return res;
 }
 
@@ -77,8 +91,8 @@ errs_new (int n)
 errs_t *
 errs_dup (errs_t *src)
 {
-  errs_t *res = errs_new (src->nerrs);
-  memcpy (res->errs, src->errs, src->nerrs * sizeof (src->errs[0]));
+  errs_t *res = errs_new (src->num);
+  memcpy (res->symbols, src->symbols, src->num * sizeof (src->symbols[0]));
   return res;
 }
 
@@ -96,13 +110,13 @@ errs_dup (errs_t *src)
 
 #define REDUCTIONS_ALLOC(Nreductions)                                  \
   (reductions_t *) xcalloc ((unsigned) (sizeof (reductions_t)          \
-                                  + (Nreductions - 1) * sizeof (short)), 1)
+                                  + (Nreductions - 1) * sizeof (rule_number_t)), 1)
 
 static reductions_t *
 reductions_new (int nreductions, short *reductions)
 {
   reductions_t *res = REDUCTIONS_ALLOC (nreductions);
-  res->nreds = nreductions;
+  res->num = nreductions;
   memcpy (res->rules, reductions, nreductions * sizeof (reductions[0]));
   return res;
 }
@@ -154,9 +168,9 @@ state_new (symbol_number_t accessing_symbol,
 `--------------------------*/
 
 void
-state_shifts_set (state_t *state, int nshifts, state_number_t *shifts)
+state_transitions_set (state_t *state, int nshifts, state_number_t *shifts)
 {
-  state->shifts = shifts_new (nshifts, shifts);
+  state->shifts = transitions_new (nshifts, shifts);
 }
 
 
@@ -184,22 +198,24 @@ state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out)
   int nlookaheads = 0;
   /* Count the number of lookaheads corresponding to this rule.  */
   for (j = 0; j < state->nlookaheads; ++j)
-    for (k = 0; k < ntokens; ++k)
-      if (bitset_test (state->lookaheads[j], k)
-         && state->lookaheads_rule[j]->number == rule->number)
+    BITSET_EXECUTE (state->lookaheads[j], 0, k,
+    {
+      if (state->lookaheads_rule[j]->number == rule->number)
        nlookaheads++;
+    });
 
   /* Print them if there are.  */
   if (nlookaheads)
     {
       fprintf (out, "  [");
       for (j = 0; j < state->nlookaheads; ++j)
-       for (k = 0; k < ntokens; ++k)
-         if (bitset_test (state->lookaheads[j], k)
-             && state->lookaheads_rule[j]->number == rule->number)
+       BITSET_EXECUTE (state->lookaheads[j], 0, k,
+       {
+         if (state->lookaheads_rule[j]->number == rule->number)
            fprintf (out, "%s%s",
                     symbol_tag_get (symbols[k]),
                     --nlookaheads ? ", " : "");
+       });
       fprintf (out, "]");
     }
 }