Get rid of broken %no-parser, -n, and --no-parser implementation and

[bison.git] / src / state.c

diff --git a/src/state.c b/src/state.c
index 4eb39f9f6ca34cfae6b2ac0d8ab99966488ea981..3ba592bf2e9c1d83cc33de1af4caa22a55d52d83 100644 (file)
--- a/src/state.c
+++ b/src/state.c
@@ -1,6 +1,6 @@
 /* Type definitions for nondeterministic finite state machine for Bison.
 
 /* Type definitions for nondeterministic finite state machine for Bison.
 

-   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Free Software
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software

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


@@ -61,7 +61,7 @@ transitions_to (transitions *shifts, symbol_number sym)
   int j;
   for (j = 0; ; j++)
     {
   int j;
   for (j = 0; ; j++)
     {

-      assert (j < shifts->num);
+      aver (j < shifts->num);

       if (TRANSITION_SYMBOL (shifts, j) == sym)
        return shifts->states[j];
     }
       if (TRANSITION_SYMBOL (shifts, j) == sym)
        return shifts->states[j];
     }


@@ -105,7 +105,7 @@ reductions_new (int num, rule **reds)
   size_t rules_size = num * sizeof *reds;
   reductions *res = xmalloc (offsetof (reductions, rules) + rules_size);
   res->num = num;
   size_t rules_size = num * sizeof *reds;
   reductions *res = xmalloc (offsetof (reductions, rules) + rules_size);
   res->num = num;

-  res->look_ahead_tokens = NULL;
+  res->lookahead_tokens = NULL;

   memcpy (res->rules, reds, rules_size);
   return res;
 }
   memcpy (res->rules, reds, rules_size);
   return res;
 }


@@ -135,7 +135,7 @@ state_new (symbol_number accessing_symbol,
   state *res;
   size_t items_size = nitems * sizeof *core;
 
   state *res;
   size_t items_size = nitems * sizeof *core;
 

-  assert (nstates < STATE_NUMBER_MAXIMUM);
+  aver (nstates < STATE_NUMBER_MAXIMUM);

 
   res = xmalloc (offsetof (state, items) + items_size);
   res->number = nstates++;
 
   res = xmalloc (offsetof (state, items) + items_size);
   res->number = nstates++;


@@ -176,7 +176,7 @@ state_free (state *s)
 void
 state_transitions_set (state *s, int num, state **trans)
 {
 void
 state_transitions_set (state *s, int num, state **trans)
 {

-  assert (!s->transitions);
+  aver (!s->transitions);

   s->transitions = transitions_new (num, trans);
 }
 
   s->transitions = transitions_new (num, trans);
 }
 


@@ -188,7 +188,7 @@ state_transitions_set (state *s, int num, state **trans)
 void
 state_reductions_set (state *s, int num, rule **reds)
 {
 void
 state_reductions_set (state *s, int num, rule **reds)
 {

-  assert (!s->reductions);
+  aver (!s->reductions);

   s->reductions = reductions_new (num, reds);
 }
 
   s->reductions = reductions_new (num, reds);
 }
 


@@ -212,32 +212,32 @@ state_reduction_find (state *s, rule *r)
 void
 state_errs_set (state *s, int num, symbol **tokens)
 {
 void
 state_errs_set (state *s, int num, symbol **tokens)
 {

-  assert (!s->errs);
+  aver (!s->errs);

   s->errs = errs_new (num, tokens);
 }
 
 
 
   s->errs = errs_new (num, tokens);
 }
 
 
 

-/*---------------------------------------------------.
-| Print on OUT all the look-ahead tokens such that S |
-| wants to reduce R.                                 |
-`---------------------------------------------------*/
+/*--------------------------------------------------.
+| Print on OUT all the lookahead tokens such that S |
+| wants to reduce R.                                |
+`--------------------------------------------------*/

 
 void
 
 void

-state_rule_look_ahead_tokens_print (state *s, rule *r, FILE *out)
+state_rule_lookahead_tokens_print (state *s, rule *r, FILE *out)

 {
   /* Find the reduction we are handling.  */
   reductions *reds = s->reductions;
   int red = state_reduction_find (s, r);
 
   /* Print them if there are.  */
 {
   /* Find the reduction we are handling.  */
   reductions *reds = s->reductions;
   int red = state_reduction_find (s, r);
 
   /* Print them if there are.  */

-  if (reds->look_ahead_tokens && red != -1)
+  if (reds->lookahead_tokens && red != -1)

     {
       bitset_iterator biter;
       int k;
       char const *sep = "";
       fprintf (out, "  [");
     {
       bitset_iterator biter;
       int k;
       char const *sep = "";
       fprintf (out, "  [");

-      BITSET_FOR_EACH (biter, reds->look_ahead_tokens[red], k, 0)
+      BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0)

        {
          fprintf (out, "%s%s", sep, symbols[k]->tag);
          sep = ", ";
        {
          fprintf (out, "%s%s", sep, symbols[k]->tag);
          sep = ", ";


@@ -352,6 +352,52 @@ state_hash_lookup (size_t nitems, item_number *core)
   return entry;
 }
 
   return entry;
 }
 

+
+/*--------------------------------------------------------.
+| Record S and all states reachable from S in REACHABLE.  |
+`--------------------------------------------------------*/
+
+static void
+state_record_reachable_states (state *s, bitset reachable)
+{
+  if (bitset_test (reachable, s->number))
+    return;
+  bitset_set (reachable, s->number);
+  {
+    int i;
+    for (i = 0; i < s->transitions->num; ++i)
+      if (!TRANSITION_IS_DISABLED (s->transitions, i))
+        state_record_reachable_states (s->transitions->states[i], reachable);
+  }
+}
+
+void
+state_remove_unreachable_states (state_number old_to_new[])
+{
+  state_number nstates_reachable = 0;
+  bitset reachable = bitset_create (nstates, BITSET_FIXED);
+  state_record_reachable_states (states[0], reachable);
+  {
+    state_number i;
+    for (i = 0; i < nstates; ++i)
+      {
+        if (bitset_test (reachable, states[i]->number))
+          {
+            states[nstates_reachable] = states[i];
+            states[nstates_reachable]->number = nstates_reachable;
+            old_to_new[i] = nstates_reachable++;
+          }
+        else
+          {
+            state_free (states[i]);
+            old_to_new[i] = nstates;
+          }
+      }
+  }
+  nstates = nstates_reachable;
+  bitset_free (reachable);
+}
+

 /* All the decorated states, indexed by the state number.  */
 state **states = NULL;
 
 /* All the decorated states, indexed by the state number.  */
 state **states = NULL;