Avoid gcc -Wundef warnings reported by Gerald Pfeifer in

[bison.git] / src / print.c

diff --git a/src/print.c b/src/print.c
index 021cb4837ac6fcc12e638417f84827e94f2de159..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;


@@ -48,16 +51,30 @@ print_token (int extnum, int token)
 #endif
 
 \f
 #endif
 
 \f

+
+/*---------------------------------------.
+| *WIDTH := max (*WIDTH, strlen (STR)).  |
+`---------------------------------------*/
+
+static void
+max_length (size_t *width, const char *str)
+{
+  size_t len = strlen (str);
+  if (len > *width)
+    *width = len;
+}
+

 /*--------------------------------.
 | Report information on a state.  |
 `--------------------------------*/
 
 static void
 /*--------------------------------.
 | Report information on a state.  |
 `--------------------------------*/
 
 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;
+  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)


@@ -67,268 +84,348 @@ print_core (FILE *out, state_t *state)
       snritems = nritemset;
     }
 
       snritems = nritemset;
     }
 

-  if (snritems)
-    {
-      for (i = 0; i < snritems; i++)
-       {
-         item_number_t *sp;
-         item_number_t *sp1;
-         int rule;
+  if (!snritems)
+    return;

 
 

-         sp1 = sp = ritem + sitems[i];
+  fputc ('\n', out);

 
 

-         while (*sp >= 0)
-           sp++;
+  for (i = 0; i < snritems; i++)
+    {
+      item_number *sp;
+      item_number *sp1;
+      rule_number r;

 
 

-         rule = -(*sp);
-         fprintf (out, "    %s  ->  ", symbol_tag_get (rules[rule].lhs));
+      sp1 = sp = ritem + sitems[i];

 
 

-         for (sp = rules[rule].rhs; sp < sp1; sp++)
-           fprintf (out, "%s ", symbol_tag_get (symbols[*sp]));
+      while (*sp >= 0)
+       sp++;

 
 

-         fputc ('.', out);
+      r = item_number_as_rule_number (*sp);

 
 

-         for (/* Nothing */; *sp >= 0; ++sp)
-           fprintf (out, " %s", symbol_tag_get (symbols[*sp]));
+      rule_lhs_print (&rules[r], previous_lhs, out);
+      previous_lhs = rules[r].lhs;

 
 

-         /* Display the lookaheads?  */
-         if (report_flag & report_lookaheads)
-           state_rule_lookaheads_print (state, &rules[rule], out);
+      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, _("   (rule %d)"), rule - 1);
-         fputc ('\n', out);
-       }
+      /* Display the lookaheads?  */
+      if (report_flag & report_lookaheads)
+       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 S on |
+| OUT.                                                        |
+`------------------------------------------------------------*/
+

 static void
 static void

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

 {
 {

+  transitions *trans = s->transitions;
+  size_t width = 0;

   int i;
   int i;

-  shifts_t *shiftp = state->shifts;

 
 

-  for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
-    if (!SHIFT_IS_DISABLED (shiftp, i))
+  /* Compute the width of the lookaheads column.  */
+  for (i = 0; i < trans->num; i++)
+    if (!TRANSITION_IS_DISABLED (trans, i)
+       && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)

       {
       {

-       state_number_t state1 = shiftp->shifts[i];
-       symbol_number_t symbol = states[state1]->accessing_symbol;
-       fprintf (out,
-                _("    %-4s\tshift, and go to state %d\n"),
-                symbol_tag_get (symbols[symbol]), state1);
+       symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
+       max_length (&width, sym->tag);

       }
 
       }
 

-  if (i > 0)
-    fputc ('\n', out);
+  /* Nothing to report. */
+  if (!width)
+    return;
+
+  fputc ('\n', out);
+  width += 2;
+
+  /* Report lookaheads and shifts.  */
+  for (i = 0; i < trans->num; i++)
+    if (!TRANSITION_IS_DISABLED (trans, i)
+       && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)
+      {
+       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)
+         fprintf (out, _("shift, and go to state %d\n"), s1->number);
+       else
+         fprintf (out, _("go to state %d\n"), s1->number);
+      }

 }
 
 
 }
 
 

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

-  for (i = 0; i < errp->nerrs; ++i)
-    if (errp->errs[i])
-      fprintf (out, _("    %-4s\terror (nonassociative)\n"),
-              symbol_tag_get (symbols[errp->errs[i]]));
+  /* Compute the width of the lookaheads column.  */
+  for (i = 0; i < errp->num; ++i)
+    if (errp->symbols[i])
+      max_length (&width, errp->symbols[i]->tag);
+
+  /* Nothing to report. */
+  if (!width)
+    return;
+
+  fputc ('\n', out);
+  width += 2;

 
 

-  if (i > 0)
-    fputc ('\n', out);
+  /* Report lookaheads and errors.  */
+  for (i = 0; i < errp->num; ++i)
+    if (errp->symbols[i])
+      {
+       const char *tag = errp->symbols[i]->tag;
+       int j;
+       fprintf (out, "    %s", tag);
+       for (j = width - strlen (tag); j > 0; --j)
+         fputc (' ', out);
+       fputs (_("error (nonassociative)\n"), out);
+      }

 }
 
 
 }
 
 

-static void
-print_gotos (FILE *out, state_t *state)
+/*-------------------------------------------------------------.
+| Return the default rule of S if it has one, NULL otherwise.  |
+`-------------------------------------------------------------*/
+
+static rule *
+state_default_rule (state *s)

 {
 {

+  reductions *reds = s->reductions;
+  rule *default_rule = NULL;
+  int cmax = 0;

   int i;
   int i;

-  shifts_t *shiftp = state->shifts;

 
 

-  for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
-    /* Skip token shifts.  */;
+  /* No need for a lookahead.  */
+  if (s->consistent)
+    return reds->rules[0];

 
 

-  if (i < shiftp->nshifts)
+  /* 1. Each reduction is possibly masked by the lookaheads on which
+     we shift (S/R conflicts)...  */
+  bitset_zero (shiftset);
+  {
+    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 (TRANSITION_IS_ERROR (trans, i))
+         return NULL;
+       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).  */
+  {
+    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 < reds->num; ++i)

     {
     {

-      for (; i < shiftp->nshifts; i++)
-       if (!SHIFT_IS_DISABLED (shiftp, i))
-         {
-           state_number_t state1 = shiftp->shifts[i];
-           symbol_number_t symbol = states[state1]->accessing_symbol;
-           fprintf (out, _("    %-4s\tgo to state %d\n"),
-                    symbol_tag_get (symbols[symbol]), state1);
-         }
+      int count = 0;

 
 

-      fputc ('\n', out);
+      /* How many non-masked lookaheads are there for this reduction?
+        */
+      bitset_andn (lookaheadset, reds->lookaheads[i], shiftset);
+      count = bitset_count (lookaheadset);
+
+      if (count > cmax)
+       {
+         cmax = count;
+         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).
+        */
+      bitset_or (shiftset, shiftset, reds->lookaheads[i]);

     }
     }

+
+  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).                                                     |
+`--------------------------------------------------------------------*/
+

 static void
 static void

-print_reductions (FILE *out, state_t *state)
+print_reduction (FILE *out, size_t width,
+                const char *lookahead,
+                rule *r, bool enabled)

 {
 {

-  int i;
-  shifts_t *shiftp = state->shifts;
-  reductions_t *redp = state->reductions;
-  errs_t *errp = state->errs;
-  int nodefault = 0;
+  int j;
+  fprintf (out, "    %s", lookahead);
+  for (j = width - strlen (lookahead); j > 0; --j)
+    fputc (' ', out);
+  if (!enabled)
+    fputc ('[', out);
+  if (r->number)
+    fprintf (out, _("reduce using rule %d (%s)"), r->number, r->lhs->tag);
+  else
+    fprintf (out, _("accept"));
+  if (!enabled)
+    fputc (']', out);
+  fputc ('\n', out);
+}

 
 

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

 
 

-  if (state->consistent)
-    {
-      int rule = redp->rules[0];
-      symbol_number_t symbol = rules[rule].lhs->number;
-      fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
-              rule - 1, symbol_tag_get (symbols[symbol]));
-      return;
-    }
+/*-------------------------------------------.
+| Report on OUT the reduction actions of S.  |
+`-------------------------------------------*/

 
 

-  bitset_zero (shiftset);
+static void
+print_reductions (FILE *out, state *s)
+{
+  transitions *trans = s->transitions;
+  reductions *reds = s->reductions;
+  rule *default_rule = NULL;
+  size_t width = 0;
+  int i, j;

 
 

-  for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
-    if (!SHIFT_IS_DISABLED (shiftp, i))
-      {
-       /* if this state has a shift for the error token, don't use a
-          default rule.  */
-       if (SHIFT_IS_ERROR (shiftp, i))
-         nodefault = 1;
-       bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i));
-      }
+  if (reds->num == 0)
+    return;

 
 

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

 
 

-  if (state->nlookaheads == 1 && !nodefault)
-    {
-      rule_t *default_rule = state->lookaheads_rule[0];
+  bitset_zero (shiftset);
+  FOR_EACH_SHIFT (trans, i)
+    bitset_set (shiftset, TRANSITION_SYMBOL (trans, i));

 
 

-      bitset_and (lookaheadset, state->lookaheads[0], shiftset);
+  /* Compute the width of the lookaheads column.  */
+  if (default_rule)
+    width = strlen (_("$default"));

 
 

-      BITSET_EXECUTE (lookaheadset, 0, i,
+  if (reds->lookaheads)
+    for (i = 0; i < ntokens; i++)

       {
       {

-       fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),
-                symbol_tag_get (symbols[i]),
-                default_rule->number - 1,
-                symbol_tag_get_n (default_rule->lhs, 1));
-      });
-      fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
-              default_rule->number - 1,
-              symbol_tag_get (default_rule->lhs));
-    }
-  else if (state->nlookaheads >= 1)
-    {
-      int cmax = 0;
-      int default_LA = -1;
-      rule_t *default_rule = NULL;
-
-      if (!nodefault)
-       for (i = 0; i < state->nlookaheads; ++i)
-         {
-           int count = 0;
+       int count = bitset_test (shiftset, i);

 
 

-           bitset_andn (lookaheadset, state->lookaheads[i], shiftset);
-           count = bitset_count (lookaheadset);
-
-           if (count > cmax)
-             {
-               cmax = count;
-               default_LA = i;
-               default_rule = state->lookaheads_rule[i];
-             }
-
-           bitset_or (shiftset, shiftset, lookaheadset);
-         }
+       for (j = 0; j < reds->num; ++j)
+         if (bitset_test (reds->lookaheads[j], i))
+           {
+             if (count == 0)
+               {
+                 if (reds->rules[j] != default_rule)
+                   max_length (&width, symbols[i]->tag);
+                 count++;
+               }
+             else
+               {
+                 max_length (&width, symbols[i]->tag);
+               }
+           }
+      }

 
 

