More changes to pacify C++ compilers.

[bison.git] / src / print.c

diff --git a/src/print.c b/src/print.c
index ae2ead9a8072b1da594f8b678804433b2879232d..533e3ca1d73765348c61f0467c2ecc5a1fd3f468 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -1,5 +1,6 @@
 /* Print information on generated parser, for bison,
 /* Print information on generated parser, for bison,

-   Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002
+
+   Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004

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


@@ -16,28 +17,30 @@
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to

-   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */

 
 
 #include "system.h"
 
 
 #include "system.h"

-#include "quotearg.h"
-#include "files.h"
-#include "symtab.h"
-#include "gram.h"
+
+#include <bitset.h>
+#include <quotearg.h>
+

 #include "LR0.h"
 #include "LR0.h"

-#include "lalr.h"
+#include "closure.h"

 #include "conflicts.h"
 #include "conflicts.h"

+#include "files.h"

 #include "getargs.h"
 #include "getargs.h"

-#include "state.h"
-#include "reader.h"
+#include "gram.h"
+#include "lalr.h"

 #include "print.h"
 #include "print.h"

+#include "reader.h"

 #include "reduce.h"
 #include "reduce.h"

-#include "closure.h"
-#include "bitset.h"
+#include "state.h"
+#include "symtab.h"

 
 

-static bitset shiftset;
-static bitset lookaheadset;
+static bitset shift_set;
+static bitset look_ahead_set;

 
 #if 0
 static void
 
 #if 0
 static void


@@ -66,12 +69,12 @@ max_length (size_t *width, const char *str)
 `--------------------------------*/
 
 static void
 `--------------------------------*/
 
 static void

-print_core (FILE *out, state_t *state)
+print_core (FILE *out, state *s)

 {
 {

-  int i;
-  item_number_t *sitems = state->items;
-  int snritems   = state->nitems;
-  symbol_t *previous_lhs = NULL;
+  size_t i;
+  item_number *sitems = s->items;
+  size_t snritems = s->nitems;
+  symbol *previous_lhs = NULL;

 
   /* Output all the items of a state, not only its kernel.  */
   if (report_flag & report_itemsets)
 
   /* Output all the items of a state, not only its kernel.  */
   if (report_flag & report_itemsets)


@@ -88,54 +91,54 @@ print_core (FILE *out, state_t *state)
 
   for (i = 0; i < snritems; i++)
     {
 
   for (i = 0; i < snritems; i++)
     {

-      item_number_t *sp;
-      item_number_t *sp1;
-      int rule;
+      item_number *sp;
+      item_number *sp1;
+      rule_number r;

 
       sp1 = sp = ritem + sitems[i];
 
       while (*sp >= 0)
        sp++;
 
 
       sp1 = sp = ritem + sitems[i];
 
       while (*sp >= 0)
        sp++;
 

-      rule = item_number_as_rule_number (*sp);
+      r = item_number_as_rule_number (*sp);

 
 

-      rule_lhs_print (&rules[rule], previous_lhs, out);
-      previous_lhs = rules[rule].lhs;
+      rule_lhs_print (&rules[r], previous_lhs, out);
+      previous_lhs = rules[r].lhs;

 
 

-      for (sp = rules[rule].rhs; sp < sp1; sp++)
+      for (sp = rules[r].rhs; sp < sp1; sp++)

        fprintf (out, " %s", symbols[*sp]->tag);
       fputs (" .", out);
       for (/* Nothing */; *sp >= 0; ++sp)
        fprintf (out, " %s", symbols[*sp]->tag);
 
        fprintf (out, " %s", symbols[*sp]->tag);
       fputs (" .", out);
       for (/* Nothing */; *sp >= 0; ++sp)
        fprintf (out, " %s", symbols[*sp]->tag);
 

-      /* Display the lookaheads?  */
-      if (report_flag & report_lookaheads)
-       state_rule_lookaheads_print (state, &rules[rule], out);
+      /* Display the look-ahead tokens?  */
+      if (report_flag & report_look_ahead_tokens)
+       state_rule_look_ahead_tokens_print (s, &rules[r], out);

 
       fputc ('\n', out);
     }
 }
 
 
 
       fputc ('\n', out);
     }
 }
 
 

