Use bitset operations when possible, not loops over bits.

[bison.git] / src / print.c

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

-   Copyright 1984, 1986, 1989, 2000, 2001 Free Software Foundation, Inc.
+   Copyright 1984, 1986, 1989, 2000, 2001, 2002 Free Software Foundation, Inc.

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


@@ -20,7 +20,9 @@
 
 
 #include "system.h"
 
 
 #include "system.h"

+#include "quotearg.h"

 #include "files.h"
 #include "files.h"

+#include "symtab.h"

 #include "gram.h"
 #include "LR0.h"
 #include "lalr.h"
 #include "gram.h"
 #include "LR0.h"
 #include "lalr.h"


@@ -31,9 +33,10 @@
 #include "print.h"
 #include "reduce.h"
 #include "closure.h"
 #include "print.h"
 #include "reduce.h"
 #include "closure.h"

+#include "bitset.h"

 
 

-static unsigned *shiftset = NULL;
-static unsigned *lookaheadset = NULL;
+static bitset shiftset;
+static bitset lookaheadset;

 
 #if 0
 static void
 
 #if 0
 static void


@@ -43,6 +46,19 @@ print_token (int extnum, int token)
 }
 #endif
 
 }
 #endif
 

+static inline const char *
+escape (const char *s)
+{
+  return quotearg_n_style (1, escape_quoting_style, s);
+}
+
+/* Be cautious not to use twice the same slot in a single expression. */
+static inline const char *
+escape2 (const char *s)
+{
+  return quotearg_n_style (2, escape_quoting_style, s);
+}
+

 \f
 /*--------------------------------.
 | Report information on a state.  |
 \f
 /*--------------------------------.
 | Report information on a state.  |


@@ -74,21 +90,21 @@ print_core (FILE *out, state_t *state)
 
          sp1 = sp = ritem + sitems[i];
 
 
          sp1 = sp = ritem + sitems[i];
 

-         while (*sp > 0)
+         while (*sp >= 0)

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

-         fprintf (out, "    %s  ->  ", tags[rule_table[rule].lhs]);
+         fprintf (out, "    %s  ->  ", escape (symbols[rules[rule].lhs]->tag));

 
 

-         for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
-           fprintf (out, "%s ", tags[*sp]);
+         for (sp = ritem + rules[rule].rhs; sp < sp1; sp++)
+           fprintf (out, "%s ", escape (symbols[*sp]->tag));

 
          fputc ('.', out);
 
 
          fputc ('.', out);
 

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

 
 

-         fprintf (out, _("   (rule %d)"), rule);
+         fprintf (out, _("   (rule %d)"), rule - 1);

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


@@ -107,10 +123,10 @@ print_shifts (FILE *out, state_t *state)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       {
        int state1 = shiftp->shifts[i];
     if (!SHIFT_IS_DISABLED (shiftp, i))
       {
        int state1 = shiftp->shifts[i];

-       int symbol = state_table[state1]->accessing_symbol;
+       int symbol = states[state1]->accessing_symbol;

        fprintf (out,
                 _("    %-4s\tshift, and go to state %d\n"),
        fprintf (out,
                 _("    %-4s\tshift, and go to state %d\n"),

-                tags[symbol], state1);
+                escape (symbols[symbol]->tag), state1);

       }
 
   if (i > 0)
       }
 
   if (i > 0)


@@ -124,16 +140,13 @@ print_errs (FILE *out, state_t *state)
   errs *errp = state->errs;
   int i;
 
   errs *errp = state->errs;
   int i;
 

-  if (!errp)
-    return;
-

   for (i = 0; i < errp->nerrs; ++i)
     if (errp->errs[i])
       fprintf (out, _("    %-4s\terror (nonassociative)\n"),
   for (i = 0; i < errp->nerrs; ++i)
     if (errp->errs[i])
       fprintf (out, _("    %-4s\terror (nonassociative)\n"),

-              tags[errp->errs[i]]);
+              escape (symbols[errp->errs[i]]->tag));

 
   if (i > 0)
 
   if (i > 0)

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

 }
 
 
 }
 
 


@@ -152,9 +165,9 @@ print_gotos (FILE *out, state_t *state)
        if (!SHIFT_IS_DISABLED (shiftp, i))
          {
            int state1 = shiftp->shifts[i];
        if (!SHIFT_IS_DISABLED (shiftp, i))
          {
            int state1 = shiftp->shifts[i];

-           int symbol = state_table[state1]->accessing_symbol;
+           int symbol = states[state1]->accessing_symbol;

            fprintf (out, _("    %-4s\tgo to state %d\n"),
            fprintf (out, _("    %-4s\tgo to state %d\n"),

-                    tags[symbol], state1);
+                    escape (symbols[symbol]->tag), state1);

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


@@ -170,17 +183,19 @@ print_reductions (FILE *out, state_t *state)
   errs *errp = state->errs;
   int nodefault = 0;
 
   errs *errp = state->errs;
   int nodefault = 0;
 

+  if (redp->nreds == 0)
+    return;
+

   if (state->consistent)
     {
       int rule = redp->rules[0];
   if (state->consistent)
     {
       int rule = redp->rules[0];

-      int symbol = rule_table[rule].lhs;
+      int symbol = rules[rule].lhs;

       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),

-              rule, tags[symbol]);
+              rule - 1, escape (symbols[symbol]->tag));

       return;
     }
 
       return;
     }
 

-  for (i = 0; i < tokensetsize; i++)
-    shiftset[i] = 0;
+  bitset_zero (shiftset);

 
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
 
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))


@@ -189,30 +204,27 @@ print_reductions (FILE *out, state_t *state)
           default rule.  */
        if (SHIFT_IS_ERROR (shiftp, i))
          nodefault = 1;
           default rule.  */
        if (SHIFT_IS_ERROR (shiftp, i))
          nodefault = 1;

