Enable push parsers to operate in impure mode. Thus, %push-parser no

[bison.git] / src / lalr.c

diff --git a/src/lalr.c b/src/lalr.c
index 8627f1cbc3c5596130ba78c7f1469b8158ead285..f2bfa96738f2b4e5b1dcce61486bc4381c779064 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -1,7 +1,7 @@
-/* Compute look-ahead criteria for Bison.
+/* Compute lookahead criteria for Bison.

 
 

-   Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004
-   Free Software Foundation, Inc.
+   Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004, 2005,
+   2006 Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -22,9 +22,10 @@
 
 
 /* Compute how to make the finite state machine deterministic; find
 
 
 /* Compute how to make the finite state machine deterministic; find

-   which rules need look-ahead in each state, and which look-ahead
+   which rules need lookahead in each state, and which lookahead

    tokens they accept.  */
 
    tokens they accept.  */
 

+#include <config.h>

 #include "system.h"
 
 #include <bitset.h>
 #include "system.h"
 
 #include <bitset.h>


@@ -93,8 +94,7 @@ set_goto_map (void)
          ngotos++;
 
          /* Abort if (ngotos + 1) would overflow.  */
          ngotos++;
 
          /* Abort if (ngotos + 1) would overflow.  */

-         if (ngotos == GOTO_NUMBER_MAXIMUM)
-           abort ();
+         aver (ngotos != GOTO_NUMBER_MAXIMUM);

 
          goto_map[TRANSITION_SYMBOL (sp, i) - ntokens]++;
        }
 
          goto_map[TRANSITION_SYMBOL (sp, i) - ntokens]++;
        }