-/*----------------------------------------------------------------.
-| Report the shifts iff DISPLAY_SHIFTS_P or the gotos of STATE on |
-| OUT.                                                            |
-`----------------------------------------------------------------*/
+/*------------------------------------------------------------.
+| Report the shifts iff DISPLAY_SHIFTS_P or the gotos of S on |
+| OUT.                                                        |
+`------------------------------------------------------------*/

 
 static void
 
 static void

-print_transitions (state_t *state, FILE *out, bool display_transitions_p)
+print_transitions (state *s, FILE *out, bool display_transitions_p)

 {
 {

-  transitions_t *transitions = state->transitions;
+  transitions *trans = s->transitions;

   size_t width = 0;
   int i;
 
   size_t width = 0;
   int i;
 

-  /* Compute the width of the lookaheads column.  */
-  for (i = 0; i < transitions->num; i++)
-    if (!TRANSITION_IS_DISABLED (transitions, i)
-       && TRANSITION_IS_SHIFT (transitions, i) == display_transitions_p)
+  /* Compute the width of the look-ahead token column.  */
+  for (i = 0; i < trans->num; i++)
+    if (!TRANSITION_IS_DISABLED (trans, i)
+       && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)

       {
       {

-       symbol_t *symbol = symbols[TRANSITION_SYMBOL (transitions, i)];
-       max_length (&width, symbol->tag);
+       symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
+       max_length (&width, sym->tag);

       }
 
   /* Nothing to report. */
       }
 
   /* Nothing to report. */


@@ -145,39 +148,39 @@ print_transitions (state_t *state, FILE *out, bool display_transitions_p)
   fputc ('\n', out);
   width += 2;
 
   fputc ('\n', out);
   width += 2;
 

-  /* Report lookaheads and shifts.  */
-  for (i = 0; i < transitions->num; i++)
-    if (!TRANSITION_IS_DISABLED (transitions, i)
-       && TRANSITION_IS_SHIFT (transitions, i) == display_transitions_p)
+  /* Report look-ahead tokens and shifts.  */
+  for (i = 0; i < trans->num; i++)
+    if (!TRANSITION_IS_DISABLED (trans, i)
+       && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)

       {
       {

-       symbol_t *symbol = symbols[TRANSITION_SYMBOL (transitions, i)];
-       const char *tag = symbol->tag;
-       state_t *state1 = transitions->states[i];
+       symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
+       const char *tag = sym->tag;
+       state *s1 = trans->states[i];

        int j;
 
        fprintf (out, "    %s", tag);
        for (j = width - strlen (tag); j > 0; --j)
          fputc (' ', out);
        if (display_transitions_p)
        int j;
 
        fprintf (out, "    %s", tag);
        for (j = width - strlen (tag); j > 0; --j)
          fputc (' ', out);
        if (display_transitions_p)

-         fprintf (out, _("shift, and go to state %d\n"), state1->number);
+         fprintf (out, _("shift, and go to state %d\n"), s1->number);

        else
        else

-         fprintf (out, _("go to state %d\n"), state1->number);
+         fprintf (out, _("go to state %d\n"), s1->number);

       }
 }
 
 
       }
 }
 
 

-/*------------------------------------------------------------.
-| Report the explicit errors of STATE raised from %nonassoc.  |
-`------------------------------------------------------------*/
+/*--------------------------------------------------------.
+| Report the explicit errors of S raised from %nonassoc.  |
+`--------------------------------------------------------*/

 
 static void
 
 static void

