* src/LR0.c, src/conflicts.c, src/lalr.c, src/lalr.h, src/output.c

* src/print.c, src/print_graph.c, src/state.h: Rename state_table
as states.

diff --git a/ChangeLog b/ChangeLog
index 6583dc55f61323a81c661bc238a0983cb040a8a6..9134808555fd86567f701b555dc7265d792ce63c 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2001-12-29  Akim Demaille  <akim@epita.fr>
+
+       * src/LR0.c, src/conflicts.c, src/lalr.c, src/lalr.h, src/output.c
+       * src/print.c, src/print_graph.c, src/state.h: Rename state_table
+       as states.
+
+       
 2001-12-29  Akim Demaille  <akim@epita.fr>
 
        * src/lalr.c (build_relations): Rename `states' as `states1'.

diff --git a/src/LR0.c b/src/LR0.c
index 2b78dd03c76c53a6242862283d7e10294614a1a9..3f06fedff43954323552cf510b349f92b72a515b 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -365,14 +365,14 @@ save_reductions (void)
 
 \f
 /*--------------------.
-| Build STATE_TABLE.  |
+| Build STATES.  |
 `--------------------*/
 
 static void
-set_state_table (void)
+set_states (void)
 {
   state_t *sp;
-  state_table = XCALLOC (state_t *, nstates);
+  states = XCALLOC (state_t *, nstates);
 
   for (sp = first_state; sp; sp = sp->next)
     {
@@ -386,7 +386,7 @@ set_state_table (void)
       if (!sp->reductions)
        sp->reductions = reductions_new (0);
 
-      state_table[sp->number] = sp;
+      states[sp->number] = sp;
     }
 }
 
@@ -432,6 +432,6 @@ generate_states (void)
   free_closure ();
   free_storage ();
 
-  /* Set up STATE_TABLE. */
-  set_state_table ();
+  /* Set up STATES. */
+  set_states ();
 }

diff --git a/src/conflicts.c b/src/conflicts.c
index 3a979410a2b9f377649e0fdeec1ff93c6ec6b81f..746fcb50cd6f3fc70e6075e5ef88aed1dc124aa4 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -204,7 +204,7 @@ solve_conflicts (void)
   lookaheadset = XCALLOC (unsigned, tokensetsize);
 
   for (i = 0; i < nstates; i++)
-    set_conflicts (state_table[i]);
+    set_conflicts (states[i]);
 }
 
 
@@ -327,8 +327,8 @@ conflicts_output (FILE *out)
     if (conflicts[i])
       {
        fprintf (out, _("State %d contains "), i);
-       fputs (conflict_report (count_sr_conflicts (state_table[i]),
-                               count_rr_conflicts (state_table[i])), out);
+       fputs (conflict_report (count_sr_conflicts (states[i]),
+                               count_rr_conflicts (states[i])), out);
        printed_sth = TRUE;
       }
   if (printed_sth)
@@ -357,8 +357,8 @@ conflicts_print (void)
   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {
-       src_total += count_sr_conflicts (state_table[i]);
-       rrc_total += count_rr_conflicts (state_table[i]);
+       src_total += count_sr_conflicts (states[i]);
+       rrc_total += count_rr_conflicts (states[i]);
       }
 
   src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);

diff --git a/src/lalr.c b/src/lalr.c
index f0b0d3bea1599f9a5a942c14cafc675e89fbb386..c16c6f52dafaea945a222c3f6103f32c6c312cf2 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -36,7 +36,7 @@
 #include "getargs.h"
 
 /* All the decorated states, indexed by the state number.  */
-state_t **state_table = NULL;
+state_t **states = NULL;
 
 int tokensetsize;
 short *LAruleno;
@@ -150,9 +150,9 @@ initialize_LA (void)
 
   np = LAruleno;
   for (i = 0; i < nstates; i++)
-    if (!state_table[i]->consistent)
-      for (j = 0; j < state_table[i]->reductions->nreds; j++)
-       *np++ = state_table[i]->reductions->rules[j];
+    if (!states[i]->consistent)
+      for (j = 0; j < states[i]->reductions->nreds; j++)
+       *np++ = states[i]->reductions->rules[j];
 }
 
 
