* src/lalr.h (lookaheads): Removed array, which contents is now

member of...
(state_t): this structure.
* src/output.c, src/lalr.c, src/print_graph.c, src/conflicts.c:
Adjust.

diff --git a/ChangeLog b/ChangeLog
index 4663bec0a2389a82c431528da54e70eb992561e9..3f2dcdbb376b41c81a9409fcdbef30b6391ff82d 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2001-11-19  Akim Demaille  <akim@epita.fr>
+
+       * src/lalr.h (lookaheads): Removed array, which contents is now
+       member of...
+       (state_t): this structure.
+       * src/output.c, src/lalr.c, src/print_graph.c, src/conflicts.c:
+       Adjust.
+
 2001-11-19  Akim Demaille  <akim@epita.fr>
 
        * src/lalr.h (consistent): Removed array, which contents is now

diff --git a/src/conflicts.c b/src/conflicts.c
index 60a5edec88ea185e2396c2fab68a3f56bf60a991..77520ade1ef7446dd3cde57ccf31914216f308ba 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -210,13 +210,13 @@ set_conflicts (int state)
        }
     }
 
-  k = lookaheads[state + 1];
+  k = state_table[state + 1].lookaheads;
   fp4 = lookaheadset + tokensetsize;
 
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence */
-  for (i = lookaheads[state]; i < k; i++)
+  for (i = state_table[state].lookaheads; i < k; i++)
     if (rprec[LAruleno[i]])
       {
        fp1 = LA + i * tokensetsize;
@@ -236,7 +236,7 @@ set_conflicts (int state)
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */
-  for (i = lookaheads[state]; i < k; i++)
+  for (i = state_table[state].lookaheads; i < k; i++)
     {
       fp1 = LA + i * tokensetsize;
       fp2 = fp1;
@@ -309,10 +309,10 @@ count_sr_conflicts (int state)
       SETBIT (shiftset, symbol);
     }
 
-  k = lookaheads[state + 1];
+  k = state_table[state + 1].lookaheads;
   fp3 = lookaheadset + tokensetsize;
 
-  for (i = lookaheads[state]; i < k; i++)
+  for (i = state_table[state].lookaheads; i < k; i++)
     {
       fp1 = LA + i * tokensetsize;
       fp2 = lookaheadset;
@@ -359,8 +359,8 @@ count_rr_conflicts (int state)
 
   int rrc_count = 0;
 
-  int m = lookaheads[state];
-  int n = lookaheads[state + 1];
+  int m = state_table[state].lookaheads;
+  int n = state_table[state + 1].lookaheads;
 
   if (n - m < 2)
     return 0;
@@ -565,8 +565,8 @@ print_reductions (FILE *out, int state)
        }
     }
 
-  m = lookaheads[state];
-  n = lookaheads[state + 1];
+  m = state_table[state].lookaheads;
+  n = state_table[state + 1].lookaheads;
 
   if (n - m == 1 && !nodefault)
     {

diff --git a/src/lalr.c b/src/lalr.c
index d4795b57e41b141246b8829eb6bf597707ff5bb9..9d11c42dd3dd39ce3b6bc6475b3f4d520f11346b 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -38,7 +38,6 @@
 state_t *state_table = NULL;
 
 int tokensetsize;
-short *lookaheads;
 short *LAruleno;
 unsigned *LA;
 
@@ -145,7 +144,10 @@ digraph (short **relation)
 static void
 set_state_table (void)
 {
-  state_table = XCALLOC (state_t, nstates);
+  /* NSTATES + 1 because lookahead for the pseudo state number NSTATES
+     might be used (see conflicts.c).  It is too opaque for me to
+     provide a probably less hacky implementation. --akim */
+  state_table = XCALLOC (state_t, nstates + 1);
 
   {
     core *sp;
@@ -202,19 +204,16 @@ initialize_LA (void)
 {
   int i;
   int j;
-  int count;
+  int count = 0;
   reductions *rp;
   shifts *sp;
   short *np;
 
-  lookaheads = XCALLOC (short, nstates + 1);
-
-  count = 0;
   for (i = 0; i < nstates; i++)
     {
       int k;
 
-      lookaheads[i] = count;
+      state_table[i].lookaheads = count;
 
       rp = state_table[i].reduction_table;
       sp = state_table[i].shift_table;
@@ -235,7 +234,7 @@ initialize_LA (void)
            }
     }
 
-  lookaheads[nstates] = count;
+  state_table[nstates].lookaheads = count;
 
   if (count == 0)
     {
@@ -450,8 +449,8 @@ add_lookback_edge (int stateno, int ruleno, int gotono)
   int found;
   shorts *sp;
 
-  i = lookaheads[stateno];
-  k = lookaheads[stateno + 1];
+  i = state_table[stateno].lookaheads;
+  k = state_table[stateno + 1].lookaheads;
   found = 0;
   while (!found && i < k)
     {
@@ -653,8 +652,7 @@ compute_lookaheads (void)
   shorts *sptmp;               /* JF */
 
   rowp = LA;
-  n = lookaheads[nstates];
-  for (i = 0; i < n; i++)
+  for (i = 0; i < state_table[nstates].lookaheads; i++)
     {
       fp3 = rowp + tokensetsize;
       for (sp = lookback[i]; sp; sp = sp->next)
@@ -668,7 +666,7 @@ compute_lookaheads (void)
       rowp = fp3;
     }
 
-  for (i = 0; i < n; i++)
+  for (i = 0; i < state_table[nstates].lookaheads; i++)
     {
       /* JF removed ref to freed storage */
       for (sp = lookback[i]; sp; sp = sptmp)

diff --git a/src/lalr.h b/src/lalr.h
index c2444883e49cac72ba9d13bb36747236e8ae0e98..0013715439c965a46e1b1da01d30d50e0ea279d2 100644 (file)
--- a/src/lalr.h
+++ b/src/lalr.h
@@ -83,6 +83,8 @@ typedef struct state_s
   /* Nonzero if no lookahead is needed to decide what to do in state
      S.  */
   char consistent;
+
+  short lookaheads;
 } state_t;
 
 /* All the decorated states, indexed by the state number.  Warning:
@@ -91,9 +93,7 @@ typedef struct state_s
 extern state_t *state_table;
 
 extern int tokensetsize;
-extern short *lookaheads;
-
-
-
 
+/* The number of lookaheads. */
+extern size_t nlookaheads;
 #endif /* !LALR_H_ */

diff --git a/src/output.c b/src/output.c
index 8abbd5d2cec526923969198d4fc710f12faae93f..3a7f08177fbc3463c7c8d2095d28314ae16b5126 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -348,8 +348,8 @@ action_row (int state)
        {
          /* loop over all the rules available here which require
             lookahead */
-         m = lookaheads[state];
-         n = lookaheads[state + 1];
+         m = state_table[state].lookaheads;
+         n = state_table[state + 1].lookaheads;
 
          for (i = n - 1; i >= m; i--)
            {
@@ -928,7 +928,6 @@ output_actions (void)
   token_actions ();
   free_shifts ();
   free_reductions ();
-  XFREE (lookaheads);
   XFREE (LA);
   XFREE (LAruleno);