Don't depend on C99 features.

* src/conflicts.c (conflicts_update_state_numbers): Fix for-loop.
* src/lalr.c (lalr_update_state_numbers): Fix for-loop.
* src/reader.c (check_and_convert_grammar): Fix for-loop.
* src/state.c (state_mark_reachable_states): Fix for-loop.
(state_remove_unreachable_states): Fix for-loop.

Don't widen struct state with member reachable just to temporarily
record reachability.  Instead, use a local bitset.
* src/state.h (struct state): Remove member.
* src/state.c (state_new): Don't initialize it.
(state_mark_reachable_states): Rename to...
(state_record_reachable_states): ... this, and use bitset.
(state_remove_unreachable_states): Use bitset.

ChangeLog

@@ -1,3 +1,20 @@
+2007-05-27  Joel E. Denny  <jdenny@ces.clemson.edu>
+
+	Don't depend on C99 features.
+	* src/conflicts.c (conflicts_update_state_numbers): Fix for-loop.
+	* src/lalr.c (lalr_update_state_numbers): Fix for-loop.
+	* src/reader.c (check_and_convert_grammar): Fix for-loop.
+	* src/state.c (state_mark_reachable_states): Fix for-loop.
+	(state_remove_unreachable_states): Fix for-loop.
+
+	Don't widen struct state with member reachable just to temporarily
+	record reachability.  Instead, use a local bitset.
+	* src/state.h (struct state): Remove member.
+	* src/state.c (state_new): Don't initialize it.
+	(state_mark_reachable_states): Rename to...
+	(state_record_reachable_states): ... this, and use bitset.
+	(state_remove_unreachable_states): Use bitset.
+
 2007-05-26  Joel E. Denny  <jdenny@ces.clemson.edu>
 
 	* src/Makefile.am (yacc): Quote target action commands properly so

src/conflicts.c

@@ -331,7 +331,8 @@ void
 conflicts_update_state_numbers (state_number old_to_new[],
                                 state_number nstates_old)
 {
-  for (state_number i = 0; i < nstates_old; ++i)
+  state_number i;
+  for (i = 0; i < nstates_old; ++i)
     if (old_to_new[i] != nstates_old)
       conflicts[old_to_new[i]] = conflicts[i];
 }

src/lalr.c

@@ -459,22 +459,25 @@ lalr_update_state_numbers (state_number old_to_new[], state_number nstates_old)
   goto_number ngotos_reachable = 0;
   symbol_number nonterminal = 0;
   aver (nsyms == nvars + ntokens);
-  for (goto_number i = 0; i < ngotos; ++i)
+  {
-    {
+    goto_number i;
-      while (i == goto_map[nonterminal])
+    for (i = 0; i < ngotos; ++i)
-        goto_map[nonterminal++] = ngotos_reachable;
+      {
-      /* If old_to_new[from_state[i]] = nstates_old, remove this goto
+        while (i == goto_map[nonterminal])
-         entry.  */
+          goto_map[nonterminal++] = ngotos_reachable;
-      if (old_to_new[from_state[i]] != nstates_old)
+        /* If old_to_new[from_state[i]] = nstates_old, remove this goto
-        {
+           entry.  */
-          /* from_state[i] is not removed, so it and thus to_state[i] are
+        if (old_to_new[from_state[i]] != nstates_old)
-             reachable, so to_state[i] != nstates_old.  */
+          {
-          aver (old_to_new[to_state[i]] != nstates_old);
+            /* from_state[i] is not removed, so it and thus to_state[i] are
-          from_state[ngotos_reachable] = old_to_new[from_state[i]];
+               reachable, so to_state[i] != nstates_old.  */
-          to_state[ngotos_reachable] = old_to_new[to_state[i]];
+            aver (old_to_new[to_state[i]] != nstates_old);
-          ++ngotos_reachable;
+            from_state[ngotos_reachable] = old_to_new[from_state[i]];
-        }
+            to_state[ngotos_reachable] = old_to_new[to_state[i]];
-    }
+            ++ngotos_reachable;
+          }
+      }
+  }
   while (nonterminal <= nvars)
     {
       aver (ngotos == goto_map[nonterminal]);

src/reader.c

@@ -640,8 +640,11 @@ check_and_convert_grammar (void)
      rule.  For the same reason, all the `used' flags must be set before
      checking whether to remove `$' from any midrule symbol name (also in
      packgram).  */
-  for (symbol_list *sym = grammar; sym; sym = sym->next)
+  {
-    code_props_translate_code (&sym->action_props);
+    symbol_list *sym;
+    for (sym = grammar; sym; sym = sym->next)
+      code_props_translate_code (&sym->action_props);
+  }
 
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();

src/state.c

@@ -145,7 +145,6 @@ state_new (symbol_number accessing_symbol,
   res->errs = NULL;
   res->consistent = 0;
   res->solved_conflicts = NULL;
-  res->reachable = false;
 
   res->nitems = nitems;
   memcpy (res->items, core, items_size);
@@ -354,41 +353,49 @@ state_hash_lookup (size_t nitems, item_number *core)
 }
 
 
-/*------------------------------------------------------.
+/*--------------------------------------------------------.
-| Mark S and all states reachable from S as reachable.  |
+| Record S and all states reachable from S in REACHABLE.  |
-`------------------------------------------------------*/
+`--------------------------------------------------------*/
 
 static void
-state_mark_reachable_states (state *s)
+state_record_reachable_states (state *s, bitset reachable)
 {
-  if (s->reachable)
+  if (bitset_test (reachable, s->number))
     return;
-  s->reachable = true;
+  bitset_set (reachable, s->number);
-  for (int i = 0; i < s->transitions->num; ++i)
+  {
-    if (!TRANSITION_IS_DISABLED (s->transitions, i))
+    int i;
-      state_mark_reachable_states (s->transitions->states[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;
-  state_mark_reachable_states (states[0]);
+  bitset reachable = bitset_create (nstates, BITSET_FIXED);
-  for (state_number i = 0; i < nstates; ++i)
+  state_record_reachable_states (states[0], reachable);
-    {
+  {
-      if (states[i]->reachable)
+    state_number i;
-        {
+    for (i = 0; i < nstates; ++i)
-          states[nstates_reachable] = states[i];
+      {
-          states[nstates_reachable]->number = nstates_reachable;
+        if (bitset_test (reachable, states[i]->number))
-          old_to_new[i] = nstates_reachable++;
+          {
-        }
+            states[nstates_reachable] = states[i];
-      else
+            states[nstates_reachable]->number = nstates_reachable;
-        {
+            old_to_new[i] = nstates_reachable++;
-          state_free (states[i]);
+          }
-          old_to_new[i] = nstates;
+        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.  */

src/state.h

@@ -209,11 +209,6 @@ struct state
      a human readable description of the resolution.  */
   const char *solved_conflicts;
 
-  /* Conflict resolution sometimes makes states unreachable.  Initialized to 0
-     in state_new and then used by state_remove_unreachable_states after
-     conflicts_solve.  */
-  bool reachable;
-
   /* Its items.  Must be last, since ITEMS can be arbitrarily large.
      */
   size_t nitems;