-       SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
+       bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i));

       }
 
       }
 

-  if (errp)
-    for (i = 0; i < errp->nerrs; i++)
-      if (errp->errs[i])
-       SETBIT (shiftset, errp->errs[i]);
+  for (i = 0; i < errp->nerrs; i++)
+    if (errp->errs[i])
+      bitset_set (shiftset, errp->errs[i]);

 
   if (state->nlookaheads == 1 && !nodefault)
     {
 
   if (state->nlookaheads == 1 && !nodefault)
     {

-      int k;

       int default_rule = LAruleno[state->lookaheadsp];
 
       int default_rule = LAruleno[state->lookaheadsp];
 

-      for (k = 0; k < tokensetsize; ++k)
-       lookaheadset[k] = LA (state->lookaheadsp)[k] & shiftset[k];
+      bitset_and (lookaheadset, LA[state->lookaheadsp], shiftset);

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

-       if (BITISSET (lookaheadset, i))
+       if (bitset_test (lookaheadset, i))

          fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),
          fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),

-                  tags[i], default_rule,
-                  tags[rule_table[default_rule].lhs]);
+                  escape (symbols[i]->tag), default_rule - 1,
+                  escape2 (symbols[rules[default_rule].lhs]->tag));

 
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
 
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),

-              default_rule, tags[rule_table[default_rule].lhs]);
+              default_rule - 1, escape (symbols[rules[default_rule].lhs]->tag));

     }
   else if (state->nlookaheads >= 1)
     {
     }
   else if (state->nlookaheads >= 1)
     {


@@ -224,13 +236,12 @@ print_reductions (FILE *out, state_t *state)
        for (i = 0; i < state->nlookaheads; ++i)
          {
            int count = 0;
        for (i = 0; i < state->nlookaheads; ++i)
          {
            int count = 0;

-           int j, k;
+           int j;

 
 

-           for (k = 0; k < tokensetsize; ++k)
-             lookaheadset[k] = LA (state->lookaheadsp + i)[k] & ~shiftset[k];
+           bitset_andn (lookaheadset, LA[state->lookaheadsp + i], shiftset);

 
            for (j = 0; j < ntokens; j++)
 
            for (j = 0; j < ntokens; j++)

-             if (BITISSET (lookaheadset, j))
+             if (bitset_test (lookaheadset, j))

                count++;
 
            if (count > cmax)
                count++;
 
            if (count > cmax)


@@ -240,62 +251,59 @@ print_reductions (FILE *out, state_t *state)
                default_rule = LAruleno[state->lookaheadsp + i];
              }
 
                default_rule = LAruleno[state->lookaheadsp + i];
              }
 

-           for (k = 0; k < tokensetsize; ++k)
-             shiftset[k] |= lookaheadset[k];
+           bitset_or (shiftset, shiftset, lookaheadset);

          }
 
          }
 

