03-fyi-state-t.patch

[Akim Demaille]

Index: ChangeLog
from  Akim Demaille  <address@hidden>
        
        * src/conflicts.c (log_resolution, flush_shift)
        (resolve_sr_conflict, set_conflicts, solve_conflicts)
        (count_sr_conflicts, count_rr_conflicts, conflicts_output)
        (conflicts_print, print_reductions): Use a state_t instead of an
        integer when referring to a state.
        As much as possible, depend upon nlookaheads, instead of the
        `lookaheadsp' member of the following state (since lookaheads of
        successive states are successive, the difference between state n + 1
        and n served as the number of lookaheads for state n).
        * src/lalr.c (add_lookback_edge): Likewise.
        * src/print.c (print_core, print_actions, print_state)
        (print_results): Likewise.
        * src/print_graph.c (print_core, print_actions, print_state)
        (print_graph): Likewise.
        * src/conflicts.h: Adjust.
        
Index: src/conflicts.c
--- src/conflicts.c Sat, 22 Dec 2001 12:52:24 +0100 akim
+++ src/conflicts.c Wed, 26 Dec 2001 16:45:27 +0100 akim
@@ -38,13 +38,13 @@
 
 
 static inline void
-log_resolution (int state, int LAno, int token, char *resolution)
+log_resolution (state_t *state, int LAno, int token, char *resolution)
 {
   if (verbose_flag)
     obstack_fgrow4 (&output_obstack,
                    _("\
 Conflict in state %d between rule %d and token %s resolved as %s.\n"),
-                   state, LAruleno[LAno], tags[token], resolution);
+                   state->number, LAruleno[LAno], tags[token], resolution);
 }
 
 
@@ -55,9 +55,9 @@
 `------------------------------------------------------------------*/
 
 static void