-      bitset_zero (shiftset);
+  /* Nothing to report. */
+  if (!width)
+    return;

 
 

-      for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
-       if (!SHIFT_IS_DISABLED (shiftp, i))
-         bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i));
+  fputc ('\n', out);
+  width += 2;

 
 

-      for (i = 0; i < ntokens; i++)
-       {
-         int j;
-         int defaulted = 0;
-         int count = bitset_test (shiftset, i);
+  /* Report lookaheads (or $default) and reductions.  */
+  if (reds->lookaheads)
+    for (i = 0; i < ntokens; i++)
+      {
+       int defaulted = 0;
+       int count = bitset_test (shiftset, i);

 
 

-         for (j = 0; j < state->nlookaheads; ++j)
-           if (bitset_test (state->lookaheads[j], i))
-             {
-               if (count == 0)
-                 {
-                   if (j != default_LA)
-                     fprintf (out,
-                              _("    %-4s\treduce using rule %d (%s)\n"),
-                              symbol_tag_get (symbols[i]),
-                              state->lookaheads_rule[j]->number - 1,
-                              symbol_tag_get_n (state->lookaheads_rule[j]->lhs, 1));
-                   else
-                     defaulted = 1;
-
-                   count++;
-                 }
-               else
-                 {
-                   if (defaulted)
-                     fprintf (out,
-                              _("    %-4s\treduce using rule %d (%s)\n"),
-                              symbol_tag_get (symbols[i]),
-                              state->lookaheads_rule[default_LA]->number - 1,
-                              symbol_tag_get_n (state->lookaheads_rule[default_LA]->lhs, 1));
-                   defaulted = 0;
-                   fprintf (out,
-                            _("    %-4s\t[reduce using rule %d (%s)]\n"),
-                            symbol_tag_get (symbols[i]),
-                            state->lookaheads_rule[j]->number - 1,
-                            symbol_tag_get_n (state->lookaheads_rule[j]->lhs, 1));
-                 }
-             }
-       }
+       for (j = 0; j < reds->num; ++j)
+         if (bitset_test (reds->lookaheads[j], i))
+           {
+             if (count == 0)
+               {
+                 if (reds->rules[j] != default_rule)
+                   print_reduction (out, width,
+                                    symbols[i]->tag,
+                                    reds->rules[j], true);
+                 else
+                   defaulted = 1;
+                 count++;
+               }
+             else
+               {
+                 if (defaulted)
+                   print_reduction (out, width,
+                                    symbols[i]->tag,
+                                    default_rule, true);
+                 defaulted = 0;
+                 print_reduction (out, width,
+                                  symbols[i]->tag,
+                                  reds->rules[j], false);
+               }
+           }
+      }

 
 