-      for (i = 0; i < tokensetsize; i++)
-       shiftset[i] = 0;
+      bitset_zero (shiftset);

 
       for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
        if (!SHIFT_IS_DISABLED (shiftp, i))
 
       for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
        if (!SHIFT_IS_DISABLED (shiftp, i))

-         SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
+         bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i));

 
       for (i = 0; i < ntokens; i++)
        {
          int j;
          int defaulted = 0;
 
       for (i = 0; i < ntokens; i++)
        {
          int j;
          int defaulted = 0;

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

 
          for (j = 0; j < state->nlookaheads; ++j)
 
          for (j = 0; j < state->nlookaheads; ++j)

-           {
-             if (BITISSET (LA (state->lookaheadsp + j), i))
-               {
-                 if (count == 0)
-                   {
-                     if (state->lookaheadsp + j != default_LA)
-                       fprintf (out,
-                                _("    %-4s\treduce using rule %d (%s)\n"),
-                                tags[i],
-                                LAruleno[state->lookaheadsp + j],
-                                tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
-                     else
-                       defaulted = 1;
-
-                     count++;
-                   }
-                 else
-                   {
-                     if (defaulted)
-                       fprintf (out,
-                                _("    %-4s\treduce using rule %d (%s)\n"),
-                                tags[i],
-                                LAruleno[default_LA],
-                                tags[rule_table[LAruleno[default_LA]].lhs]);
-                     defaulted = 0;
+           if (bitset_test (LA[state->lookaheadsp + j], i))
+             {
+               if (count == 0)
+                 {
+                   if (state->lookaheadsp + j != default_LA)

                      fprintf (out,
                      fprintf (out,

-                              _("    %-4s\t[reduce using rule %d (%s)]\n"),
-                              tags[i],
-                              LAruleno[state->lookaheadsp + j],
-                              tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
-                   }
-               }
-           }
+                              _("    %-4s\treduce using rule %d (%s)\n"),
+                              escape (symbols[i]->tag),
+                              LAruleno[state->lookaheadsp + j] - 1,
+                              escape2 (symbols[rules[LAruleno[state->lookaheadsp + j]].lhs]->tag));
+                   else
+                     defaulted = 1;
+
+                   count++;
+                 }
+               else
+                 {
+                   if (defaulted)
+                     fprintf (out,
+                              _("    %-4s\treduce using rule %d (%s)\n"),
+                              escape (symbols[i]->tag),
+                              LAruleno[default_LA] - 1,
+                              escape2 (symbols[rules[LAruleno[default_LA]].lhs]->tag));
+                   defaulted = 0;
+                   fprintf (out,
+                            _("    %-4s\t[reduce using rule %d (%s)]\n"),
+                            escape (symbols[i]->tag),
+                            LAruleno[state->lookaheadsp + j] - 1,
+                            escape2 (symbols[rules[LAruleno[state->lookaheadsp + j]].lhs]->tag));
+                 }
+             }

        }
 
       if (default_LA >= 0)
        fprintf (out, _("    $default\treduce using rule %d (%s)\n"),
        }
 
       if (default_LA >= 0)
        fprintf (out, _("    $default\treduce using rule %d (%s)\n"),

-                default_rule, tags[rule_table[default_rule].lhs]);
+                default_rule - 1,
+                escape (symbols[rules[default_rule].lhs]->tag));

     }
 }
 
     }
 }
 


