Enable declaration of default %printer/%destructor. Make the parser

[bison.git] / src / print.c

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

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

    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.


@@ -17,10 +17,10 @@
 
    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 <config.h>

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


@@ -40,7 +40,7 @@
 #include "symtab.h"
 
 static bitset shift_set;
 #include "symtab.h"
 
 static bitset shift_set;

-static bitset look_ahead_set;
+static bitset lookahead_set;

 
 #if 0
 static void
 
 #if 0
 static void


@@ -111,9 +111,9 @@ print_core (FILE *out, state *s)
       for (/* Nothing */; *sp >= 0; ++sp)
        fprintf (out, " %s", symbols[*sp]->tag);
 
       for (/* Nothing */; *sp >= 0; ++sp)
        fprintf (out, " %s", symbols[*sp]->tag);
 

-      /* Display the look-ahead tokens?  */
-      if (report_flag & report_look_ahead_tokens)
-       state_rule_look_ahead_tokens_print (s, &rules[r], out);
+      /* Display the lookahead tokens?  */
+      if (report_flag & report_lookahead_tokens)
+       state_rule_lookahead_tokens_print (s, &rules[r], out);

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


@@ -132,7 +132,7 @@ print_transitions (state *s, FILE *out, bool display_transitions_p)
   size_t width = 0;
   int i;
 
   size_t width = 0;
   int i;
 

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

   for (i = 0; i < trans->num; i++)
     if (!TRANSITION_IS_DISABLED (trans, i)
        && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)
   for (i = 0; i < trans->num; i++)
     if (!TRANSITION_IS_DISABLED (trans, i)
        && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)


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

-  /* Report look-ahead tokens and shifts.  */
+  /* Report lookahead tokens and shifts.  */

   for (i = 0; i < trans->num; i++)
     if (!TRANSITION_IS_DISABLED (trans, i)
        && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)
   for (i = 0; i < trans->num; i++)
     if (!TRANSITION_IS_DISABLED (trans, i)
        && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)


@@ -180,7 +180,7 @@ print_errs (FILE *out, state *s)
   size_t width = 0;
   int i;
 
   size_t width = 0;
   int i;
 

-  /* Compute the width of the look-ahead token column.  */
+  /* Compute the width of the lookahead 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);


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

-  /* Report look-ahead tokens and errors.  */
+  /* Report lookahead 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])
       {


@@ -218,11 +218,11 @@ state_default_rule (state *s)
   int cmax = 0;
   int i;
 
   int cmax = 0;
   int i;
 

-  /* No need for a look-ahead.  */
+  /* No need for a lookahead.  */

   if (s->consistent)
     return reds->rules[0];
 
   if (s->consistent)
     return reds->rules[0];
 

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

      we shift (S/R conflicts)...  */
   bitset_zero (shift_set);
   {
      we shift (S/R conflicts)...  */
   bitset_zero (shift_set);
   {


@@ -237,7 +237,7 @@ state_default_rule (state *s)
       }
   }
 
       }
   }
 

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

      we raise an error (due to %nonassoc).  */
   {
     errs *errp = s->errs;
      we raise an error (due to %nonassoc).  */
   {
     errs *errp = s->errs;


@@ -250,10 +250,10 @@ state_default_rule (state *s)
     {
       int count = 0;
 
     {
       int count = 0;
 

-      /* How many non-masked look-ahead tokens are there for this
+      /* How many non-masked lookahead tokens are there for this

         reduction?  */
         reduction?  */

-      bitset_andn (look_ahead_set, reds->look_ahead_tokens[i], shift_set);
-      count = bitset_count (look_ahead_set);
+      bitset_andn (lookahead_set, reds->lookahead_tokens[i], shift_set);
+      count = bitset_count (lookahead_set);

 
       if (count > cmax)
        {
 
       if (count > cmax)
        {


@@ -264,27 +264,27 @@ state_default_rule (state *s)
       /* 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 (shift_set, shift_set, reds->look_ahead_tokens[i]);
+      bitset_or (shift_set, shift_set, reds->lookahead_tokens[i]);

     }
 
   return default_rule;
 }
 
 
     }
 
   return default_rule;
 }
 
 

-/*--------------------------------------------------------------------------.
-| 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).                                                           |
-`--------------------------------------------------------------------------*/
+/*-------------------------------------------------------------------------.
+| Report a reduction of RULE on LOOKAHEAD_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 *look_ahead_token,
+                const char *lookahead_token,

                 rule *r, bool enabled)
 {
   int j;
                 rule *r, bool enabled)
 {
   int j;

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

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


@@ -320,17 +320,17 @@ print_reductions (FILE *out, state *s)
   FOR_EACH_SHIFT (trans, i)
     bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));
 
   FOR_EACH_SHIFT (trans, i)
     bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));
 

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

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

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

     for (i = 0; i < ntokens; i++)
       {
        bool count = bitset_test (shift_set, i);
 
        for (j = 0; j < reds->num; ++j)
     for (i = 0; i < ntokens; i++)
       {
        bool count = bitset_test (shift_set, i);
 
        for (j = 0; j < reds->num; ++j)

-         if (bitset_test (reds->look_ahead_tokens[j], i))
+         if (bitset_test (reds->lookahead_tokens[j], i))

            {
              if (! count)
                {
            {
              if (! count)
                {


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

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

     for (i = 0; i < ntokens; i++)
       {
        bool defaulted = false;
        bool count = bitset_test (shift_set, i);
 
        for (j = 0; j < reds->num; ++j)
     for (i = 0; i < ntokens; i++)
       {
        bool defaulted = false;
        bool count = bitset_test (shift_set, i);
 
        for (j = 0; j < reds->num; ++j)

-         if (bitset_test (reds->look_ahead_tokens[j], i))
+         if (bitset_test (reds->lookahead_tokens[j], i))

            {
              if (! count)
                {
            {
              if (! count)
                {


@@ -563,11 +563,11 @@ print_results (void)
     new_closure (nritems);
   /* Storage for print_reductions.  */
   shift_set =  bitset_create (ntokens, BITSET_FIXED);
     new_closure (nritems);
   /* Storage for print_reductions.  */
   shift_set =  bitset_create (ntokens, BITSET_FIXED);

-  look_ahead_set = bitset_create (ntokens, BITSET_FIXED);
+  lookahead_set = bitset_create (ntokens, BITSET_FIXED);

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

-  bitset_free (look_ahead_set);
+  bitset_free (lookahead_set);

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