@@ -153,8 +153,7 @@ map_goto (state_number s0, symbol_number sym)
 
   for (;;)
     {
 
   for (;;)
     {

-      if (high < low)
-       abort ();
+      aver (low <= high);

       middle = (low + high) / 2;
       s = from_state[middle];
       if (s == s0)
       middle = (low + high) / 2;
       s = from_state[middle];
       if (s == s0)


@@ -220,9 +219,9 @@ add_lookback_edge (state *s, rule *r, goto_number gotono)
 {
   int ri = state_reduction_find (s, r);
   goto_list *sp = xmalloc (sizeof *sp);
 {
   int ri = state_reduction_find (s, r);
   goto_list *sp = xmalloc (sizeof *sp);

-  sp->next = lookback[(s->reductions->look_ahead_tokens - LA) + ri];
+  sp->next = lookback[(s->reductions->lookahead_tokens - LA) + ri];

   sp->value = gotono;
   sp->value = gotono;

-  lookback[(s->reductions->look_ahead_tokens - LA) + ri] = sp;
+  lookback[(s->reductions->lookahead_tokens - LA) + ri] = sp;

 }
 
 
 }
 
 


@@ -246,11 +245,11 @@ build_relations (void)
        {
          bool done;
          int length = 1;
        {
          bool done;
          int length = 1;

-         item_number *rp;
+         item_number const *rp;

          state *s = states[from_state[i]];
          states1[0] = s->number;
 
          state *s = states[from_state[i]];
          states1[0] = s->number;
 

-         for (rp = (*rulep)->rhs; *rp >= 0; rp++)
+         for (rp = (*rulep)->rhs; ! item_number_is_rule_number (*rp); rp++)

            {
              s = transitions_to (s->transitions,
                                  item_number_as_symbol_number (*rp));
            {
              s = transitions_to (s->transitions,
                                  item_number_as_symbol_number (*rp));


@@ -265,9 +264,11 @@ build_relations (void)
          while (!done)
            {
              done = true;
          while (!done)
            {
              done = true;

+             /* Each rhs ends in an item number, and there is a
+                sentinel before the first rhs, so it is safe to
+                decrement RP here.  */

              rp--;
              rp--;

-             /* JF added rp>=ritem &&   I hope to god its right! */
-             if (rp >= ritem && ISVAR (*rp))
+             if (ISVAR (*rp))

                {
                  /* Downcasting from item_number to symbol_number.  */
                  edge[nedges++] = map_goto (states1[--length],
                {
                  /* Downcasting from item_number to symbol_number.  */
                  edge[nedges++] = map_goto (states1[--length],


@@ -313,7 +314,7 @@ compute_FOLLOWS (void)
 
 
 static void
 
 
 static void

-compute_look_ahead_tokens (void)
+compute_lookahead_tokens (void)

 {
   size_t i;
   goto_list *sp;
 {
   size_t i;
   goto_list *sp;


@@ -331,27 +332,27 @@ compute_look_ahead_tokens (void)
 }
 
 
 }
 
 

-/*-----------------------------------------------------.
-| Count the number of look-ahead tokens required for S |
-| (N_LOOK_AHEAD_TOKENS member).                        |
-`-----------------------------------------------------*/
+/*----------------------------------------------------.
+| Count the number of lookahead tokens required for S |
+| (N_LOOKAHEAD_TOKENS member).                        |
+`----------------------------------------------------*/

 
 static int
 
 static int

-state_look_ahead_tokens_count (state *s)
+state_lookahead_tokens_count (state *s)

 {
   int k;
 {
   int k;

-  int n_look_ahead_tokens = 0;
+  int n_lookahead_tokens = 0;

   reductions *rp = s->reductions;
   transitions *sp = s->transitions;
 
   reductions *rp = s->reductions;
   transitions *sp = s->transitions;
 

-  /* We need a look-ahead either to distinguish different
+  /* 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->num > 1
       || (rp->num == 1 && sp->num &&
          !TRANSITION_IS_DISABLED (sp, 0) && TRANSITION_IS_SHIFT (sp, 0)))
      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->num > 1
       || (rp->num == 1 && sp->num &&
          !TRANSITION_IS_DISABLED (sp, 0) && TRANSITION_IS_SHIFT (sp, 0)))

-    n_look_ahead_tokens += rp->num;
+    n_lookahead_tokens += rp->num;

   else
     s->consistent = 1;
 
   else
     s->consistent = 1;
 


@@ -362,13 +363,13 @@ state_look_ahead_tokens_count (state *s)
        break;
       }
 
        break;
       }
 

-  return n_look_ahead_tokens;
+  return n_lookahead_tokens;

 }
 
 
 }
 
 

-/*-----------------------------------------------------.
-| Compute LA, NLA, and the look_ahead_tokens members.  |
-`-----------------------------------------------------*/
+/*----------------------------------------------------.
+| Compute LA, NLA, and the lookahead_tokens members.  |
+`----------------------------------------------------*/

 
 static void
 initialize_LA (void)
 
 static void
 initialize_LA (void)


@@ -376,10 +377,10 @@ initialize_LA (void)
   state_number i;
   bitsetv pLA;
 
   state_number i;
   bitsetv pLA;
 

-  /* Compute the total number of reductions requiring a look-ahead.  */
+  /* Compute the total number of reductions requiring a lookahead.  */

   nLA = 0;
   for (i = 0; i < nstates; i++)
   nLA = 0;
   for (i = 0; i < nstates; i++)

-    nLA += state_look_ahead_tokens_count (states[i]);
+    nLA += state_lookahead_tokens_count (states[i]);

   /* Avoid having to special case 0.  */
   if (!nLA)
     nLA = 1;
   /* Avoid having to special case 0.  */
   if (!nLA)
     nLA = 1;


@@ -387,54 +388,54 @@ initialize_LA (void)
   pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
   lookback = xcalloc (nLA, sizeof *lookback);
 
   pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
   lookback = xcalloc (nLA, sizeof *lookback);
 

-  /* Initialize the members LOOK_AHEAD_TOKENS for each state whose reductions
-     require look-ahead tokens.  */
+  /* Initialize the members LOOKAHEAD_TOKENS for each state whose reductions
+     require lookahead tokens.  */

   for (i = 0; i < nstates; i++)
     {
   for (i = 0; i < nstates; i++)
     {

-      int count = state_look_ahead_tokens_count (states[i]);
+      int count = state_lookahead_tokens_count (states[i]);

       if (count)
        {
       if (count)
        {

-         states[i]->reductions->look_ahead_tokens = pLA;
+         states[i]->reductions->lookahead_tokens = pLA;

          pLA += count;
        }
     }
 }
 
 
          pLA += count;
        }
     }
 }
 
 

-/*----------------------------------------------.
-| Output the look-ahead tokens for each state.  |
-`----------------------------------------------*/
+/*---------------------------------------------.
+| Output the lookahead tokens for each state.  |
+`---------------------------------------------*/

 
 static void
 
 static void

-look_ahead_tokens_print (FILE *out)
+lookahead_tokens_print (FILE *out)

 {
   state_number i;
   int j, k;
 {
   state_number i;
   int j, k;

-  fprintf (out, "Look-ahead tokens: BEGIN\n");
+  fprintf (out, "Lookahead tokens: BEGIN\n");

   for (i = 0; i < nstates; ++i)
     {
       reductions *reds = states[i]->reductions;
       bitset_iterator iter;
   for (i = 0; i < nstates; ++i)
     {
       reductions *reds = states[i]->reductions;
       bitset_iterator iter;

-      int n_look_ahead_tokens = 0;
+      int n_lookahead_tokens = 0;

 
 

-      if (reds->look_ahead_tokens)
+      if (reds->lookahead_tokens)

        for (k = 0; k < reds->num; ++k)
        for (k = 0; k < reds->num; ++k)

-         if (reds->look_ahead_tokens[k])
-           ++n_look_ahead_tokens;
+         if (reds->lookahead_tokens[k])
+           ++n_lookahead_tokens;

 
 

-      fprintf (out, "State %d: %d look-ahead tokens\n",
-              i, n_look_ahead_tokens);
+      fprintf (out, "State %d: %d lookahead tokens\n",
+              i, n_lookahead_tokens);

 
 

-      if (reds->look_ahead_tokens)
+      if (reds->lookahead_tokens)

        for (j = 0; j < reds->num; ++j)
        for (j = 0; j < reds->num; ++j)

-         BITSET_FOR_EACH (iter, reds->look_ahead_tokens[j], k, 0)
+         BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0)

          {
            fprintf (out, "   on %d (%s) -> rule %d\n",
                     k, symbols[k]->tag,
                     reds->rules[j]->number);
          };
     }
          {
            fprintf (out, "   on %d (%s) -> rule %d\n",
                     k, symbols[k]->tag,
                     reds->rules[j]->number);
          };
     }

-  fprintf (out, "Look-ahead tokens: END\n");
+  fprintf (out, "Lookahead tokens: END\n");

 }
 
 void
 }
 
 void


@@ -445,10 +446,10 @@ lalr (void)
   initialize_F ();
   build_relations ();
   compute_FOLLOWS ();
   initialize_F ();
   build_relations ();
   compute_FOLLOWS ();

-  compute_look_ahead_tokens ();
+  compute_lookahead_tokens ();

 
   if (trace_flag & trace_sets)
 
   if (trace_flag & trace_sets)

-    look_ahead_tokens_print (stderr);
+    lookahead_tokens_print (stderr);

 }
 
 
 }
 
 


@@ -457,6 +458,6 @@ lalr_free (void)
 {
   state_number s;
   for (s = 0; s < nstates; ++s)
 {
   state_number s;
   for (s = 0; s < nstates; ++s)

-    states[s]->reductions->look_ahead_tokens = NULL;
+    states[s]->reductions->lookahead_tokens = NULL;

   bitsetv_free (LA);
 }
   bitsetv_free (LA);
 }