@@ -306,19 +314,18 @@ print_actions (FILE *out, state_t *state)
   reductions *redp = state->reductions;
   shifts *shiftp = state->shifts;
 
   reductions *redp = state->reductions;
   shifts *shiftp = state->shifts;
 

-  if (!shiftp->nshifts && !redp)
+  if (shiftp->nshifts == 0 && redp->nreds == 0)

     {
       if (final_state == state->number)
     {
       if (final_state == state->number)

-       fprintf (out, _("    $default\taccept\n"));
+       fprintf (out, _("    $default\taccept\n"));

       else
       else

-       fprintf (out, _("    NO ACTIONS\n"));
+       fprintf (out, _("    NO ACTIONS\n"));

       return;
     }
 
   print_shifts (out, state);
   print_errs (out, state);
       return;
     }
 
   print_shifts (out, state);
   print_errs (out, state);

-  if (redp)
-    print_reductions (out, state);
+  print_reductions (out, state);

   print_gotos (out, state);
 }
 
   print_gotos (out, state);
 }
 


@@ -360,14 +367,14 @@ print_grammar (FILE *out)
   fprintf (out, "  %s\n", _("Number, Line, Rule"));
   for (i = 1; i <= nrules; i++)
     /* Don't print rules disabled in reduce_grammar_tables.  */
   fprintf (out, "  %s\n", _("Number, Line, Rule"));
   for (i = 1; i <= nrules; i++)
     /* Don't print rules disabled in reduce_grammar_tables.  */

