]> git.saurik.com Git - bison.git/blobdiff - src/lalr.c
* src/derives.c (print_derives): Be sure to use `>= 0', not `> 0',
[bison.git] / src / lalr.c
index 1dfb293d7f0168f2854caf86d92e3e592c22fd60..660088cd62fff85e7c404a21c2c7eb5e7c9ace18 100644 (file)
@@ -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];
 }
 
 
@@ -171,13 +169,11 @@ set_goto_map (void)
       shifts *sp = state_table[state]->shifts;
       for (i = sp->nshifts - 1; i >= 0 && SHIFT_IS_GOTO (sp, i); --i)
        {
-         int symbol = state_table[sp->shifts[i]]->accessing_symbol;
-
          if (ngotos == MAXSHORT)
            fatal (_("too many gotos (max %d)"), MAXSHORT);
 
          ngotos++;
-         goto_map[symbol]++;
+         goto_map[SHIFT_SYMBOL (sp, i)]++;
        }
     }
 
@@ -204,12 +200,9 @@ set_goto_map (void)
       shifts *sp = state_table[state]->shifts;
       for (i = sp->nshifts - 1; i >= 0 && SHIFT_IS_GOTO (sp, i); --i)
        {
-         int state2 = sp->shifts[i];
-         int symbol = state_table[state2]->accessing_symbol;
-
-         int k = temp_map[symbol]++;
+         int k = temp_map[SHIFT_SYMBOL (sp, i)]++;
          from_state[k] = state;
-         to_state[k] = state2;
+         to_state[k] = sp->shifts[i];
        }
     }
 
@@ -269,14 +262,11 @@ initialize_F (void)
 
       int j;
       for (j = 0; j < sp->nshifts && SHIFT_IS_SHIFT (sp, j); j++)
-       {
-         int symbol = state_table[sp->shifts[j]]->accessing_symbol;
-         SETBIT (F (i), symbol);
-       }
+       SETBIT (F (i), SHIFT_SYMBOL (sp, j));
 
       for (; j < sp->nshifts; j++)
        {
-         int symbol = state_table[sp->shifts[j]]->accessing_symbol;
+         int symbol = SHIFT_SYMBOL (sp, j);
          if (nullable[symbol])
            edge[nedges++] = map_goto (stateno, symbol);
        }
@@ -301,21 +291,21 @@ initialize_F (void)
 
 
 static void
-add_lookback_edge (int stateno, int ruleno, int gotono)
+add_lookback_edge (state_t *state, int ruleno, int gotono)
 {
   int i;
   shorts *sp;
 
-  for (i = 0; i < state_table[stateno]->nlookaheads; ++i)
-    if (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno)
+  for (i = 0; i < state->nlookaheads; ++i)
+    if (LAruleno[state->lookaheadsp + i] == ruleno)
       break;
 
-  assert (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno);
+  assert (LAruleno[state->lookaheadsp + i] == ruleno);
 
   sp = XCALLOC (shorts, 1);
-  sp->next = lookback[state_table[stateno]->lookaheadsp + i];
+  sp->next = lookback[state->lookaheadsp + i];
   sp->value = gotono;
-  lookback[state_table[stateno]->lookaheadsp + i] = sp;
+  lookback[state->lookaheadsp + i] = sp;
 }
 
 
@@ -417,7 +407,6 @@ build_relations (void)
   for (i = 0; i < ngotos; i++)
     {
       int nedges = 0;
-      int state1 = from_state[i];
       int symbol1 = state_table[to_state[i]]->accessing_symbol;
       short *rulep;
 
@@ -425,26 +414,26 @@ build_relations (void)
        {
          int done;
          int length = 1;
-         int stateno = state1;
          short *rp;
-         states[0] = state1;
+         state_t *state = state_table[from_state[i]];
+         states[0] = state->number;
 
-         for (rp = ritem + rule_table[*rulep].rhs; *rp > 0; rp++)
+         for (rp = &ritem[rule_table[*rulep].rhs]; *rp >= 0; rp++)
            {
-             shifts *sp = state_table[stateno]->shifts;
+             shifts *sp = state->shifts;
              int j;
              for (j = 0; j < sp->nshifts; j++)
                {
-                 stateno = sp->shifts[j];
-                 if (state_table[stateno]->accessing_symbol == *rp)
+                 state = state_table[sp->shifts[j]];
+                 if (state->accessing_symbol == *rp)
                    break;
                }
 
-             states[length++] = stateno;
+             states[length++] = state->number;
            }
 
-         if (!state_table[stateno]->consistent)
-           add_lookback_edge (stateno, *rulep, i);
+         if (!state->consistent)
+           add_lookback_edge (state, *rulep, i);
 
          length--;
          done = 0;
@@ -455,8 +444,7 @@ build_relations (void)
              /* JF added rp>=ritem &&   I hope to god its right! */
              if (rp >= ritem && ISVAR (*rp))
                {
-                 stateno = states[--length];
-                 edge[nedges++] = map_goto (stateno, *rp);
+                 edge[nedges++] = map_goto (states[--length], *rp);
                  if (nullable[*rp])
                    done = 0;
                }
@@ -535,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;