* src/state.h, src/state.c (reductions_new): New.

* src/LR0.c (set_state_table): Let all the states have a
`reductions', even if reduced to 0.
(save_reductions): Adjust.
* src/lalr.c (initialize_LA, initialize_lookaheads): Adjust.
* src/print.c (print_reductions, print_actions): Adjust.
* src/output.c (action_row): Adjust.

diff --git a/ChangeLog b/ChangeLog
index c600ff3aa2efb4fc484d5615922535ccc841668c..3eb452562c8f535dd28de734b48dff8eadac2be7 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,14 @@
+2001-12-27  Akim Demaille  <akim@epita.fr>
+
+       * src/state.h, src/state.c (reductions_new): New.
+       * src/LR0.c (set_state_table): Let all the states have a
+       `reductions', even if reduced to 0.
+       (save_reductions): Adjust.
+       * src/lalr.c (initialize_LA, initialize_lookaheads): Adjust.
+       * src/print.c (print_reductions, print_actions): Adjust.
+       * src/output.c (action_row): Adjust.
+
+       
 2001-12-27  Akim Demaille  <akim@epita.fr>
 
        * src/state.h, src/state.c (errs_new, errs_dup): New.

diff --git a/src/LR0.c b/src/LR0.c
index 4f771d21088eff52ba72dcafd84dac4a0145c28a..a9a69655914cda8d7d869a925cf6d957f4c53a5d 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -522,15 +522,8 @@ save_reductions (void)
     }
 
   /* Make a reductions structure and copy the data into it.  */
-
-  if (count)
-    {
-      reductions *p = REDUCTIONS_ALLOC (count);
-      p->nreds = count;
-      shortcpy (p->rules, redset, count);
-
-      this_state->reductions = p;
-    }
+  this_state->reductions = reductions_new (count);
+  shortcpy (this_state->reductions->rules, redset, count);
 }
 
 \f
@@ -547,11 +540,14 @@ set_state_table (void)
   for (sp = first_state; sp; sp = sp->next)
     {
       /* Pessimization, but simplification of the code: make sure all
-        the states have a shifts and errs, even if reduced to 0.  */
+        the states have a shifts, errs, and reductions, even if
+        reduced to 0.  */
       if (!sp->shifts)
        sp->shifts = shifts_new (0);
       if (!sp->errs)
        sp->errs = errs_new (0);
+      if (!sp->reductions)
+       sp->reductions = reductions_new (0);
 
       state_table[sp->number] = sp;
     }

diff --git a/src/lalr.c b/src/lalr.c
index 3851350bdfce5482587ae71803ebf86196c92c8f..db9abfa3c8c0226474aa92613b6f0817068eb283 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -137,7 +137,6 @@ initialize_LA (void)
   int i;
   int j;
   short *np;
-  reductions *rp;
 
   /* Avoid having to special case 0.  */
   if (!nLA)
@@ -150,9 +149,8 @@ initialize_LA (void)
   np = LAruleno;
   for (i = 0; i < nstates; i++)
     if (!state_table[i]->consistent)
-      if ((rp = state_table[i]->reductions))
-       for (j = 0; j < rp->nreds; j++)
-         *np++ = rp->rules[j];
+      for (j = 0; j < state_table[i]->reductions->nreds; j++)
+       *np++ = state_table[i]->reductions->rules[j];
 }
 
 
@@ -525,8 +523,12 @@ initialize_lookaheads (void)
       reductions *rp = state_table[i]->reductions;
       shifts *sp = state_table[i]->shifts;
 
-      if (rp
-         && (rp->nreds > 1 || (sp->nshifts && SHIFT_IS_SHIFT (sp, 0))))
+      /* We need a lookahead either to distinguish different
+        reductions (i.e., there are two or more), or to distinguish a
+        reduction from a shift.  Otherwise, it is straightforward,
+        and the state is `consistent'.  */
+      if (rp->nreds > 1
+         || (rp->nreds == 1 && sp->nshifts && SHIFT_IS_SHIFT (sp, 0)))
        nlookaheads += rp->nreds;
       else
        state_table[i]->consistent = 1;