-    if (rule_table[i].useful)
+    if (rules[i].useful)

       {
        fprintf (out, _("  %3d %3d %s ->"),
       {
        fprintf (out, _("  %3d %3d %s ->"),

-                i, rule_table[i].line, tags[rule_table[i].lhs]);
-       rule = &ritem[rule_table[i].rhs];
-       if (*rule > 0)
-         while (*rule > 0)
-           fprintf (out, " %s", tags[*rule++]);
+                i - 1, rules[i].line, escape (symbols[rules[i].lhs]->tag));
+       rule = &ritem[rules[i].rhs];
+       if (*rule >= 0)
+         while (*rule >= 0)
+           fprintf (out, " %s", escape (symbols[*rule++]->tag));

        else
          fprintf (out, " /* %s */", _("empty"));
        fputc ('\n', out);
        else
          fprintf (out, " /* %s */", _("empty"));
        fputc ('\n', out);


@@ -377,23 +384,21 @@ print_grammar (FILE *out)
 
   /* TERMINAL (type #) : rule #s terminal is on RHS */
   fprintf (out, "%s\n\n", _("Terminals, with rules where they appear"));
 
   /* TERMINAL (type #) : rule #s terminal is on RHS */
   fprintf (out, "%s\n\n", _("Terminals, with rules where they appear"));

-  fprintf (out, "%s (-1)\n", tags[0]);
-

   for (i = 0; i <= max_user_token_number; i++)
     if (token_translations[i] != 2)
       {
        buffer[0] = 0;
   for (i = 0; i <= max_user_token_number; i++)
     if (token_translations[i] != 2)
       {
        buffer[0] = 0;

-       column = strlen (tags[token_translations[i]]);
-       fputs (tags[token_translations[i]], out);
+       column = strlen (escape (symbols[token_translations[i]]->tag));
+       fputs (escape (symbols[token_translations[i]]->tag), out);

        END_TEST (50);
        sprintf (buffer, " (%d)", i);
 
        for (j = 1; j <= nrules; j++)
        END_TEST (50);
        sprintf (buffer, " (%d)", i);
 
        for (j = 1; j <= nrules; j++)

-         for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++)
+         for (rule = &ritem[rules[j].rhs]; *rule >= 0; rule++)

            if (*rule == token_translations[i])
              {
                END_TEST (65);
            if (*rule == token_translations[i])
              {
                END_TEST (65);

-               sprintf (buffer + strlen (buffer), " %d", j);
+               sprintf (buffer + strlen (buffer), " %d", j - 1);

                break;
              }
        fprintf (out, "%s\n", buffer);
                break;
              }
        fprintf (out, "%s\n", buffer);


@@ -408,9 +413,9 @@ print_grammar (FILE *out)
 
       for (j = 1; j <= nrules; j++)
        {
 
       for (j = 1; j <= nrules; j++)
        {

-         if (rule_table[j].lhs == i)
+         if (rules[j].lhs == i)

            left_count++;
            left_count++;

-         for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++)
+         for (rule = &ritem[rules[j].rhs]; *rule >= 0; rule++)

            if (*rule == i)
              {
                right_count++;
            if (*rule == i)
              {
                right_count++;


@@ -419,8 +424,8 @@ print_grammar (FILE *out)
        }
 
       buffer[0] = 0;
        }
 
       buffer[0] = 0;

-      fputs (tags[i], out);
-      column = strlen (tags[i]);
+      fputs (escape (symbols[i]->tag), out);
+      column = strlen (escape (symbols[i]->tag));

       sprintf (buffer, " (%d)", i);
       END_TEST (0);
 
       sprintf (buffer, " (%d)", i);
       END_TEST (0);
 


@@ -432,8 +437,8 @@ print_grammar (FILE *out)
          for (j = 1; j <= nrules; j++)
            {
              END_TEST (65);
          for (j = 1; j <= nrules; j++)
            {
              END_TEST (65);

-             if (rule_table[j].lhs == i)
-               sprintf (buffer + strlen (buffer), " %d", j);
+             if (rules[j].lhs == i)
+               sprintf (buffer + strlen (buffer), " %d", j - 1);

            }
        }
 
            }
        }
 


@@ -445,11 +450,11 @@ print_grammar (FILE *out)
          sprintf (buffer + strlen (buffer), _(" on right:"));
          for (j = 1; j <= nrules; j++)
            {
          sprintf (buffer + strlen (buffer), _(" on right:"));
          for (j = 1; j <= nrules; j++)
            {

-             for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++)
+             for (rule = &ritem[rules[j].rhs]; *rule >= 0; rule++)

                if (*rule == i)
                  {
                    END_TEST (65);
                if (*rule == i)
                  {
                    END_TEST (65);

-                   sprintf (buffer + strlen (buffer), " %d", j);
+                   sprintf (buffer + strlen (buffer), " %d", j - 1);

                    break;
                  }
            }
                    break;
                  }
            }


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

-  int i;
+  size_t 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.  */


@@ -484,14 +489,16 @@ print_results (void)
      only its kernel.  Requires to run closure, which need memory
      allocation/deallocation.  */
   if (trace_flag)
      only its kernel.  Requires to run closure, which need memory
      allocation/deallocation.  */
   if (trace_flag)

-    new_closure (nitems);
+    new_closure (nritems);

   /* Storage for print_reductions.  */
   /* Storage for print_reductions.  */

-  shiftset = XCALLOC (unsigned, tokensetsize);
-  lookaheadset = XCALLOC (unsigned, tokensetsize);
+  shiftset =  bitset_create (ntokens, BITSET_FIXED);
+  bitset_zero (shiftset);
+  lookaheadset = bitset_create (ntokens, BITSET_FIXED);
+  bitset_zero (lookaheadset);

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

-    print_state (out, state_table[i]);
-  free (shiftset);
-  free (lookaheadset);
+    print_state (out, states[i]);
+  bitset_free (shiftset);
+  bitset_free (lookaheadset);

   if (trace_flag)
     free_closure ();
 
   if (trace_flag)
     free_closure ();