@@ -168,7 +168,7 @@ set_goto_map (void)
   ngotos = 0;
   for (state = 0; state < nstates; ++state)
     {
-      shifts *sp = state_table[state]->shifts;
+      shifts *sp = states[state]->shifts;
       for (i = sp->nshifts - 1; i >= 0 && SHIFT_IS_GOTO (sp, i); --i)
        {
          if (ngotos == MAXSHORT)
@@ -199,7 +199,7 @@ set_goto_map (void)
 
   for (state = 0; state < nstates; ++state)
     {
-      shifts *sp = state_table[state]->shifts;
+      shifts *sp = states[state]->shifts;
       for (i = sp->nshifts - 1; i >= 0 && SHIFT_IS_GOTO (sp, i); --i)
        {
          int k = temp_map[SHIFT_SYMBOL (sp, i)]++;
@@ -260,7 +260,7 @@ initialize_F (void)
   for (i = 0; i < ngotos; i++)
     {
       int stateno = to_state[i];
-      shifts *sp = state_table[stateno]->shifts;
+      shifts *sp = states[stateno]->shifts;
 
       int j;
       for (j = 0; j < sp->nshifts && SHIFT_IS_SHIFT (sp, j); j++)
@@ -409,7 +409,7 @@ build_relations (void)
   for (i = 0; i < ngotos; i++)
     {
       int nedges = 0;
-      int symbol1 = state_table[to_state[i]]->accessing_symbol;
+      int symbol1 = states[to_state[i]]->accessing_symbol;
       short *rulep;
 
       for (rulep = derives[symbol1]; *rulep > 0; rulep++)
@@ -417,7 +417,7 @@ build_relations (void)
          int done;
          int length = 1;
          short *rp;
-         state_t *state = state_table[from_state[i]];
+         state_t *state = states[from_state[i]];
          states1[0] = state->number;
 
          for (rp = &ritem[rules[*rulep].rhs]; *rp >= 0; rp++)
@@ -426,7 +426,7 @@ build_relations (void)
              int j;
              for (j = 0; j < sp->nshifts; j++)
                {
-                 state = state_table[sp->shifts[j]];
+                 state = states[sp->shifts[j]];
                  if (state->accessing_symbol == *rp)
                    break;
                }
@@ -522,8 +522,8 @@ initialize_lookaheads (void)
     {
       int k;
       int nlookaheads = 0;
-      reductions *rp = state_table[i]->reductions;
-      shifts *sp = state_table[i]->shifts;
+      reductions *rp = states[i]->reductions;
+      shifts *sp = states[i]->shifts;
 
       /* We need a lookahead either to distinguish different
         reductions (i.e., there are two or more), or to distinguish a
@@ -533,17 +533,17 @@ initialize_lookaheads (void)
          || (rp->nreds == 1 && sp->nshifts && SHIFT_IS_SHIFT (sp, 0)))
        nlookaheads += rp->nreds;
       else
-       state_table[i]->consistent = 1;
+       states[i]->consistent = 1;
 
       for (k = 0; k < sp->nshifts; k++)
        if (SHIFT_IS_ERROR (sp, k))
          {
-           state_table[i]->consistent = 0;
+           states[i]->consistent = 0;
            break;
          }
 
-      state_table[i]->nlookaheads = nlookaheads;
-      state_table[i]->lookaheadsp = nLA;
+      states[i]->nlookaheads = nlookaheads;
+      states[i]->lookaheadsp = nLA;
       nLA += nlookaheads;
     }
 }
@@ -561,14 +561,14 @@ lookaheads_print (FILE *out)
   for (i = 0; i < nstates; ++i)
     {
       fprintf (out, "State %d: %d lookaheads\n",
-              i, state_table[i]->nlookaheads);
+              i, states[i]->nlookaheads);
 
-      for (j = 0; j < state_table[i]->nlookaheads; ++j)
+      for (j = 0; j < states[i]->nlookaheads; ++j)
        for (k = 0; k < ntokens; ++k)
-         if (BITISSET (LA (state_table[i]->lookaheadsp + j), j))
+         if (BITISSET (LA (states[i]->lookaheadsp + j), j))
            fprintf (out, "   on %d (%s) -> rule %d\n",
                     k, symbols[k]->tag,
-                    -LAruleno[state_table[i]->lookaheadsp + j] - 1);
+                    -LAruleno[states[i]->lookaheadsp + j] - 1);
     }
   fprintf (out, "Lookaheads: END\n");
 }

diff --git a/src/lalr.h b/src/lalr.h
index 31cf806983a072b90d78f5f0abd07a67fab371b1..77a5d9df7d4a461c1fb1e824cd3ebb8f2d84490e 100644 (file)
--- a/src/lalr.h
+++ b/src/lalr.h
@@ -70,7 +70,7 @@ extern unsigned *LA;
 
 
 /* All the states, indexed by the state number.  */
-extern state_t **state_table;
+extern state_t **states;
 
 extern int tokensetsize;
 

diff --git a/src/output.c b/src/output.c
index 3a8bc9949f4a32f22b7a967f627c18cb30d0a214..45af9b7e614c34b666fccf2362e21dcd725a9591 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -222,7 +222,7 @@ output_stos (void)
   int i;
   short *values = (short *) alloca (sizeof (short) * nstates);
   for (i = 0; i < nstates; ++i)
-    values[i] = state_table[i]->accessing_symbol;
+    values[i] = states[i]->accessing_symbol;
   output_table_data (&format_obstack, values,
                     0, 1, nstates);
   muscle_insert ("stos", obstack_finish (&format_obstack));
@@ -362,7 +362,7 @@ action_row (state_t *state)
       if (!shift_state)
        continue;
 
-      symbol = state_table[shift_state]->accessing_symbol;
+      symbol = states[shift_state]->accessing_symbol;
 
       if (ISVAR (symbol))
        break;
@@ -486,7 +486,7 @@ token_actions (void)
   actrow = XCALLOC (short, ntokens);
   for (i = 0; i < nstates; ++i)
     {
-      yydefact[i] = action_row (state_table[i]);
+      yydefact[i] = action_row (states[i]);
       save_row (i);
     }
 
@@ -904,12 +904,12 @@ output_actions (void)
 
   for (i = 0; i < nstates; ++i)
     {
-      free (state_table[i]->shifts);
-      XFREE (state_table[i]->reductions);
-      free (state_table[i]->errs);
-      free (state_table[i]);
+      free (states[i]->shifts);
+      XFREE (states[i]->reductions);
+      free (states[i]->errs);
+      free (states[i]);
     }
-  XFREE (state_table);
+  XFREE (states);
 }
 
 \f

diff --git a/src/print.c b/src/print.c
index 5a417d320f395dca180945f6806a974f3bf97101..72b4cd0a4f89b30943853946c46c5892bb11c2be 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -122,7 +122,7 @@ print_shifts (FILE *out, state_t *state)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       {
        int state1 = shiftp->shifts[i];
-       int symbol = state_table[state1]->accessing_symbol;
+       int symbol = states[state1]->accessing_symbol;
        fprintf (out,
                 _("    %-4s\tshift, and go to state %d\n"),
                 escape (symbols[symbol]->tag), state1);
@@ -164,7 +164,7 @@ print_gotos (FILE *out, state_t *state)
        if (!SHIFT_IS_DISABLED (shiftp, i))
          {
            int state1 = shiftp->shifts[i];
-           int symbol = state_table[state1]->accessing_symbol;
+           int symbol = states[state1]->accessing_symbol;
            fprintf (out, _("    %-4s\tgo to state %d\n"),
                     escape (symbols[symbol]->tag), state1);
          }
@@ -501,7 +501,7 @@ print_results (void)
   shiftset = XCALLOC (unsigned, tokensetsize);
   lookaheadset = XCALLOC (unsigned, tokensetsize);
   for (i = 0; i < nstates; i++)
-    print_state (out, state_table[i]);
+    print_state (out, states[i]);
   free (shiftset);
   free (lookaheadset);
   if (trace_flag)

diff --git a/src/print_graph.c b/src/print_graph.c
index d32e5520351e8b9f732674b99d1da258fb848c1f..f9bec77d4c81638a110f0e0b2527d27687c1f19b 100644 (file)
--- a/src/print_graph.c
+++ b/src/print_graph.c
@@ -114,7 +114,7 @@ print_actions (state_t *state, const char *node_name)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       {
        int state1 = shiftp->shifts[i];
-       int symbol = state_table[state1]->accessing_symbol;
+       int symbol = states[state1]->accessing_symbol;
 
        new_edge (&edge);
 
@@ -202,7 +202,7 @@ print_graph (void)
   /* Output nodes and edges. */
   new_closure (nritems);
   for (i = 0; i < nstates; i++)
-    print_state (state_table[i]);
+    print_state (states[i]);
   free_closure ();
 
   /* Close graph. */

diff --git a/src/state.h b/src/state.h
index 8cdf40400cce385f3ff7ecd9c07163bb922d7358..c2d66f3fa5217e2e83d51e862fd1fb42249e7a8c 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -107,7 +107,7 @@ shifts *shifts_new PARAMS ((int n));
    case of gotos.  */
 
 #define SHIFT_SYMBOL(Shifts, Shift) \
-  (state_table[Shifts->shifts[Shift]]->accessing_symbol)
+  (states[Shifts->shifts[Shift]]->accessing_symbol)
 
 /* Is the SHIFTS->shifts[Shift] a real shift? (as opposed to gotos.) */