]> git.saurik.com Git - bison.git/blobdiff - src/conflicts.c
* src/bison.simple: Remove YYERROR_VERBOSE using.
[bison.git] / src / conflicts.c
index 6b9cad07e7d504fd43201e82e61cbb74ed487ad8..b6bacb94cde8d4e9444eb43f6e57e49d540e2c92 100644 (file)
@@ -1,5 +1,5 @@
 /* Find and resolve or report look-ahead conflicts for bison,
 /* Find and resolve or report look-ahead conflicts for bison,
-   Copyright (C) 1984, 1989, 1992, 2000 Free Software Foundation, Inc.
+   Copyright 1984, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 
    02111-1307, USA.  */
 
 #include "system.h"
    02111-1307, USA.  */
 
 #include "system.h"
+#include "complain.h"
 #include "getargs.h"
 #include "getargs.h"
-#include "alloc.h"
 #include "files.h"
 #include "gram.h"
 #include "state.h"
 #include "files.h"
 #include "gram.h"
 #include "state.h"
+#include "lalr.h"
+#include "conflicts.h"
+#include "reader.h"
+#include "LR0.h"
 
 
+errs **err_table = NULL;
+/* -1 stands for not specified. */
+int expected_conflicts = -1;
+static char *conflicts = NULL;
 
 
-extern char **tags;
-extern int tokensetsize;
-extern char *consistent;
-extern short *accessing_symbol;
-extern shifts **shift_table;
-extern unsigned *LA;
-extern short *LAruleno;
-extern short *lookaheads;
-extern int fixed_outfiles;
-
-extern void initialize_conflicts PARAMS((void));
-extern void conflict_log PARAMS((void));
-extern void verbose_conflict_log PARAMS((void));
-extern void print_reductions PARAMS((int));
-extern void finalize_conflicts PARAMS((void));
-
-static void set_conflicts PARAMS((int));
-static void resolve_sr_conflict PARAMS((int, int));
-static void flush_shift PARAMS((int, int));
-static void log_resolution PARAMS((int, int, int, char *));
-static void total_conflicts PARAMS((void));
-static void count_sr_conflicts PARAMS((int));
-static void count_rr_conflicts PARAMS((int));
-
-char any_conflicts;
-errs **err_table;
-int expected_conflicts;
-static char *conflicts;
-
-
-static unsigned *shiftset;
-static unsigned *lookaheadset;
-static int src_total;
-static int rrc_total;
-static int src_count;
-static int rrc_count;
+static unsigned *shiftset = NULL;
+static unsigned *lookaheadset = NULL;
+\f
 
 
-
-void
-initialize_conflicts (void)
+static inline void
+log_resolution (int state, int LAno, int token, char *resolution)
 {
 {
-  register int i;
-/*  register errs *sp; JF unused */
-
-  conflicts = NEW2(nstates, char);
-  shiftset = NEW2(tokensetsize, unsigned);
-  lookaheadset = NEW2(tokensetsize, unsigned);
-
-  err_table = NEW2(nstates, errs *);
-
-  any_conflicts = 0;
-
-  for (i = 0; i < nstates; i++)
-    set_conflicts(i);
+  obstack_fgrow4 (&output_obstack,
+                 _("\
+Conflict in state %d between rule %d and token %s resolved as %s.\n"),
+                 state, LAruleno[LAno], tags[token], resolution);
 }
 
 
 }
 
 
+/*------------------------------------------------------------------.
+| Turn off the shift recorded for the specified token in the        |
+| specified state.  Used when we resolve a shift-reduce conflict in |
+| favor of the reduction.                                           |
+`------------------------------------------------------------------*/
+
 static void
 static void