-flush_shift (int state, int token)
+flush_shift (state_t *state, int token)
 {
-  shifts *shiftp = state_table[state]->shifts;
+  shifts *shiftp = state->shifts;
   int i;
 
   RESETBIT (lookaheadset, token);
@@ -88,7 +88,7 @@
 `------------------------------------------------------------------*/
 
 static void
-resolve_sr_conflict (int state, int lookahead)
+resolve_sr_conflict (state_t *state, int lookahead)
 {
   int i;
   /* find the rule to reduce by to get precedence of reduction  */
@@ -146,25 +146,25 @@
   /* Some tokens have been explicitly made errors.  Allocate a
      permanent errs structure for this state, to record them.  */
   i = (char *) errtokens - (char *) errp;
-  state_table[state]->errs = ERRS_ALLOC (i + 1);
-  memcpy (state_table[state]->errs, errp, i);
+  state->errs = ERRS_ALLOC (i + 1);
+  memcpy (state->errs, errp, i);
   free (errp);
 }
 
 
 static void
-set_conflicts (int state)
+set_conflicts (state_t *state)
 {
   int i, j;
   shifts *shiftp;
 
-  if (state_table[state]->consistent)
+  if (state->consistent)
     return;
 
   for (i = 0; i < tokensetsize; i++)
     lookaheadset[i] = 0;
 
-  shiftp = state_table[state]->shifts;
+  shiftp = state->shifts;
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));
@@ -172,30 +172,26 @@
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence */
-  for (i = state_table[state]->lookaheadsp;
-       i < state_table[state + 1]->lookaheadsp;
-       ++i)
-    if (rule_table[LAruleno[i]].prec)
+  for (i = 0; i < state->nlookaheads; ++i)
+    if (rule_table[LAruleno[state->lookaheadsp + i]].prec)
       for (j = 0; j < tokensetsize; ++j)
-       if (LA (i)[j] & lookaheadset[j])
+       if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
          {
-           resolve_sr_conflict (state, i);
+           resolve_sr_conflict (state, state->lookaheadsp + i);
            break;
          }
 
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */
-  for (i = state_table[state]->lookaheadsp;
-       i < state_table[state + 1]->lookaheadsp;
-       ++i)
+  for (i = 0; i < state->nlookaheads; ++i)
     {
       for (j = 0; j < tokensetsize; ++j)
-       if (LA (i)[j] & lookaheadset[j])
-         conflicts[state] = 1;
+       if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
+         conflicts[state->number] = 1;
 
       for (j = 0; j < tokensetsize; ++j)
-       lookaheadset[j] |= LA (i)[j];
+       lookaheadset[j] |= LA (state->lookaheadsp + i)[j];
     }
 }
 
@@ -209,7 +205,7 @@
   lookaheadset = XCALLOC (unsigned, tokensetsize);
 
   for (i = 0; i < nstates; i++)
-    set_conflicts (i);
+    set_conflicts (state_table[i]);
 }
 
 
@@ -218,11 +214,11 @@
 `---------------------------------------------*/
 
 static int
-count_sr_conflicts (int state)
+count_sr_conflicts (state_t *state)
 {
   int i, k;
   int src_count = 0;
-  shifts *shiftp = state_table[state]->shifts;
+  shifts *shiftp = state->shifts;
 
   if (!shiftp)
     return 0;
@@ -237,11 +233,9 @@
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 
-  for (i = state_table[state]->lookaheadsp;
-       i < state_table[state + 1]->lookaheadsp;
-       ++i)
+  for (i = 0; i < state->nlookaheads; ++i)
     for (k = 0; k < tokensetsize; ++k)
-      lookaheadset[k] |= LA (i)[k];
+      lookaheadset[k] |= LA (state->lookaheadsp + i)[k];
 
   for (k = 0; k < tokensetsize; ++k)
     lookaheadset[k] &= shiftset[k];
@@ -259,23 +253,20 @@
 `----------------------------------------------*/
 
 static int
-count_rr_conflicts (int state)
+count_rr_conflicts (state_t *state)
 {
   int i;
   int rrc_count = 0;
 
-  int m = state_table[state]->lookaheadsp;
-  int n = state_table[state + 1]->lookaheadsp;
-
-  if (n - m < 2)
+  if (state->nlookaheads < 2)
     return 0;
 
   for (i = 0; i < ntokens; i++)
     {
       int count = 0;
       int j;
-      for (j = m; j < n; j++)
-       if (BITISSET (LA (m), j))
+      for (j = 0; j < state->nlookaheads; ++j)
+       if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j))
          count++;
 
       if (count >= 2)
@@ -337,8 +328,8 @@
     if (conflicts[i])
       {
        fprintf (out, _("State %d contains "), i);
-       fputs (conflict_report (count_sr_conflicts (i),
-                               count_rr_conflicts (i)), out);
+       fputs (conflict_report (count_sr_conflicts (state_table[i]),
+                               count_rr_conflicts (state_table[i])), out);
        printed_sth = TRUE;
       }
   if (printed_sth)
@@ -367,8 +358,8 @@
   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {
-       src_total += count_sr_conflicts (i);
-       rrc_total += count_rr_conflicts (i);
+       src_total += count_sr_conflicts (state_table[i]);
+       rrc_total += count_rr_conflicts (state_table[i]);
       }
 
   src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);
@@ -410,13 +401,11 @@
 
 
 void
-print_reductions (FILE *out, int state)
+print_reductions (FILE *out, state_t *state)
 {
   int i;
-  int m = state_table[state]->lookaheadsp;
-  int n = state_table[state + 1]->lookaheadsp;
-  shifts *shiftp = state_table[state]->shifts;
-  errs *errp = state_table[state]->errs;
+  shifts *shiftp = state->shifts;
+  errs *errp = state->errs;
   int nodefault = 0;
 
   for (i = 0; i < tokensetsize; i++)
@@ -437,13 +426,13 @@
       if (errp->errs[i])
        SETBIT (shiftset, errp->errs[i]);
 
-  if (n - m == 1 && !nodefault)
+  if (state->nlookaheads == 1 && !nodefault)
     {
       int k;
-      int default_rule = LAruleno[m];
+      int default_rule = LAruleno[state->lookaheadsp];
 
       for (k = 0; k < tokensetsize; ++k)
-       lookaheadset[k] = LA (m)[k] & shiftset[k];
+       lookaheadset[k] = LA (state->lookaheadsp)[k] & shiftset[k];
 
       for (i = 0; i < ntokens; i++)
        if (BITISSET (lookaheadset, i))
@@ -454,20 +443,20 @@
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
               default_rule, tags[rule_table[default_rule].lhs]);
     }
-  else if (n - m >= 1)
+  else if (state->nlookaheads >= 1)
     {
       int cmax = 0;
       int default_LA = -1;
       int default_rule = 0;
 
       if (!nodefault)
-       for (i = m; i < n; i++)
+       for (i = 0; i < state->nlookaheads; ++i)
          {
            int count = 0;
            int j, k;
 
            for (k = 0; k < tokensetsize; ++k)
-             lookaheadset[k] = LA (i)[k] & ~shiftset[k];
+             lookaheadset[k] = LA (state->lookaheadsp + i)[k] & ~shiftset[k];
 
            for (j = 0; j < ntokens; j++)
              if (BITISSET (lookaheadset, j))
@@ -476,8 +465,8 @@
            if (count > cmax)
              {
                cmax = count;
-               default_LA = i;
-               default_rule = LAruleno[i];
+               default_LA = state->lookaheadsp + i;
+               default_rule = LAruleno[state->lookaheadsp + i];
              }
 
            for (k = 0; k < tokensetsize; ++k)
@@ -497,18 +486,18 @@
          int defaulted = 0;
          int count = BITISSET (shiftset, i);
 
-         for (j = m; j < n; j++)
+         for (j = 0; j < state->nlookaheads; ++j)
            {
-             if (BITISSET (LA (j), i))
+             if (BITISSET (LA (state->lookaheadsp + j), i))
                {
                  if (count == 0)
                    {
-                     if (j != default_LA)
+                     if (state->lookaheadsp + j != default_LA)
                        fprintf (out,
                                 _("    %-4s\treduce using rule %d (%s)\n"),
                                 tags[i],
-                                LAruleno[j],
-                                tags[rule_table[LAruleno[j]].lhs]);
+                                LAruleno[state->lookaheadsp + j],
+                                tags[rule_table[LAruleno[state->lookaheadsp + 
j]].lhs]);
                      else
                        defaulted = 1;
 
@@ -526,8 +515,8 @@
                      fprintf (out,
                               _("    %-4s\t[reduce using rule %d (%s)]\n"),
                               tags[i],
-                              LAruleno[j],
-                              tags[rule_table[LAruleno[j]].lhs]);
+                              LAruleno[state->lookaheadsp + j],
+                              tags[rule_table[LAruleno[state->lookaheadsp + 
j]].lhs]);
                    }
                }
            }
Index: src/conflicts.h
--- src/conflicts.h Tue, 04 Dec 2001 20:15:38 +0100 akim
+++ src/conflicts.h Wed, 26 Dec 2001 16:31:03 +0100 akim
@@ -25,7 +25,7 @@
 void solve_conflicts PARAMS ((void));
 void conflicts_print PARAMS ((void));
 void conflicts_output PARAMS ((FILE *out));
-void print_reductions PARAMS ((FILE*out, int state));
+void print_reductions PARAMS ((FILE*out, state_t *state));
 void free_conflicts PARAMS ((void));
 
 /* Were there conflicts? */
Index: src/lalr.c
--- src/lalr.c Sat, 22 Dec 2001 14:56:19 +0100 akim
+++ src/lalr.c Wed, 26 Dec 2001 16:12:23 +0100 akim
@@ -310,27 +310,18 @@
 add_lookback_edge (int stateno, int ruleno, int gotono)
 {
   int i;
-  int k;
-  int found;
   shorts *sp;
 
-  i = state_table[stateno]->lookaheadsp;
-  k = state_table[stateno + 1]->lookaheadsp;
-  found = 0;
-  while (!found && i < k)
-    {
-      if (LAruleno[i] == ruleno)
-       found = 1;
-      else
-       i++;
-    }
+  for (i = 0; i < state_table[stateno]->nlookaheads; ++i)
+    if (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno)
+      break;
 
-  assert (found);
+  assert (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno);
 
   sp = XCALLOC (shorts, 1);
-  sp->next = lookback[i];
+  sp->next = lookback[state_table[stateno]->lookaheadsp + i];
   sp->value = gotono;
-  lookback[i] = sp;
+  lookback[state_table[stateno]->lookaheadsp + i] = sp;
 }
 
 
Index: src/print.c
--- src/print.c Sun, 16 Dec 2001 11:51:05 +0100 akim
+++ src/print.c Wed, 26 Dec 2001 16:33:24 +0100 akim
@@ -46,11 +46,11 @@
 `--------------------------------*/
 
 static void
-print_core (FILE *out, int state)
+print_core (FILE *out, state_t *state)
 {
   int i;
-  short *sitems = state_table[state]->items;
-  int snitems   = state_table[state]->nitems;
+  short *sitems = state->items;
+  int snitems   = state->nitems;
 
   /* New experimental feature: if TRACE_FLAGS output all the items of
      a state, not only its kernel.  */
@@ -94,17 +94,17 @@
 }
 
 static void
-print_actions (FILE *out, int state)
+print_actions (FILE *out, state_t *state)
 {
   int i;
 
-  shifts   *shiftp = state_table[state]->shifts;
-  reductions *redp = state_table[state]->reductions;
-  errs       *errp = state_table[state]->errs;
+  shifts   *shiftp = state->shifts;
+  reductions *redp = state->reductions;
+  errs       *errp = state->errs;
 
   if (!shiftp->nshifts && !redp)
     {
-      if (final_state == state)
+      if (final_state == state->number)
        fprintf (out, _("    $default\taccept\n"));
       else
        fprintf (out, _("    NO ACTIONS\n"));
@@ -140,7 +140,7 @@
        fputc ('\n', out);
     }
 
-  if (state_table[state]->consistent && redp)
+  if (state->consistent && redp)
     {
       int rule = redp->rules[0];
       int symbol = rule_table[rule].lhs;
@@ -168,9 +168,9 @@
 }
 
 static void
-print_state (FILE *out, int state)
+print_state (FILE *out, state_t *state)
 {
-  fprintf (out, _("state %d"), state);
+  fprintf (out, _("state %d"), state->number);
   fputs ("\n\n", out);
   print_core (out, state);
   print_actions (out, state);
@@ -331,7 +331,7 @@
   if (trace_flag)
     new_closure (nitems);
   for (i = 0; i < nstates; i++)
-    print_state (out, i);
+    print_state (out, state_table[i]);
   if (trace_flag)
     free_closure ();
 
Index: src/print_graph.c
--- src/print_graph.c Sun, 16 Dec 2001 11:51:05 +0100 akim
+++ src/print_graph.c Wed, 26 Dec 2001 16:34:37 +0100 akim
@@ -38,18 +38,18 @@
 
 /* This part will construct the label of nodes. */
 static void
-print_core (int state, struct obstack *node_obstack)
+print_core (state_t *state, struct obstack *node_obstack)
 {
   int i;
-  short *sitems = state_table[state]->items;
-  int snitems   = state_table[state]->nitems;
+  short *sitems = state->items;
+  int snitems   = state->nitems;
 
   /* Output all the items of a state, not only its kernel.  */
   closure (sitems, snitems);
   sitems = itemset;
   snitems = nitemset;
 
-  obstack_fgrow1 (node_obstack, "%2d: ", state);
+  obstack_fgrow1 (node_obstack, "%2d: ", state->number);
   for (i = 0; i < snitems; i++)
     {
       short *sp;
@@ -65,7 +65,7 @@
 
       if (i)
        obstack_sgrow (node_obstack, "\n    ");
-      obstack_fgrow1 (node_obstack, " %s  ->  ",
+      obstack_fgrow1 (node_obstack, " %s -> ",
                      tags[rule_table[rule].lhs]);
 
       for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
@@ -85,14 +85,14 @@
 `---------------------------------------------------------------*/
 
 static void
-print_actions (int state, const char *node_name)
+print_actions (state_t *state, const char *node_name)
 {
   int i;
 
-  shifts   *shiftp = state_table[state]->shifts;
-  reductions *redp = state_table[state]->reductions;
+  shifts   *shiftp = state->shifts;
+  reductions *redp = state->reductions;
 #if 0
-  errs       *errp = state_table[state]->errs;
+  errs       *errp = state->errs;
 #endif
 
   static char buff[10];
@@ -117,7 +117,7 @@
 
        new_edge (&edge);
 
-       if (state > state1)
+       if (state->number > state1)
          edge.type = back_edge;
        open_edge (&edge, fgraph);
        /* The edge source is the current node.  */
@@ -155,7 +155,7 @@
        obstack_1grow (node_obstack, '\n');
     }
 
-  if (state_table[state]->consistent && redp)
+  if (state->consistent && redp)
     {
       rule = redp->rules[0];
       symbol = rule_table[rule].lhs;
@@ -176,7 +176,7 @@
 `-------------------------------------------------------------*/
 
 static void
-print_state (int state)
+print_state (state_t *state)
 {
   static char name[10];
   struct obstack node_obstack;
@@ -185,7 +185,7 @@
   /* The labels of the nodes are their the items.  */
   obstack_init (&node_obstack);
   new_node (&node);
-  sprintf (name, "%d", state);
+  sprintf (name, "%d", state->number);
   node.title = name;
   print_core (state, &node_obstack);
   obstack_1grow (&node_obstack, '\0');
@@ -235,7 +235,7 @@
   /* Output nodes and edges. */
   new_closure (nitems);
   for (i = 0; i < nstates; i++)
-    print_state (i);
+    print_state (state_table[i]);
   free_closure ();
 
   /* Close graph. */