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

* src/LR0.c (set_state_table): Let all the states have an errs,
even if reduced to 0.
* src/print.c (print_errs, print_reductions): Adjust.
* src/output.c (output_actions, action_row): Adjust.
* src/conflicts.c (resolve_sr_conflict): Adjust.

diff --git a/ChangeLog b/ChangeLog
index 6966cac37a09908c8d4a352d39f84a57c2d2e97b..c600ff3aa2efb4fc484d5615922535ccc841668c 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2001-12-27  Akim Demaille  <akim@epita.fr>
+
+       * src/state.h, src/state.c (errs_new, errs_dup): New.
+       * src/LR0.c (set_state_table): Let all the states have an errs,
+       even if reduced to 0.
+       * src/print.c (print_errs, print_reductions): Adjust.
+       * src/output.c (output_actions, action_row): Adjust.
+       * src/conflicts.c (resolve_sr_conflict): Adjust.
+
+       
 2001-12-27  Akim Demaille  <akim@epita.fr>
 
        * src/lalr.c (set_goto_map, initialize_F): Use SHIFT_SYMBOL.

diff --git a/src/LR0.c b/src/LR0.c
index 148e2bc0adc4c083d51a43dd9432b9317aaf8623..4f771d21088eff52ba72dcafd84dac4a0145c28a 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -541,22 +541,20 @@ save_reductions (void)
 static void
 set_state_table (void)
 {
+  state_t *sp;
   state_table = XCALLOC (state_t *, nstates);
 
-  {
-    state_t *sp;
-    for (sp = first_state; sp; sp = sp->next)
+  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.  */
+      if (!sp->shifts)
+       sp->shifts = shifts_new (0);
+      if (!sp->errs)
+       sp->errs = errs_new (0);
+
       state_table[sp->number] = sp;
-  }
-
-  /* Pessimization, but simplification of the code: make sure all the
-     states have a shifts, even if reduced to 0 shifts.  */
-  {
-    int i;
-    for (i = 0; i < nstates; i++)
-      if (!state_table[i]->shifts)
-       state_table[i]->shifts = shifts_new (0);
-  }
+    }
 }
 
 /*-------------------------------------------------------------------.

diff --git a/src/conflicts.c b/src/conflicts.c
index 01fff4f12cc0632b67d6c1255a59e0a8919d4f9f..2f9b4c247892bff531b47a9e4f7adab1487774da 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -93,8 +93,8 @@ resolve_sr_conflict (state_t *state, int lookahead)
   int i;
   /* find the rule to reduce by to get precedence of reduction  */
   int redprec = rule_table[LAruleno[lookahead]].prec;
-  errs *errp = ERRS_ALLOC (ntokens + 1);
-  short *errtokens = errp->errs;
+  errs *errp = errs_new (ntokens + 1);
+  errp->nerrs = 0;
 
   for (i = 0; i < ntokens; i++)
     if (BITISSET (LA (lookahead), i)
@@ -137,17 +137,14 @@ resolve_sr_conflict (state_t *state, int lookahead)
              flush_shift (state, i);
              flush_reduce (lookahead, i);
              /* Record an explicit error for this token.  */
-             *errtokens++ = i;
+             errp->errs[errp->nerrs++] = i;
              break;
            }
       }
 
-  errp->nerrs = errtokens - errp->errs;
   /* Some tokens have been explicitly made errors.  Allocate a
      permanent errs structure for this state, to record them.  */
-  i = (char *) errtokens - (char *) errp;
-  state->errs = ERRS_ALLOC (i + 1);
-  memcpy (state->errs, errp, i);
+  state->errs = errs_dup (errp);
   free (errp);
 }
 

diff --git a/src/output.c b/src/output.c
index dfbfbb501369a7774d4017425615f64b23bfb0aa..c424716cc873dd2e2dfbaa503aa97fb10a001271 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -375,12 +375,11 @@ action_row (state_t *state)
 
   /* See which tokens are an explicit error in this state (due to
      %nonassoc).  For them, record MINSHORT as the action.  */
-  if (errp)
-    for (i = 0; i < errp->nerrs; i++)
-      {
-       int symbol = errp->errs[i];
-       actrow[symbol] = MINSHORT;
-      }
+  for (i = 0; i < errp->nerrs; i++)
+    {
+      int symbol = errp->errs[i];
+      actrow[symbol] = MINSHORT;
+    }
 
   /* Now find the most common reduction and make it the default action
      for this state.  */