-set_conflicts (int state)
+flush_shift (int state, int token)
 {
 {
-  register int i;
-  register int k;
-  register shifts *shiftp;
-  register unsigned *fp2;
-  register unsigned *fp3;
-  register unsigned *fp4;
-  register unsigned *fp1;
-  register int symbol;
+  shifts *shiftp;
+  int k, i;
 
 
-  if (consistent[state]) return;
+  shiftp = state_table[state].shift_table;
 
 
-  for (i = 0; i < tokensetsize; i++)
-    lookaheadset[i] = 0;
-
-  shiftp = shift_table[state];
   if (shiftp)
     {
       k = shiftp->nshifts;
       for (i = 0; i < k; i++)
        {
   if (shiftp)
     {
       k = shiftp->nshifts;
       for (i = 0; i < k; i++)
        {
-         symbol = accessing_symbol[shiftp->shifts[i]];
-         if (ISVAR(symbol)) break;
-         SETBIT(lookaheadset, symbol);
-       }
-    }
-
-  k = lookaheads[state + 1];
-  fp4 = lookaheadset + tokensetsize;
-
-  /* loop over all rules which require lookahead in this state */
-  /* first check for shift-reduce conflict, and try to resolve using precedence  */
-
-  for (i = lookaheads[state]; i < k; i++)
-    if (rprec[LAruleno[i]])
-      {
-       fp1 = LA + i * tokensetsize;
-       fp2 = fp1;
-       fp3 = lookaheadset;
-
-       while (fp3 < fp4)
-         {
-           if (*fp2++ & *fp3++)
-             {
-               resolve_sr_conflict(state, i);
-               break;
-             }
-         }
-      }
-
-  /* loop over all rules which require lookahead in this state */
-  /* Check for conflicts not resolved above.  */
-
-  for (i = lookaheads[state]; i < k; i++)
-    {
-      fp1 = LA + i * tokensetsize;
-      fp2 = fp1;
-      fp3 = lookaheadset;
-
-      while (fp3 < fp4)
-       {
-         if (*fp2++ & *fp3++)
-           {
-             conflicts[state] = 1;
-             any_conflicts = 1;
-           }
+         if (shiftp->shifts[i]
+             && token == state_table[shiftp->shifts[i]].accessing_symbol)
+           (shiftp->shifts[i]) = 0;
        }
        }
-
-      fp2 = fp1;
-      fp3 = lookaheadset;
-
-      while (fp3 < fp4)
-       *fp3++ |= *fp2++;
     }
 }
 
 
     }
 }
 
 