-print_errs (FILE *out, state_t *state)
+print_errs (FILE *out, state *s)

 {
 {

-  errs_t *errp = state->errs;
+  errs *errp = s->errs;

   size_t width = 0;
   int i;
 
   size_t width = 0;
   int i;
 

-  /* Compute the width of the lookaheads column.  */
+  /* Compute the width of the look-ahead token column.  */

   for (i = 0; i < errp->num; ++i)
     if (errp->symbols[i])
       max_length (&width, errp->symbols[i]->tag);
   for (i = 0; i < errp->num; ++i)
     if (errp->symbols[i])
       max_length (&width, errp->symbols[i]->tag);


@@ -189,7 +192,7 @@ print_errs (FILE *out, state_t *state)
   fputc ('\n', out);
   width += 2;
 
   fputc ('\n', out);
   width += 2;
 

-  /* Report lookaheads and errors.  */
+  /* Report look-ahead tokens and errors.  */

   for (i = 0; i < errp->num; ++i)
     if (errp->symbols[i])
       {
   for (i = 0; i < errp->num; ++i)
     if (errp->symbols[i])
       {


@@ -203,92 +206,90 @@ print_errs (FILE *out, state_t *state)
 }
 
 
 }
 
 

-/*----------------------------------------------------------.
-| Return the default rule of this STATE if it has one, NULL |
-| otherwise.                                                |
-`----------------------------------------------------------*/
+/*-------------------------------------------------------------.
+| Return the default rule of S if it has one, NULL otherwise.  |
+`-------------------------------------------------------------*/

 
 

-static rule_t *
-state_default_rule (state_t *state)
+static rule *
+state_default_rule (state *s)

 {
 {

-  reductions_t *redp = state->reductions;
-  rule_t *default_rule = NULL;
+  reductions *reds = s->reductions;
+  rule *default_rule = NULL;

   int cmax = 0;
   int i;
 
   int cmax = 0;
   int i;
 

-  /* No need for a lookahead.  */
-  if (state->consistent)
-    return redp->rules[0];
+  /* No need for a look-ahead.  */
+  if (s->consistent)
+    return reds->rules[0];

 
 

-  /* 1. Each reduction is possibly masked by the lookaheads on which
+  /* 1. Each reduction is possibly masked by the look-ahead tokens on which

      we shift (S/R conflicts)...  */
      we shift (S/R conflicts)...  */

-  bitset_zero (shiftset);
+  bitset_zero (shift_set);

   {
   {

-    transitions_t *transitions = state->transitions;
-    FOR_EACH_SHIFT (transitions, i)
+    transitions *trans = s->transitions;
+    FOR_EACH_SHIFT (trans, i)

       {
        /* If this state has a shift for the error token, don't use a
             default rule.  */
       {
        /* If this state has a shift for the error token, don't use a
             default rule.  */

-       if (TRANSITION_IS_ERROR (transitions, i))
+       if (TRANSITION_IS_ERROR (trans, i))

          return NULL;
          return NULL;

-       bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+       bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));

       }
   }
 
       }
   }
 

-  /* 2. Each reduction is possibly masked by the lookaheads on which
+  /* 2. Each reduction is possibly masked by the look-ahead tokens on which

      we raise an error (due to %nonassoc).  */
   {
      we raise an error (due to %nonassoc).  */
   {

-    errs_t *errp = state->errs;
+    errs *errp = s->errs;

     for (i = 0; i < errp->num; i++)
       if (errp->symbols[i])
     for (i = 0; i < errp->num; i++)
       if (errp->symbols[i])

-       bitset_set (shiftset, errp->symbols[i]->number);
+       bitset_set (shift_set, errp->symbols[i]->number);

   }
 
   }
 

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

     {
       int count = 0;
 
     {
       int count = 0;
 

-      /* How many non-masked lookaheads are there for this reduction?
-        */
-      bitset_andn (lookaheadset, redp->lookaheads[i], shiftset);
-      count = bitset_count (lookaheadset);
+      /* How many non-masked look-ahead tokens are there for this
+        reduction?  */
+      bitset_andn (look_ahead_set, reds->look_ahead_tokens[i], shift_set);
+      count = bitset_count (look_ahead_set);

 
       if (count > cmax)
        {
          cmax = count;
 
       if (count > cmax)
        {
          cmax = count;

-         default_rule = redp->rules[i];
+         default_rule = reds->rules[i];

        }
 
       /* 3. And finally, each reduction is possibly masked by previous
         reductions (in R/R conflicts, we keep the first reductions).
         */
        }
 
       /* 3. And finally, each reduction is possibly masked by previous
         reductions (in R/R conflicts, we keep the first reductions).
         */

-      bitset_or (shiftset, shiftset, redp->lookaheads[i]);
+      bitset_or (shift_set, shift_set, reds->look_ahead_tokens[i]);

     }
 
   return default_rule;
 }
 
 
     }
 
   return default_rule;
 }
 
 