-      if (default_LA >= 0)
-       fprintf (out, _("    $default\treduce using rule %d (%s)\n"),
-                default_rule->number - 1,
-                symbol_tag_get (default_rule->lhs));
-    }
+  if (default_rule)
+    print_reduction (out, width,
+                    _("$default"), default_rule, true);

 }
 
 
 }
 
 

+/*--------------------------------------------------------------.
+| Report on OUT all the actions (shifts, gotos, reductions, and |
+| explicit erros from %nonassoc) of S.                          |
+`--------------------------------------------------------------*/
+

 static void
 static void

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

 {
 {

-  reductions_t *redp = state->reductions;
-  shifts_t *shiftp = state->shifts;
+  /* Print shifts.  */
+  print_transitions (s, out, true);
+  print_errs (out, s);
+  print_reductions (out, s);
+  /* Print gotos.  */
+  print_transitions (s, out, false);
+}

 
 

-  if (shiftp->nshifts == 0 && redp->nreds == 0)
-    {
-      if (state->number == final_state->number)
-       fprintf (out, _("    $default\taccept\n"));
-      else
-       fprintf (out, _("    NO ACTIONS\n"));
-      return;
-    }

 
 

-  print_shifts (out, state);
-  print_errs (out, state);
-  print_reductions (out, state);
-  print_gotos (out, state);
-}
+/*----------------------------------.
+| 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)

 {
 {

-  fprintf (out, _("state %d"), state->number);
-  fputs ("\n\n", out);
-  print_core (out, state);
-  print_actions (out, state);
-  if ((report_flag & report_solved_conflicts)
-      && state->solved_conflicts)
-    fputs (state->solved_conflicts, out);

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

+  fprintf (out, _("state %d"), s->number);
+  fputc ('\n', 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
 /*-----------------------------------------.


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


@@ -360,9 +457,9 @@ print_grammar (FILE *out)
   for (i = 0; i < max_user_token_number + 1; i++)
     if (token_translations[i] != undeftoken->number)
       {
   for (i = 0; i < max_user_token_number + 1; i++)
     if (token_translations[i] != undeftoken->number)
       {

-       const char *tag = symbol_tag_get (symbols[token_translations[i]]);
-       rule_number_t r;
-       item_number_t *rhsp;
+       const char *tag = symbols[token_translations[i]]->tag;
+       rule_number r;
+       item_number *rhsp;

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


@@ -370,12 +467,12 @@ print_grammar (FILE *out)
        END_TEST (50);
        sprintf (buffer, " (%d)", i);
 
        END_TEST (50);
        sprintf (buffer, " (%d)", i);
 

-       for (r = 1; r < nrules + 1; r++)
+       for (r = 0; r < nrules; r++)

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

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

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


@@ -387,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;
-      const char *tag = symbol_tag_get (symbols[i]);
+      rule_number r;
+      const char *tag = symbols[i]->tag;

 
 

-      for (r = 1; r < nrules + 1; r++)
+      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++)


@@ -414,11 +511,11 @@ print_grammar (FILE *out)
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on left:"));
 
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on left:"));
 

-         for (r = 1; r < nrules + 1; r++)
+         for (r = 0; r < nrules; r++)

            {
              END_TEST (65);
              if (rules[r].lhs->number == i)
            {
              END_TEST (65);
              if (rules[r].lhs->number == i)

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

            }
        }
 
            }
        }
 


@@ -428,33 +525,34 @@ print_grammar (FILE *out)
            sprintf (buffer + strlen (buffer), ",");
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on right:"));
            sprintf (buffer + strlen (buffer), ",");
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on right:"));

-         for (r = 1; r < nrules + 1; r++)
+         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)
                  {
                    END_TEST (65);
              for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
                if (item_number_as_symbol_number (*rhsp) == i)
                  {
                    END_TEST (65);

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

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

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

 }
 \f
 void
 print_results (void)
 {
 }
 \f
 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);