diff --git a/src/output.c b/src/output.c
index c424716cc873dd2e2dfbaa503aa97fb10a001271..34ff7d36551e6bf32c7551def2ff78eca1f209d0 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -326,7 +326,6 @@ action_row (state_t *state)
   int i;
   int default_rule = 0;
   reductions *redp = state->reductions;
-  int nreds = redp ? redp->nreds : 0;
   shifts *shiftp = state->shifts;
   errs *errp = state->errs;
   /* set nonzero to inhibit having any default reduction */
@@ -335,7 +334,7 @@ action_row (state_t *state)
   for (i = 0; i < ntokens; i++)
     actrow[i] = 0;
 
-  if (nreds >= 1)
+  if (redp->nreds >= 1)
     {
       int j;
       /* loop over all the rules available here which require
@@ -384,7 +383,7 @@ action_row (state_t *state)
   /* Now find the most common reduction and make it the default action
      for this state.  */
 
-  if (nreds >= 1 && !nodefault)
+  if (redp->nreds >= 1 && !nodefault)
     {
       if (state->consistent)
        default_rule = redp->rules[0];

diff --git a/src/print.c b/src/print.c
index b9c518f7dd1bd6f3ca35c46ba7821eab712de174..b6c41a85ed7a560b09b7c9305d2d2c7aab5224f3 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -167,6 +167,9 @@ print_reductions (FILE *out, state_t *state)
   errs *errp = state->errs;
   int nodefault = 0;
 
+  if (redp->nreds == 0)
+    return;
+
   if (state->consistent)
     {
       int rule = redp->rules[0];
@@ -302,7 +305,7 @@ print_actions (FILE *out, state_t *state)
   reductions *redp = state->reductions;
   shifts *shiftp = state->shifts;
 
-  if (!shiftp->nshifts && !redp)
+  if (shiftp->nshifts == 0 && redp->nreds == 0)
     {
       if (final_state == state->number)
        fprintf (out, _("    $default\taccept\n"));
@@ -313,8 +316,7 @@ print_actions (FILE *out, state_t *state)
 
   print_shifts (out, state);
   print_errs (out, state);
-  if (redp)
-    print_reductions (out, state);
+  print_reductions (out, state);
   print_gotos (out, state);
 }
 

diff --git a/src/state.c b/src/state.c
index ed4a5082beb45cc72acf253f506ebfef6180373f..a1e83f383d1ad603dc2cc6f7bb36c6276f1d4a34 100644 (file)
--- a/src/state.c
+++ b/src/state.c
@@ -64,3 +64,19 @@ errs_dup (errs *src)
   memcpy (res->errs, src->errs, src->nerrs);
   return res;
 }
+
+/*-------------------------------------.
+| Create a new array of N reductions.  |
+`-------------------------------------*/
+
+#define REDUCTIONS_ALLOC(Nreductions)                                  \
+  (reductions *) xcalloc ((unsigned) (sizeof (reductions)              \
+                                  + (Nreductions - 1) * sizeof (short)), 1)
+
+reductions *
+reductions_new (int n)
+{
+  reductions *res = REDUCTIONS_ALLOC (n);
+  res->nreds = n;
+  return res;
+}

diff --git a/src/state.h b/src/state.h
index 14017afedec657d3f4b67b1c6bfc713c226d39c4..8cdf40400cce385f3ff7ecd9c07163bb922d7358 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -158,10 +158,7 @@ typedef struct reductions
   short rules[1];
 } reductions;
 
-#define REDUCTIONS_ALLOC(Nreductions)                                  \
-  (reductions *) xcalloc ((unsigned) (sizeof (reductions)              \
-                                  + (Nreductions - 1) * sizeof (short)), 1)
-
+reductions *reductions_new PARAMS ((int n));
 
 
 /*----------.