@@ -903,9 +902,9 @@ output_actions (void)
 
   for (i = 0; i < nstates; ++i)
     {
-      XFREE (state_table[i]->shifts);
+      free (state_table[i]->shifts);
       XFREE (state_table[i]->reductions);
-      XFREE (state_table[i]->errs);
+      free (state_table[i]->errs);
       free (state_table[i]);
     }
   XFREE (state_table);

diff --git a/src/print.c b/src/print.c
index e1f53a1e12dce3521eeb04cb98eb67994449a785..b9c518f7dd1bd6f3ca35c46ba7821eab712de174 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -124,16 +124,13 @@ print_errs (FILE *out, state_t *state)
   errs *errp = state->errs;
   int i;
 
-  if (!errp)
-    return;
-
   for (i = 0; i < errp->nerrs; ++i)
     if (errp->errs[i])
       fprintf (out, _("    %-4s\terror (nonassociative)\n"),
               tags[errp->errs[i]]);
 
   if (i > 0)
-       fputc ('\n', out);
+    fputc ('\n', out);
 }
 
 
@@ -192,10 +189,9 @@ print_reductions (FILE *out, state_t *state)
        SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
       }
 
-  if (errp)
-    for (i = 0; i < errp->nerrs; i++)
-      if (errp->errs[i])
-       SETBIT (shiftset, errp->errs[i]);
+  for (i = 0; i < errp->nerrs; i++)
+    if (errp->errs[i])
+      SETBIT (shiftset, errp->errs[i]);
 
   if (state->nlookaheads == 1 && !nodefault)
     {

diff --git a/src/state.c b/src/state.c
index 7c3b69210e463e3166538a97fd01b3ac7c1358bb..ed4a5082beb45cc72acf253f506ebfef6180373f 100644 (file)
--- a/src/state.c
+++ b/src/state.c
@@ -26,6 +26,10 @@
 | Create a new array of N shitfs.  |
 `---------------------------------*/
 
+#define SHIFTS_ALLOC(Nshifts)                                          \
+  (shifts *) xcalloc ((unsigned) (sizeof (shifts)                      \
+                                  + (Nshifts - 1) * sizeof (short)), 1)
+
 shifts *
 shifts_new (int n)
 {
@@ -33,3 +37,30 @@ shifts_new (int n)
   res->nshifts = n;
   return res;
 }
+
+
+/*-------------------------------.
+| Create a new array of N errs.  |
+`-------------------------------*/
+
+#define ERRS_ALLOC(Nerrs)                                              \
+  (errs *) xcalloc ((unsigned) (sizeof (errs)                          \
+                                  + (Nerrs - 1) * sizeof (short)), 1)
+
+
+errs *
+errs_new (int n)
+{
+  errs *res = ERRS_ALLOC (n);
+  res->nerrs = n;
+  return res;
+}
+
+
+errs *
+errs_dup (errs *src)
+{
+  errs *res = errs_new (src->nerrs);
+  memcpy (res->errs, src->errs, src->nerrs);
+  return res;
+}

diff --git a/src/state.h b/src/state.h
index a31af20bcd675750678bca2a7fe6dd4bb1323771..14017afedec657d3f4b67b1c6bfc713c226d39c4 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -99,12 +99,7 @@ typedef struct shifts
   short shifts[1];
 } shifts;
 
-
-#define SHIFTS_ALLOC(Nshifts)                                          \
-  (shifts *) xcalloc ((unsigned) (sizeof (shifts)                      \
-                                  + (Nshifts - 1) * sizeof (short)), 1)
-
-shifts * shifts_new PARAMS ((int n));
+shifts *shifts_new PARAMS ((int n));
 
 
 /* What is the symbol which is shifted by SHIFTS->shifts[Shift]?  Can
@@ -149,9 +144,8 @@ typedef struct errs
   short errs[1];
 } errs;
 
-#define ERRS_ALLOC(Nerrs)                                              \
-  (errs *) xcalloc ((unsigned) (sizeof (errs)                          \
-                                  + (Nerrs - 1) * sizeof (short)), 1)
+errs *errs_new PARAMS ((int n));
+errs *errs_dup PARAMS ((errs *src));
 
 
 /*-------------.