-/*--------------------------------------------------------------------.
-| Report a reduction of RULE on LOOKAHEADS (which can be `default').  |
-| If not ENABLED, the rule is masked by a shift or a reduce (S/R and  |
-| R/R conflicts).                                                     |
-`--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------------.
+| Report a reduction of RULE on LOOK_AHEAD_TOKEN (which can be `default').  |
+| If not ENABLED, the rule is masked by a shift or a reduce (S/R and        |
+| R/R conflicts).                                                           |
+`--------------------------------------------------------------------------*/

 
 static void
 print_reduction (FILE *out, size_t width,
 
 static void
 print_reduction (FILE *out, size_t width,

-                const char *lookahead,
-                rule_t *rule, bool enabled)
+                const char *look_ahead_token,
+                rule *r, bool enabled)

 {
   int j;
 {
   int j;

-  fprintf (out, "    %s", lookahead);
-  for (j = width - strlen (lookahead); j > 0; --j)
+  fprintf (out, "    %s", look_ahead_token);
+  for (j = width - strlen (look_ahead_token); j > 0; --j)

     fputc (' ', out);
   if (!enabled)
     fputc ('[', out);
     fputc (' ', out);
   if (!enabled)
     fputc ('[', out);

-  if (rule->number)
-    fprintf (out, _("reduce using rule %d (%s)"),
-            rule->number, rule->lhs->tag);
+  if (r->number)
+    fprintf (out, _("reduce using rule %d (%s)"), r->number, r->lhs->tag);

   else
     fprintf (out, _("accept"));
   if (!enabled)
   else
     fprintf (out, _("accept"));
   if (!enabled)


@@ -297,45 +298,45 @@ print_reduction (FILE *out, size_t width,
 }
 
 
 }
 
 

-/*----------------------------------------------------.
-| Report on OUT the reduction actions of this STATE.  |
-`----------------------------------------------------*/
+/*-------------------------------------------.
+| Report on OUT the reduction actions of S.  |
+`-------------------------------------------*/

 
 static void
 
 static void

-print_reductions (FILE *out, state_t *state)
+print_reductions (FILE *out, state *s)

 {
 {

-  transitions_t *transitions = state->transitions;
-  reductions_t *redp = state->reductions;
-  rule_t *default_rule = NULL;
+  transitions *trans = s->transitions;
+  reductions *reds = s->reductions;
+  rule *default_rule = NULL;

   size_t width = 0;
   int i, j;
 
   size_t width = 0;
   int i, j;
 

-  if (redp->num == 0)
+  if (reds->num == 0)

     return;
 
     return;
 

-  default_rule = state_default_rule (state);
+  default_rule = state_default_rule (s);

 
 

-  bitset_zero (shiftset);
-  FOR_EACH_SHIFT (transitions, i)
-    bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+  bitset_zero (shift_set);
+  FOR_EACH_SHIFT (trans, i)
+    bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));

 
 

-  /* Compute the width of the lookaheads column.  */
+  /* Compute the width of the look-ahead token column.  */

   if (default_rule)
     width = strlen (_("$default"));
 
   if (default_rule)
     width = strlen (_("$default"));
 

-  if (redp->lookaheads)
+  if (reds->look_ahead_tokens)

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

-       int count = bitset_test (shiftset, i);
+       bool count = bitset_test (shift_set, i);

 
 

-       for (j = 0; j < redp->num; ++j)
-         if (bitset_test (redp->lookaheads[j], i))
+       for (j = 0; j < reds->num; ++j)
+         if (bitset_test (reds->look_ahead_tokens[j], i))

            {
            {

-             if (count == 0)
+             if (! count)

                {
                {

-                 if (redp->rules[j] != default_rule)
+                 if (reds->rules[j] != default_rule)

                    max_length (&width, symbols[i]->tag);
                    max_length (&width, symbols[i]->tag);

-                 count++;
+                 count = true;

                }
              else
                {
                }
              else
                {


@@ -351,25 +352,25 @@ print_reductions (FILE *out, state_t *state)
   fputc ('\n', out);
   width += 2;
 
   fputc ('\n', out);
   width += 2;
 

-  /* Report lookaheads (or $default) and reductions.  */
-  if (redp->lookaheads)
+  /* Report look-ahead tokens (or $default) and reductions.  */
+  if (reds->look_ahead_tokens)

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

-       int defaulted = 0;
-       int count = bitset_test (shiftset, i);
+       bool defaulted = false;
+       bool count = bitset_test (shift_set, i);

 
 

-       for (j = 0; j < redp->num; ++j)
-         if (bitset_test (redp->lookaheads[j], i))
+       for (j = 0; j < reds->num; ++j)
+         if (bitset_test (reds->look_ahead_tokens[j], i))

            {
            {

-             if (count == 0)
+             if (! count)

                {
                {

-                 if (redp->rules[j] != default_rule)
+                 if (reds->rules[j] != default_rule)

                    print_reduction (out, width,
                                     symbols[i]->tag,
                    print_reduction (out, width,
                                     symbols[i]->tag,

-                                    redp->rules[j], true);
+                                    reds->rules[j], true);

                  else
                  else

-                   defaulted = 1;
-                 count++;
+                   defaulted = true;
+                 count = true;

                }
              else
                {
                }
              else
                {


@@ -377,10 +378,10 @@ print_reductions (FILE *out, state_t *state)
                    print_reduction (out, width,
                                     symbols[i]->tag,
                                     default_rule, true);
                    print_reduction (out, width,
                                     symbols[i]->tag,
                                     default_rule, true);

-                 defaulted = 0;
+                 defaulted = false;

                  print_reduction (out, width,
                                   symbols[i]->tag,
                  print_reduction (out, width,
                                   symbols[i]->tag,

-                                  redp->rules[j], false);
+                                  reds->rules[j], false);

                }
            }
       }
                }
            }
       }


@@ -393,38 +394,37 @@ print_reductions (FILE *out, state_t *state)
 
 /*--------------------------------------------------------------.
 | Report on OUT all the actions (shifts, gotos, reductions, and |
 
 /*--------------------------------------------------------------.
 | Report on OUT all the actions (shifts, gotos, reductions, and |

-| explicit erros from %nonassoc) of STATE.                      |
+| explicit erros from %nonassoc) of S.                          |

 `--------------------------------------------------------------*/
 
 static void
 `--------------------------------------------------------------*/
 
 static void

-print_actions (FILE *out, state_t *state)
+print_actions (FILE *out, state *s)

 {
   /* Print shifts.  */
 {
   /* Print shifts.  */

-  print_transitions (state, out, true);
-  print_errs (out, state);
-  print_reductions (out, state);
+  print_transitions (s, out, true);
+  print_errs (out, s);
+  print_reductions (out, s);

   /* Print gotos.  */
   /* Print gotos.  */

-  print_transitions (state, out, false);
+  print_transitions (s, out, false);

 }
 
 
 }
 
 

-/*--------------------------------------.
-| Report all the data on STATE on OUT.  |
-`--------------------------------------*/
+/*----------------------------------.
+| Report all the data on S on OUT.  |
+`----------------------------------*/

 
 static void
 
 static void

-print_state (FILE *out, state_t *state)
+print_state (FILE *out, state *s)

 {
   fputs ("\n\n", out);
 {
   fputs ("\n\n", out);

-  fprintf (out, _("state %d"), state->number);
+  fprintf (out, _("state %d"), s->number);

   fputc ('\n', out);
   fputc ('\n', out);

-  print_core (out, state);
-  print_actions (out, state);
-  if ((report_flag & report_solved_conflicts)
-      && state->solved_conflicts)
+  print_core (out, s);
+  print_actions (out, s);
+  if ((report_flag & report_solved_conflicts) && s->solved_conflicts)

     {
       fputc ('\n', out);
     {
       fputc ('\n', out);

-      fputs (state->solved_conflicts, out);
+      fputs (s->solved_conflicts, out);

     }
 }
 \f
     }
 }
 \f


@@ -446,7 +446,7 @@ do {                                                \
 static void
 print_grammar (FILE *out)
 {
 static void
 print_grammar (FILE *out)
 {

-  symbol_number_t i;
+  symbol_number i;

   char buffer[90];
   int column = 0;
 
   char buffer[90];
   int column = 0;
 


@@ -458,8 +458,8 @@ print_grammar (FILE *out)
     if (token_translations[i] != undeftoken->number)
       {
        const char *tag = symbols[token_translations[i]]->tag;
     if (token_translations[i] != undeftoken->number)
       {
        const char *tag = symbols[token_translations[i]]->tag;

-       rule_number_t r;
-       item_number_t *rhsp;
+       rule_number r;
+       item_number *rhsp;

 
        buffer[0] = 0;
        column = strlen (tag);
 
        buffer[0] = 0;
        column = strlen (tag);


@@ -484,12 +484,12 @@ print_grammar (FILE *out)
   for (i = ntokens; i < nsyms; i++)
     {
       int left_count = 0, right_count = 0;
   for (i = ntokens; i < nsyms; i++)
     {
       int left_count = 0, right_count = 0;

-      rule_number_t r;
+      rule_number r;

       const char *tag = symbols[i]->tag;
 
       for (r = 0; r < nrules; r++)
        {
       const char *tag = symbols[i]->tag;
 
       for (r = 0; r < nrules; r++)
        {

-         item_number_t *rhsp;
+         item_number *rhsp;

          if (rules[r].lhs->number == i)
            left_count++;
          for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
          if (rules[r].lhs->number == i)
            left_count++;
          for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)


@@ -527,7 +527,7 @@ print_grammar (FILE *out)
          sprintf (buffer + strlen (buffer), _(" on right:"));
          for (r = 0; r < nrules; r++)
            {
          sprintf (buffer + strlen (buffer), _(" on right:"));
          for (r = 0; r < nrules; r++)
            {

-             item_number_t *rhsp;
+             item_number *rhsp;

              for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
                if (item_number_as_symbol_number (*rhsp) == i)
                  {
              for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
                if (item_number_as_symbol_number (*rhsp) == i)
                  {


@@ -544,7 +544,7 @@ print_grammar (FILE *out)
 void
 print_results (void)
 {
 void
 print_results (void)
 {

-  state_number_t i;
+  state_number i;

 
   /* We used to use just .out if SPEC_NAME_PREFIX (-p) was used, but
      that conflicts with Posix.  */
 
   /* We used to use just .out if SPEC_NAME_PREFIX (-p) was used, but
      that conflicts with Posix.  */


@@ -562,12 +562,12 @@ print_results (void)
   if (report_flag & report_itemsets)
     new_closure (nritems);
   /* Storage for print_reductions.  */
   if (report_flag & report_itemsets)
     new_closure (nritems);
   /* Storage for print_reductions.  */

-  shiftset =  bitset_create (ntokens, BITSET_FIXED);
-  lookaheadset = bitset_create (ntokens, BITSET_FIXED);
+  shift_set =  bitset_create (ntokens, BITSET_FIXED);
+  look_ahead_set = bitset_create (ntokens, BITSET_FIXED);

   for (i = 0; i < nstates; i++)
     print_state (out, states[i]);
   for (i = 0; i < nstates; i++)
     print_state (out, states[i]);

-  bitset_free (shiftset);
-  bitset_free (lookaheadset);
+  bitset_free (shift_set);
+  bitset_free (look_ahead_set);

   if (report_flag & report_itemsets)
     free_closure ();
 
   if (report_flag & report_itemsets)
     free_closure ();