-
-/* Attempt to resolve shift-reduce conflict for one rule
-by means of precedence declarations.
-It has already been checked that the rule has a precedence.
-A conflict is resolved by modifying the shift or reduce tables
-so that there is no longer a conflict.  */
+/*------------------------------------------------------------------.
+| Attempt to resolve shift-reduce conflict for one rule by means of |
+| precedence declarations.  It has already been checked that the    |
+| rule has a precedence.  A conflict is resolved by modifying the   |
+| shift or reduce tables so that there is no longer a conflict.     |
+`------------------------------------------------------------------*/
 
 static void
 resolve_sr_conflict (int state, int lookaheadnum)
 {
 
 static void
 resolve_sr_conflict (int state, int lookaheadnum)
 {
-  register int i;
-  register int mask;
-  register unsigned *fp1;
-  register unsigned *fp2;
-  register int redprec;
-  errs *errp = (errs *) xmalloc (sizeof(errs) + ntokens * sizeof(short));
+  int i;
+  int mask;
+  unsigned *fp1;
+  unsigned *fp2;
+  int redprec;
+  errs *errp = ERRS_ALLOC (ntokens + 1);
   short *errtokens = errp->errs;
 
   /* find the rule to reduce by to get precedence of reduction  */
   short *errtokens = errp->errs;
 
   /* find the rule to reduce by to get precedence of reduction  */
-  redprec = rprec[LAruleno[lookaheadnum]];
+  redprec = rule_table[LAruleno[lookaheadnum]].prec;
 
   mask = 1;
 
   mask = 1;
-  fp1 = LA + lookaheadnum * tokensetsize;
+  fp1 = LA (lookaheadnum);
   fp2 = lookaheadset;
   for (i = 0; i < ntokens; i++)
     {
   fp2 = lookaheadset;
   for (i = 0; i < ntokens; i++)
     {
@@ -195,48 +108,47 @@ resolve_sr_conflict (int state, int lookaheadnum)
        {
          if (sprec[i] < redprec)
            {
        {
          if (sprec[i] < redprec)
            {
-             if (verboseflag) log_resolution(state, lookaheadnum, i, _("reduce"));
-             *fp2 &= ~mask;  /* flush the shift for this token */
-             flush_shift(state, i);
+             log_resolution (state, lookaheadnum, i, _("reduce"));
+             *fp2 &= ~mask;    /* flush the shift for this token */
+             flush_shift (state, i);
            }
          else if (sprec[i] > redprec)
            {
            }
          else if (sprec[i] > redprec)
            {
-             if (verboseflag) log_resolution(state, lookaheadnum, i, _("shift"));
-             *fp1 &= ~mask;  /* flush the reduce for this token */
+             log_resolution (state, lookaheadnum, i, _("shift"));
+             *fp1 &= ~mask;    /* flush the reduce for this token */
            }
          else
            {
              /* Matching precedence levels.
            }
          else
            {
              /* Matching precedence levels.
-                For left association, keep only the reduction.
-                For right association, keep only the shift.
-                For nonassociation, keep neither.  */
+                For left association, keep only the reduction.
+                For right association, keep only the shift.
+                For nonassociation, keep neither.  */
 
              switch (sassoc[i])
                {
 
              switch (sassoc[i])
                {
-
-               case RIGHT_ASSOC:
-                 if (verboseflag) log_resolution(state, lookaheadnum, i, _("shift"));
+               case right_assoc:
+                 log_resolution (state, lookaheadnum, i, _("shift"));
                  break;
 
                  break;
 
-               case LEFT_ASSOC:
-                 if (verboseflag) log_resolution(state, lookaheadnum, i, _("reduce"));
+               case left_assoc:
+                 log_resolution (state, lookaheadnum, i, _("reduce"));
                  break;
 
                  break;
 
-               case NON_ASSOC:
-                 if (verboseflag) log_resolution(state, lookaheadnum, i, _("an error"));
+               case non_assoc:
+                 log_resolution (state, lookaheadnum, i, _("an error"));
                  break;
                }
 
                  break;
                }
 
-             if (sassoc[i] != RIGHT_ASSOC)
+             if (sassoc[i] != right_assoc)
                {
                {
-                 *fp2 &= ~mask;  /* flush the shift for this token */
-                 flush_shift(state, i);
+                 *fp2 &= ~mask;        /* flush the shift for this token */
+                 flush_shift (state, i);
                }
                }
-             if (sassoc[i] != LEFT_ASSOC)
-               {
-                 *fp1 &= ~mask;  /* flush the reduce for this token */
+             if (sassoc[i] != left_assoc)
+               {
+                 *fp1 &= ~mask;        /* flush the reduce for this token */
                }
                }
-             if (sassoc[i] == NON_ASSOC)
+             if (sassoc[i] == non_assoc)
                {
                  /* Record an explicit error for this token.  */
                  *errtokens++ = i;
                {
                  /* Record an explicit error for this token.  */
                  *errtokens++ = i;
@@ -248,180 +160,115 @@ resolve_sr_conflict (int state, int lookaheadnum)
       if (mask == 0)
        {
          mask = 1;
       if (mask == 0)
        {
          mask = 1;
-         fp2++;  fp1++;
+         fp2++;
+         fp1++;
        }
     }
   errp->nerrs = errtokens - errp->errs;
   if (errp->nerrs)
     {
       /* Some tokens have been explicitly made errors.  Allocate
        }
     }
   errp->nerrs = errtokens - errp->errs;
   if (errp->nerrs)
     {
       /* Some tokens have been explicitly made errors.  Allocate
-        a permanent errs structure for this state, to record them.  */
+         a permanent errs structure for this state, to record them.  */
       i = (char *) errtokens - (char *) errp;
       i = (char *) errtokens - (char *) errp;
-      err_table[state] = (errs *) xmalloc ((unsigned int)i);
+      err_table[state] = ERRS_ALLOC (i + 1);
       bcopy (errp, err_table[state], i);
     }
   else
     err_table[state] = 0;
       bcopy (errp, err_table[state], i);
     }
   else
     err_table[state] = 0;
-  free(errp);
+  free (errp);
 }
 
 
 }
 
 
-
-/* turn off the shift recorded for the specified token in the specified state.
-Used when we resolve a shift-reduce conflict in favor of the reduction.  */
-
 static void
 static void
-flush_shift (int state, int token)
+set_conflicts (int state)
 {
 {
-  register shifts *shiftp;
-  register int k, i;
-/*  register unsigned symbol; JF unused */
-
-  shiftp = shift_table[state];
-
-  if (shiftp)
-    {
-      k = shiftp->nshifts;
-      for (i = 0; i < k; i++)
-       {
-         if (shiftp->shifts[i] && token == accessing_symbol[shiftp->shifts[i]])
-           (shiftp->shifts[i]) = 0;
-       }
-    }
-}
+  int i, j;
+  shifts *shiftp;
+  int symbol;
 
 
+  if (state_table[state].consistent)
+    return;
 
 
-static void
-log_resolution (int state, int LAno, int token, char *resolution)
-{
-  fprintf(foutput,
-         _("Conflict in state %d between rule %d and token %s resolved as %s.\n"),
-         state, LAruleno[LAno], tags[token], resolution);
-}
+  for (i = 0; i < tokensetsize; i++)
+    lookaheadset[i] = 0;
 
 
+  shiftp = state_table[state].shift_table;
+  if (shiftp)
+    for (i = 0; i < shiftp->nshifts; i++)
+      {
+       symbol = state_table[shiftp->shifts[i]].accessing_symbol;
+       if (ISVAR (symbol))
+         break;
+       SETBIT (lookaheadset, symbol);
+      }
 
 
-void
-conflict_log (void)
-{
-  register int i;
+  /* Loop over all rules which require lookahead in this state.  First
+     check for shift-reduce conflict, and try to resolve using
+     precedence */
+  for (i = state_table[state].lookaheads;
+       i < state_table[state + 1].lookaheads;
+       ++i)
+    if (rule_table[LAruleno[i]].prec)
+      for (j = 0; j < tokensetsize; ++j)
+       if (LA (i)[j] & lookaheadset[j])
+         {
+           resolve_sr_conflict (state, i);
+           break;
+         }
 
 
-  src_total = 0;
-  rrc_total = 0;
 
 
-  for (i = 0; i < nstates; i++)
+  /* Loop over all rules which require lookahead in this state.  Check
+     for conflicts not resolved above.  */
+  for (i = state_table[state].lookaheads;
+       i < state_table[state + 1].lookaheads;
+       ++i)
     {
     {
-      if (conflicts[i])
-       {
-         count_sr_conflicts(i);
-         count_rr_conflicts(i);
-         src_total += src_count;
-         rrc_total += rrc_count;
-       }
-    }
+      for (j = 0; j < tokensetsize; ++j)
+       if (LA (i)[j] & lookaheadset[j])
+         conflicts[state] = 1;
 
 
-  total_conflicts();
+      for (j = 0; j < tokensetsize; ++j)
+       lookaheadset[j] |= LA (i)[j];
+    }
 }
 
 }
 
-
 void
 void
-verbose_conflict_log (void)
+solve_conflicts (void)
 {
 {
-  register int i;
-
-  src_total = 0;
-  rrc_total = 0;
-
-  for (i = 0; i < nstates; i++)
-    {
-      if (conflicts[i])
-       {
-         count_sr_conflicts(i);
-         count_rr_conflicts(i);
-         src_total += src_count;
-         rrc_total += rrc_count;
-
-         fprintf(foutput, _("State %d contains"), i);
+  int i;
 
 
-         if (src_count == 1)
-           fprintf(foutput, _(" 1 shift/reduce conflict"));
-         else if (src_count > 1)
-           fprintf(foutput, _(" %d shift/reduce conflicts"), src_count);
+  conflicts = XCALLOC (char, nstates);
+  shiftset = XCALLOC (unsigned, tokensetsize);
+  lookaheadset = XCALLOC (unsigned, tokensetsize);
 
 
-         if (src_count > 0 && rrc_count > 0)
-           fprintf(foutput, _(" and"));
+  err_table = XCALLOC (errs *, nstates);
 
 
-         if (rrc_count == 1)
-           fprintf(foutput, _(" 1 reduce/reduce conflict"));
-         else if (rrc_count > 1)
-           fprintf(foutput, _(" %d reduce/reduce conflicts"), rrc_count);
-
-         putc('.', foutput);
-         putc('\n', foutput);
-       }
-    }
-
-  total_conflicts();
+  for (i = 0; i < nstates; i++)
+    set_conflicts (i);
 }
 
 
 }
 
 
-static void
-total_conflicts (void)
-{
-  if (src_total == expected_conflicts && rrc_total == 0)
-    return;
-
-  if (fixed_outfiles)
-    {
-      /* If invoked under the name `yacc', use the output format
-        specified by POSIX.  */
-      fprintf(stderr, _("conflicts: "));
-      if (src_total > 0)
-       fprintf(stderr, _(" %d shift/reduce"), src_total);
-      if (src_total > 0 && rrc_total > 0)
-       fprintf(stderr, ",");
-      if (rrc_total > 0)
-       fprintf(stderr, _(" %d reduce/reduce"), rrc_total);
-      putc('\n', stderr);
-    }
-  else
-    {
-      fprintf(stderr, _("%s contains"), infile);
-
-      if (src_total == 1)
-       fprintf(stderr, _(" 1 shift/reduce conflict"));
-      else if (src_total > 1)
-       fprintf(stderr, _(" %d shift/reduce conflicts"), src_total);
-
-      if (src_total > 0 && rrc_total > 0)
-       fprintf(stderr, _(" and"));
-
-      if (rrc_total == 1)
-       fprintf(stderr, _(" 1 reduce/reduce conflict"));
-      else if (rrc_total > 1)
-       fprintf(stderr, _(" %d reduce/reduce conflicts"), rrc_total);
+/*---------------------------------------------.
+| Count the number of shift/reduce conflicts.  |
+`---------------------------------------------*/
 
 
-      putc('.', stderr);
-      putc('\n', stderr);
-    }
-}
-
-
-static void
+static int
 count_sr_conflicts (int state)
 {
 count_sr_conflicts (int state)
 {
-  register int i;
-  register int k;
-  register int mask;
-  register shifts *shiftp;
-  register unsigned *fp1;
-  register unsigned *fp2;
-  register unsigned *fp3;
-  register int symbol;
+  int i;
+  int k;
+  int mask;
+  shifts *shiftp;
+  unsigned *fp1;
+  unsigned *fp2;
+  unsigned *fp3;
+  int symbol;
 
 
-  src_count = 0;
+  int src_count = 0;
 
 
-  shiftp = shift_table[state];
-  if (!shiftp) return;
+  shiftp = state_table[state].shift_table;
+  if (!shiftp)
+    return 0;
 
   for (i = 0; i < tokensetsize; i++)
     {
 
   for (i = 0; i < tokensetsize; i++)
     {
@@ -432,18 +279,20 @@ count_sr_conflicts (int state)
   k = shiftp->nshifts;
   for (i = 0; i < k; i++)
     {
   k = shiftp->nshifts;
   for (i = 0; i < k; i++)
     {
-      if (! shiftp->shifts[i]) continue;
-      symbol = accessing_symbol[shiftp->shifts[i]];
-      if (ISVAR(symbol)) break;
-      SETBIT(shiftset, symbol);
+      if (!shiftp->shifts[i])
+       continue;
+      symbol = state_table[shiftp->shifts[i]].accessing_symbol;
+      if (ISVAR (symbol))
+       break;
+      SETBIT (shiftset, symbol);
     }
 
     }
 
-  k = lookaheads[state + 1];
+  k = state_table[state + 1].lookaheads;
   fp3 = lookaheadset + tokensetsize;
 
   fp3 = lookaheadset + tokensetsize;
 
-  for (i = lookaheads[state]; i < k; i++)
+  for (i = state_table[state].lookaheads; i < k; i++)
     {
     {
-      fp1 = LA + i * tokensetsize;
+      fp1 = LA (i);
       fp2 = lookaheadset;
 
       while (fp2 < fp3)
       fp2 = lookaheadset;
 
       while (fp2 < fp3)
@@ -470,35 +319,38 @@ count_sr_conflicts (int state)
          fp2++;
        }
     }
          fp2++;
        }
     }
+
+  return src_count;
 }
 
 
 }
 
 
-static void
+/*----------------------------------------------.
+| Count the number of reduce/reduce conflicts.  |
+`----------------------------------------------*/
+
+static int
 count_rr_conflicts (int state)
 {
 count_rr_conflicts (int state)
 {
-  register int i;
-  register int j;
-  register int count;
-  register unsigned mask;
-  register unsigned *baseword;
-  register unsigned *wordp;
-  register int m;
-  register int n;
+  int i;
+  unsigned mask;
+  unsigned *baseword;
 
 
-  rrc_count = 0;
+  int rrc_count = 0;
 
 
-  m = lookaheads[state];
-  n = lookaheads[state + 1];
+  int m = state_table[state].lookaheads;
+  int n = state_table[state + 1].lookaheads;
 
 
-  if (n - m < 2) return;
+  if (n - m < 2)
+    return 0;
 
   mask = 1;
 
   mask = 1;
-  baseword = LA + m * tokensetsize;
+  baseword = LA (m);
   for (i = 0; i < ntokens; i++)
     {
   for (i = 0; i < ntokens; i++)
     {
-      wordp = baseword;
+      unsigned *wordp = baseword;
 
 
-      count = 0;
+      int count = 0;
+      int j;
       for (j = m; j < n; j++)
        {
          if (mask & *wordp)
       for (j = m; j < n; j++)
        {
          if (mask & *wordp)
@@ -507,7 +359,8 @@ count_rr_conflicts (int state)
          wordp += tokensetsize;
        }
 
          wordp += tokensetsize;
        }
 
-      if (count >= 2) rrc_count++;
+      if (count >= 2)
+       rrc_count++;
 
       mask <<= 1;
       if (mask == 0)
 
       mask <<= 1;
       if (mask == 0)
@@ -516,48 +369,172 @@ count_rr_conflicts (int state)
          baseword++;
        }
     }
          baseword++;
        }
     }
+
+  return rrc_count;
+}
+
+/*--------------------------------------------------------------.
+| Return a human readable string which reports shift/reduce and |
+| reduce/reduce conflict numbers (SRC_NUM, RRC_NUM).            |
+`--------------------------------------------------------------*/
+
+static const char *
+conflict_report (int src_num, int rrc_num)
+{
+  static char res[4096];
+  char *cp = res;
+
+  if (src_num >= 1)
+    {
+      sprintf (cp, ngettext ("%d shift/reduce conflict",
+                            "%d shift/reduce conflicts", src_num), src_num);
+      cp += strlen (cp);
+    }
+
+  if (src_num > 0 && rrc_num > 0)
+    {
+      sprintf (cp, " %s ", _("and"));
+      cp += strlen (cp);
+    }
+
+  if (rrc_num >= 1)
+    {
+      sprintf (cp, ngettext ("%d reduce/reduce conflict",
+                            "%d reduce/reduce conflicts", rrc_num), rrc_num);
+      cp += strlen (cp);
+    }
+
+  *cp++ = '.';
+  *cp++ = '\n';
+  *cp++ = '\0';
+
+  return res;
+}
+
+
+/*-----------------------------------------------------------.
+| Output the detailed description of states with conflicts.  |
+`-----------------------------------------------------------*/
+
+void
+conflicts_output (FILE *out)
+{
+  int i;
+  for (i = 0; i < nstates; i++)
+    if (conflicts[i])
+      {
+       fprintf (out, _("State %d contains "), i);
+       fputs (conflict_report (count_sr_conflicts (i),
+                               count_rr_conflicts (i)), out);
+      }
+}
+
+
+/*------------------------------------------.
+| Reporting the total number of conflicts.  |
+`------------------------------------------*/
+
+void
+conflicts_print (void)
+{
+  int i;
+
+  /* Is the number of SR conflicts OK?  Either EXPECTED_CONFLICTS is
+     not set, and then we want 0 SR, or else it is specified, in which
+     case we want equality.  */
+  int src_ok = 0;
+
+  int src_total = 0;
+  int rrc_total = 0;
+
+  /* Conflicts by state.  */
+  for (i = 0; i < nstates; i++)
+    if (conflicts[i])
+      {
+       src_total += count_sr_conflicts (i);
+       rrc_total += count_rr_conflicts (i);
+      }
+
+  src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);
+
+  /* If there are no RR conflicts, and as many SR conflicts as
+     expected, then there is nothing to report.  */
+  if (!rrc_total && src_ok)
+    return;
+
+  /* Report the total number of conflicts on STDERR.  */
+  if (yacc_flag)
+    {
+      /* If invoked with `--yacc', use the output format specified by
+        POSIX.  */
+      fprintf (stderr, _("conflicts: "));
+      if (src_total > 0)
+       fprintf (stderr, _(" %d shift/reduce"), src_total);
+      if (src_total > 0 && rrc_total > 0)
+       fprintf (stderr, ",");
+      if (rrc_total > 0)
+       fprintf (stderr, _(" %d reduce/reduce"), rrc_total);
+      putc ('\n', stderr);
+    }
+  else
+    {
+      fprintf (stderr, _("%s contains "), infile);
+      fputs (conflict_report (src_total, rrc_total), stderr);
+    }
+
+  if (expected_conflicts != -1 && !src_ok)
+    {
+      complain_message_count++;
+      fprintf (stderr, ngettext ("expected %d shift/reduce conflict\n",
+                                "expected %d shift/reduce conflicts\n",
+                                expected_conflicts),
+              expected_conflicts);
+    }
 }
 
 
 void
 }
 
 
 void
-print_reductions (int state)
+print_reductions (FILE *out, int state)
 {
 {
-  register int i;
-  register int j;
-  register int k;
-  register unsigned *fp1;
-  register unsigned *fp2;
-  register unsigned *fp3;
-  register unsigned *fp4;
-  register int rule;
-  register int symbol;
-  register unsigned mask;
-  register int m;
-  register int n;
-  register int default_LA;
-  register int default_rule = 0;
-  register int cmax;
-  register int count;
-  register shifts *shiftp;
-  register errs *errp;
+  int i;
+  int j;
+  int k;
+  unsigned *fp1;
+  unsigned *fp2;
+  unsigned *fp3;
+  unsigned *fp4;
+  int rule;
+  int symbol;
+  unsigned mask;
+  int m;
+  int n;
+  int default_LA;
+  int default_rule = 0;
+  int cmax;
+  int count;
+  shifts *shiftp;
+  errs *errp;
   int nodefault = 0;
 
   for (i = 0; i < tokensetsize; i++)
     shiftset[i] = 0;
 
   int nodefault = 0;
 
   for (i = 0; i < tokensetsize; i++)
     shiftset[i] = 0;
 
-  shiftp = shift_table[state];
+  shiftp = state_table[state].shift_table;
   if (shiftp)
     {
       k = shiftp->nshifts;
       for (i = 0; i < k; i++)
        {
   if (shiftp)
     {
       k = shiftp->nshifts;
       for (i = 0; i < k; i++)
        {
-         if (! shiftp->shifts[i]) continue;
-         symbol = accessing_symbol[shiftp->shifts[i]];
-         if (ISVAR(symbol)) break;
+         if (!shiftp->shifts[i])
+           continue;
+         symbol = state_table[shiftp->shifts[i]].accessing_symbol;
+         if (ISVAR (symbol))
+           break;
          /* 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 (symbol == error_token_number) nodefault = 1;
-         SETBIT(shiftset, symbol);
+         if (symbol == error_token_number)
+           nodefault = 1;
+         SETBIT (shiftset, symbol);
        }
     }
 
        }
     }
 
@@ -567,20 +544,21 @@ print_reductions (int state)
       k = errp->nerrs;
       for (i = 0; i < k; i++)
        {
       k = errp->nerrs;
       for (i = 0; i < k; i++)
        {
-         if (! errp->errs[i]) continue;
+         if (!errp->errs[i])
+           continue;
          symbol = errp->errs[i];
          symbol = errp->errs[i];
-         SETBIT(shiftset, symbol);
+         SETBIT (shiftset, symbol);
        }
     }
 
        }
     }
 
-  m = lookaheads[state];
-  n = lookaheads[state + 1];
+  m = state_table[state].lookaheads;
+  n = state_table[state + 1].lookaheads;
 
 
-  if (n - m == 1 && ! nodefault)
+  if (n - m == 1 && !nodefault)
     {
       default_rule = LAruleno[m];
 
     {
       default_rule = LAruleno[m];
 
-      fp1 = LA + m * tokensetsize;
+      fp1 = LA (m);
       fp2 = shiftset;
       fp3 = lookaheadset;
       fp4 = lookaheadset + tokensetsize;
       fp2 = shiftset;
       fp3 = lookaheadset;
       fp4 = lookaheadset + tokensetsize;
@@ -594,8 +572,9 @@ print_reductions (int state)
       for (i = 0; i < ntokens; i++)
        {
          if (mask & *fp3)
       for (i = 0; i < ntokens; i++)
        {
          if (mask & *fp3)
-           fprintf(foutput, _("    %-4s\t[reduce using rule %d (%s)]\n"),
-                   tags[i], default_rule, tags[rlhs[default_rule]]);
+           fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),
+                    tags[i], default_rule,
+                    tags[rule_table[default_rule].lhs]);
 
          mask <<= 1;
          if (mask == 0)
 
          mask <<= 1;
          if (mask == 0)
@@ -605,8 +584,8 @@ print_reductions (int state)
            }
        }
 
            }
        }
 
-      fprintf(foutput, _("    $default\treduce using rule %d (%s)\n\n"),
-             default_rule, tags[rlhs[default_rule]]);
+      fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
+              default_rule, tags[rule_table[default_rule].lhs]);
     }
   else if (n - m >= 1)
     {
     }
   else if (n - m >= 1)
     {
@@ -614,10 +593,10 @@ print_reductions (int state)
       default_LA = -1;
       fp4 = lookaheadset + tokensetsize;
 
       default_LA = -1;
       fp4 = lookaheadset + tokensetsize;
 
-      if (! nodefault)
+      if (!nodefault)
        for (i = m; i < n; i++)
          {
        for (i = m; i < n; i++)
          {
-           fp1 = LA + i * tokensetsize;
+           fp1 = LA (i);
            fp2 = shiftset;
            fp3 = lookaheadset;
 
            fp2 = shiftset;
            fp3 = lookaheadset;
 
@@ -655,22 +634,24 @@ print_reductions (int state)
          }
 
       for (i = 0; i < tokensetsize; i++)
          }
 
       for (i = 0; i < tokensetsize; i++)
-        shiftset[i] = 0;
+       shiftset[i] = 0;
 
       if (shiftp)
 
       if (shiftp)
-        {
-          k = shiftp->nshifts;
-          for (i = 0; i < k; i++)
+       {
+         k = shiftp->nshifts;
+         for (i = 0; i < k; i++)
            {
            {
-             if (! shiftp->shifts[i]) continue;
-             symbol = accessing_symbol[shiftp->shifts[i]];
-             if (ISVAR(symbol)) break;
-             SETBIT(shiftset, symbol);
+             if (!shiftp->shifts[i])
+               continue;
+             symbol = state_table[shiftp->shifts[i]].accessing_symbol;
+             if (ISVAR (symbol))
+               break;
+             SETBIT (shiftset, symbol);
            }
            }
-        }
+       }
 
       mask = 1;
 
       mask = 1;
-      fp1 = LA + m * tokensetsize;
+      fp1 = LA (m);
       fp2 = shiftset;
       for (i = 0; i < ntokens; i++)
        {
       fp2 = shiftset;
       for (i = 0; i < ntokens; i++)
        {
@@ -691,10 +672,12 @@ print_reductions (int state)
                      if (j != default_LA)
                        {
                          rule = LAruleno[j];
                      if (j != default_LA)
                        {
                          rule = LAruleno[j];
-                         fprintf(foutput, _("    %-4s\treduce using rule %d (%s)\n"),
-                                 tags[i], rule, tags[rlhs[rule]]);
+                         fprintf (out,
+                                  _("    %-4s\treduce using rule %d (%s)\n"),
+                                  tags[i], rule, tags[rule_table[rule].lhs]);
                        }
                        }
-                     else defaulted = 1;
+                     else
+                       defaulted = 1;
 
                      count++;
                    }
 
                      count++;
                    }
@@ -703,13 +686,15 @@ print_reductions (int state)
                      if (defaulted)
                        {
                          rule = LAruleno[default_LA];
                      if (defaulted)
                        {
                          rule = LAruleno[default_LA];
-                         fprintf(foutput, _("    %-4s\treduce using rule %d (%s)\n"),
-                                 tags[i], rule, tags[rlhs[rule]]);
+                         fprintf (out,
+                                  _("    %-4s\treduce using rule %d (%s)\n"),
+                                  tags[i], rule, tags[rule_table[rule].lhs]);
                          defaulted = 0;
                        }
                      rule = LAruleno[j];
                          defaulted = 0;
                        }
                      rule = LAruleno[j];
-                     fprintf(foutput, _("    %-4s\t[reduce using rule %d (%s)]\n"),
-                             tags[i], rule, tags[rlhs[rule]]);
+                     fprintf (out,
+                              _("    %-4s\t[reduce using rule %d (%s)]\n"),
+                              tags[i], rule, tags[rule_table[rule].lhs]);
                    }
                }
 
                    }
                }
 
@@ -721,27 +706,23 @@ print_reductions (int state)
            {
              mask = 1;
              /* We tried incrementing just fp1, and just fp2; both seem wrong.
            {
              mask = 1;
              /* We tried incrementing just fp1, and just fp2; both seem wrong.
-                It seems necessary to increment both in sync.  */
+                It seems necessary to increment both in sync.  */
              fp1++;
              fp2++;
            }
        }
 
       if (default_LA >= 0)
              fp1++;
              fp2++;
            }
        }
 
       if (default_LA >= 0)
-       {
-         fprintf(foutput, _("    $default\treduce using rule %d (%s)\n"),
-                 default_rule, tags[rlhs[default_rule]]);
-       }
-
-      putc('\n', foutput);
+       fprintf (out, _("    $default\treduce using rule %d (%s)\n"),
+                default_rule, tags[rule_table[default_rule].lhs]);
     }
 }
 
 
 void
     }
 }
 
 
 void
-finalize_conflicts (void)
+free_conflicts (void)
 {
 {
-  FREE(conflicts);
-  FREE(shiftset);
-  FREE(lookaheadset);
+  XFREE (conflicts);
+  XFREE (shiftset);
+  XFREE (lookaheadset);
 }
 }