* data/yacc.c: (b4_lex_param): Corrected for the case where

[bison.git] / src / print.c

diff --git a/src/print.c b/src/print.c
index 12466c905e4c4de54f55aba2a7fb9c9ae9e35c19..dcf7df3a9941c2561d1fe0a98df1c345dca51b15 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

    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.


@@ -21,20 +22,22 @@
 
 
 #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 shiftset;
 static bitset lookaheadset;


@@ -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;
 {
   int i;

-  item_number_t *sitems = state->items;
-  int snritems   = state->nitems;
-  symbol_t *previous_lhs = NULL;
+  item_number *sitems = s->items;
+  int 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,21 +91,21 @@ 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);
       fputs (" .", out);
       for (/* Nothing */; *sp >= 0; ++sp)


@@ -110,32 +113,32 @@ print_core (FILE *out, state_t *state)
 
       /* Display the lookaheads?  */
       if (report_flag & report_lookaheads)
 
       /* Display the lookaheads?  */
       if (report_flag & report_lookaheads)

-       state_rule_lookaheads_print (state, &rules[rule], out);
+       state_rule_lookaheads_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;
 
   /* Compute the width of the lookaheads column.  */
   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)
+  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. */


@@ -146,34 +149,34 @@ print_transitions (state_t *state, FILE *out, bool display_transitions_p)
   width += 2;
 
   /* Report lookaheads and shifts.  */
   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)
+  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;
 


@@ -203,66 +206,65 @@ 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;
 
   /* No need for a lookahead.  */
   int cmax = 0;
   int i;
 
   /* No need for a lookahead.  */

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

 
   /* 1. Each reduction is possibly masked by the lookaheads on which
      we shift (S/R conflicts)...  */
   bitset_zero (shiftset);
   {
 
   /* 1. Each reduction is possibly masked by the lookaheads on which
      we shift (S/R conflicts)...  */
   bitset_zero (shiftset);
   {

-    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 (shiftset, TRANSITION_SYMBOL (trans, i));

       }
   }
 
   /* 2. Each reduction is possibly masked by the lookaheads on which
      we raise an error (due to %nonassoc).  */
   {
       }
   }
 
   /* 2. Each reduction is possibly masked by the lookaheads on which
      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])
        bitset_set (shiftset, errp->symbols[i]->number);
   }
 
     for (i = 0; i < errp->num; i++)
       if (errp->symbols[i])
        bitset_set (shiftset, errp->symbols[i]->number);
   }
 

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

     {
       int count = 0;
 
       /* How many non-masked lookaheads are there for this reduction?
         */
     {
       int count = 0;
 
       /* How many non-masked lookaheads are there for this reduction?
         */

-      bitset_andn (lookaheadset, redp->lookaheads[i], shiftset);
+      bitset_andn (lookaheadset, reds->lookaheads[i], shiftset);

       count = bitset_count (lookaheadset);
 
       if (count > cmax)
        {
          cmax = count;
       count = bitset_count (lookaheadset);
 
       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 (shiftset, shiftset, reds->lookaheads[i]);

     }
 
   return default_rule;
     }
 
   return default_rule;


@@ -278,7 +280,7 @@ state_default_rule (state_t *state)
 static void
 print_reduction (FILE *out, size_t width,
                 const char *lookahead,
 static void
 print_reduction (FILE *out, size_t width,
                 const char *lookahead,

-                rule_t *rule, bool enabled)
+                rule *r, bool enabled)

 {
   int j;
   fprintf (out, "    %s", lookahead);
 {
   int j;
   fprintf (out, "    %s", lookahead);


@@ -286,9 +288,8 @@ print_reduction (FILE *out, size_t width,
     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,43 +298,43 @@ 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);
 
   bitset_zero (shiftset);

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

 
   /* Compute the width of the lookaheads column.  */
   if (default_rule)
     width = strlen (_("$default"));
 
 
   /* Compute the width of the lookaheads column.  */
   if (default_rule)
     width = strlen (_("$default"));
 

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

     for (i = 0; i < ntokens; i++)
       {
        int count = bitset_test (shiftset, i);
 
     for (i = 0; i < ntokens; i++)
       {
        int count = bitset_test (shiftset, 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->lookaheads[j], i))

            {
              if (count == 0)
                {
            {
              if (count == 0)
                {

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

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


@@ -352,21 +353,21 @@ print_reductions (FILE *out, state_t *state)
   width += 2;
 
   /* Report lookaheads (or $default) and reductions.  */
   width += 2;
 
   /* Report lookaheads (or $default) and reductions.  */

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

     for (i = 0; i < ntokens; i++)
       {
        int defaulted = 0;
        int count = bitset_test (shiftset, i);
 
     for (i = 0; i < ntokens; i++)
       {
        int defaulted = 0;
        int count = bitset_test (shiftset, 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->lookaheads[j], i))

            {
              if (count == 0)
                {
            {
              if (count == 0)
                {

-                 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
                    defaulted = 1;
                  count++;
                  else
                    defaulted = 1;
                  count++;


@@ -376,53 +377,55 @@ print_reductions (FILE *out, state_t *state)
                  if (defaulted)
                    print_reduction (out, width,
                                     symbols[i]->tag,
                  if (defaulted)
                    print_reduction (out, width,
                                     symbols[i]->tag,

-                                    default_rule, TRUE);
+                                    default_rule, true);

                  defaulted = 0;
                  print_reduction (out, width,
                                   symbols[i]->tag,
                  defaulted = 0;
                  print_reduction (out, width,
                                   symbols[i]->tag,

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

                }
            }
       }
 
   if (default_rule)
     print_reduction (out, width,
                }
            }
       }
 
   if (default_rule)
     print_reduction (out, width,

-                    _("$default"), default_rule, TRUE);
+                    _("$default"), default_rule, true);

 }
 
 
 /*--------------------------------------------------------------.
 | 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)
-    fputs (state->solved_conflicts, out);
+  print_core (out, s);
+  print_actions (out, s);
+  if ((report_flag & report_solved_conflicts) && s->solved_conflicts)
+    {
+      fputc ('\n', out);
+      fputs (s->solved_conflicts, out);
+    }

 }
 \f
 /*-----------------------------------------.
 }
 \f
 /*-----------------------------------------.


@@ -443,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;
 


@@ -455,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);


@@ -481,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++)


@@ -524,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)
                  {


@@ -541,13 +544,15 @@ 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.  */
   FILE *out = xfopen (spec_verbose_file, "w");
 
   reduce_output (out);
 
   /* We used to use just .out if SPEC_NAME_PREFIX (-p) was used, but
      that conflicts with Posix.  */
   FILE *out = xfopen (spec_verbose_file, "w");
 
   reduce_output (out);

+  grammar_rules_partial_print (out,
+                              _("Rules never reduced"), rule_never_reduced_p);

   conflicts_output (out);
 
   print_grammar (out);
   conflicts_output (out);
 
   print_grammar (out);