Change @dircategory from "GNU programming tools" to "Software development".
[bison.git] / src / conflicts.c
index 201c9c97eb87e6d5a907531f72a4fe8eed3dea98..bcd6c84667c790c6df848bb5787cc03be8b6fecf 100644 (file)
@@ -1,5 +1,6 @@
 /* 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, 2001, 2002
+
+   Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004
    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.
    02111-1307, USA.  */
 
 #include "system.h"
    02111-1307, USA.  */
 
 #include "system.h"
-#include "bitset.h"
+
+#include <bitset.h>
+
+#include "LR0.h"
 #include "complain.h"
 #include "complain.h"
-#include "getargs.h"
-#include "symtab.h"
+#include "conflicts.h"
 #include "files.h"
 #include "files.h"
+#include "getargs.h"
 #include "gram.h"
 #include "gram.h"
-#include "state.h"
 #include "lalr.h"
 #include "lalr.h"
-#include "conflicts.h"
 #include "reader.h"
 #include "reader.h"
-#include "LR0.h"
+#include "state.h"
+#include "symtab.h"
 
 /* -1 stands for not specified. */
 
 /* -1 stands for not specified. */
-int expected_conflicts = -1;
-static char *conflicts = NULL;
+int expected_sr_conflicts = -1;
+int expected_rr_conflicts = -1;
+static char *conflicts;
 struct obstack solved_conflicts_obstack;
 
 struct obstack solved_conflicts_obstack;
 
-static bitset shiftset;
-static bitset lookaheadset;
+static bitset shift_set;
+static bitset look_ahead_set;
 
 \f
 
 
 \f
 
-enum conflict_resolution_e
+enum conflict_resolution
   {
     shift_resolution,
     reduce_resolution,
   {
     shift_resolution,
     reduce_resolution,
@@ -58,8 +62,8 @@ enum conflict_resolution_e
 `----------------------------------------------------------------*/
 
 static inline void
 `----------------------------------------------------------------*/
 
 static inline void
-log_resolution (rule_t *rule, symbol_number_t token,
-               enum conflict_resolution_e resolution)
+log_resolution (rule *r, symbol_number token,
+               enum conflict_resolution resolution)
 {
   if (report_flag & report_solved_conflicts)
     {
 {
   if (report_flag & report_solved_conflicts)
     {
@@ -71,7 +75,7 @@ log_resolution (rule_t *rule, symbol_number_t token,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as shift"),
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as shift"),
-                         rule->number,
+                         r->number,
                          symbols[token]->tag);
          break;
        case reduce_resolution:
                          symbols[token]->tag);
          break;
        case reduce_resolution:
@@ -79,14 +83,14 @@ log_resolution (rule_t *rule, symbol_number_t token,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as reduce"),
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as reduce"),
-                         rule->number,
+                         r->number,
                          symbols[token]->tag);
          break;
        case nonassoc_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as an error"),
                          symbols[token]->tag);
          break;
        case nonassoc_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as an error"),
-                         rule->number,
+                         r->number,
                          symbols[token]->tag);
          break;
        }
                          symbols[token]->tag);
          break;
        }
@@ -97,7 +101,7 @@ log_resolution (rule_t *rule, symbol_number_t token,
        case shift_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
        case shift_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
-                         rule->prec->tag,
+                         r->prec->tag,
                          symbols[token]->tag);
          break;
 
                          symbols[token]->tag);
          break;
 
@@ -105,7 +109,7 @@ log_resolution (rule_t *rule, symbol_number_t token,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
                          symbols[token]->tag,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
                          symbols[token]->tag,
-                         rule->prec->tag);
+                         r->prec->tag);
          break;
 
        case left_resolution:
          break;
 
        case left_resolution:
@@ -137,29 +141,29 @@ log_resolution (rule_t *rule, symbol_number_t token,
 `------------------------------------------------------------------*/
 
 static void
 `------------------------------------------------------------------*/
 
 static void
-flush_shift (state_t *state, int token)
+flush_shift (state *s, int token)
 {
 {
-  transitions_t *transitions = state->transitions;
+  transitions *trans = s->transitions;
   int i;
 
   int i;
 
-  bitset_reset (lookaheadset, token);
-  for (i = 0; i < transitions->num; i++)
-    if (!TRANSITION_IS_DISABLED (transitions, i)
-       && TRANSITION_SYMBOL (transitions, i) == token)
-      TRANSITION_DISABLE (transitions, i);
+  bitset_reset (look_ahead_set, token);
+  for (i = 0; i < trans->num; i++)
+    if (!TRANSITION_IS_DISABLED (trans, i)
+       && TRANSITION_SYMBOL (trans, i) == token)
+      TRANSITION_DISABLE (trans, i);
 }
 
 
 }
 
 
-/*-------------------------------------------------------------------.
-| Turn off the reduce recorded for the specified token for the       |
-| specified lookahead.  Used when we resolve a shift-reduce conflict |
-| in favor of the shift.                                             |
-`-------------------------------------------------------------------*/
+/*--------------------------------------------------------------------.
+| Turn off the reduce recorded for the specified token for the        |
+| specified look-ahead.  Used when we resolve a shift-reduce conflict |
+| in favor of the shift.                                              |
+`--------------------------------------------------------------------*/
 
 static void
 
 static void
-flush_reduce (bitset lookaheads, int token)
+flush_reduce (bitset look_ahead_tokens, int token)
 {
 {
-  bitset_reset (lookaheads, token);
+  bitset_reset (look_ahead_tokens, token);
 }
 
 
 }
 
 
@@ -169,26 +173,25 @@ flush_reduce (bitset lookaheads, int token)
 | rule has a precedence.  A conflict is resolved by modifying the   |
 | shift or reduce tables so that there is no longer a conflict.     |
 |                                                                   |
 | rule has a precedence.  A conflict is resolved by modifying the   |
 | shift or reduce tables so that there is no longer a conflict.     |
 |                                                                   |
-| LOOKAHEAD is the number of the lookahead bitset to consider.      |
+| RULENO is the number of the look-ahead bitset to consider.      |
 |                                                                   |
 |                                                                   |
-| ERRS can be used to store discovered explicit errors.             |
+| ERRORS can be used to store discovered explicit errors.           |
 `------------------------------------------------------------------*/
 
 static void
 `------------------------------------------------------------------*/
 
 static void
-resolve_sr_conflict (state_t *state, int ruleno,
-                    symbol_t **errs)
+resolve_sr_conflict (state *s, int ruleno, symbol **errors)
 {
 {
-  symbol_number_t i;
-  reductions_t *reds = state->reductions;
+  symbol_number i;
+  reductions *reds = s->reductions;
   /* Find the rule to reduce by to get precedence of reduction.  */
   /* Find the rule to reduce by to get precedence of reduction.  */
-  rule_t *redrule = reds->rules[ruleno];
+  rule *redrule = reds->rules[ruleno];
   int redprec = redrule->prec->prec;
   int redprec = redrule->prec->prec;
-  bitset lookaheads = reds->lookaheads[ruleno];
+  bitset look_ahead_tokens = reds->look_ahead_tokens[ruleno];
   int nerrs = 0;
 
   for (i = 0; i < ntokens; i++)
   int nerrs = 0;
 
   for (i = 0; i < ntokens; i++)
-    if (bitset_test (lookaheads, i)
-       && bitset_test (lookaheadset, i)
+    if (bitset_test (look_ahead_tokens, i)
+       && bitset_test (look_ahead_set, i)
        && symbols[i]->prec)
       {
        /* Shift-reduce conflict occurs for token number i
        && symbols[i]->prec)
       {
        /* Shift-reduce conflict occurs for token number i
@@ -197,12 +200,12 @@ resolve_sr_conflict (state_t *state, int ruleno,
        if (symbols[i]->prec < redprec)
          {
            log_resolution (redrule, i, reduce_resolution);
        if (symbols[i]->prec < redprec)
          {
            log_resolution (redrule, i, reduce_resolution);
-           flush_shift (state, i);
+           flush_shift (s, i);
          }
        else if (symbols[i]->prec > redprec)
          {
            log_resolution (redrule, i, shift_resolution);
          }
        else if (symbols[i]->prec > redprec)
          {
            log_resolution (redrule, i, shift_resolution);
-           flush_reduce (lookaheads, i);
+           flush_reduce (look_ahead_tokens, i);
          }
        else
          /* Matching precedence levels.
          }
        else
          /* Matching precedence levels.
@@ -214,81 +217,80 @@ resolve_sr_conflict (state_t *state, int ruleno,
            {
            case right_assoc:
              log_resolution (redrule, i, right_resolution);
            {
            case right_assoc:
              log_resolution (redrule, i, right_resolution);
-             flush_reduce (lookaheads, i);
+             flush_reduce (look_ahead_tokens, i);
              break;
 
            case left_assoc:
              log_resolution (redrule, i, left_resolution);
              break;
 
            case left_assoc:
              log_resolution (redrule, i, left_resolution);
-             flush_shift (state, i);
+             flush_shift (s, i);
              break;
 
            case non_assoc:
              log_resolution (redrule, i, nonassoc_resolution);
              break;
 
            case non_assoc:
              log_resolution (redrule, i, nonassoc_resolution);
-             flush_shift (state, i);
-             flush_reduce (lookaheads, i);
+             flush_shift (s, i);
+             flush_reduce (look_ahead_tokens, i);
              /* Record an explicit error for this token.  */
              /* Record an explicit error for this token.  */
-             errs[nerrs++] = symbols[i];
+             errors[nerrs++] = symbols[i];
              break;
 
            case undef_assoc:
              break;
 
            case undef_assoc:
-             assert (symbols[i]->assoc != undef_assoc);
-             break;
+             abort ();
            }
       }
 
            }
       }
 
-  /* Some tokens have been explicitly made errors.  Allocate a
-     permanent errs structure for this state, to record them.  */
-  state_errs_set (state, nerrs, errs);
+  if (nerrs)
+    {
+      /* Some tokens have been explicitly made errors.  Allocate a
+        permanent errs structure for this state, to record them.  */
+      state_errs_set (s, nerrs, errors);
+    }
 
   if (obstack_object_size (&solved_conflicts_obstack))
     {
       obstack_1grow (&solved_conflicts_obstack, '\0');
 
   if (obstack_object_size (&solved_conflicts_obstack))
     {
       obstack_1grow (&solved_conflicts_obstack, '\0');
-      state->solved_conflicts = obstack_finish (&solved_conflicts_obstack);
+      s->solved_conflicts = obstack_finish (&solved_conflicts_obstack);
     }
 }
 
 
 /*-------------------------------------------------------------------.
     }
 }
 
 
 /*-------------------------------------------------------------------.
-| Solve the S/R conflicts of STATE using the                         |
+| Solve the S/R conflicts of state S using the                       |
 | precedence/associativity, and flag it inconsistent if it still has |
 | precedence/associativity, and flag it inconsistent if it still has |
-| conflicts.  ERRS can be used as storage to compute the list of     |
-| lookaheads on which this STATE raises a syntax error (%nonassoc).  |
+| conflicts.  ERRORS can be used as storage to compute the list of   |
+| look-ahead tokens on which S raises a syntax error (%nonassoc).    |
 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void
-set_conflicts (state_t *state, symbol_t **errs)
+set_conflicts (state *s, symbol **errors)
 {
   int i;
 {
   int i;
-  transitions_t *transitions = state->transitions;
-  reductions_t *reds = state->reductions;
+  transitions *trans = s->transitions;
+  reductions *reds = s->reductions;
 
 
-  if (state->consistent)
+  if (s->consistent)
     return;
 
     return;
 
-  bitset_zero (lookaheadset);
+  bitset_zero (look_ahead_set);
 
 
-  FOR_EACH_SHIFT (transitions, i)
-    bitset_set (lookaheadset, TRANSITION_SYMBOL (transitions, i));
+  FOR_EACH_SHIFT (trans, i)
+    bitset_set (look_ahead_set, TRANSITION_SYMBOL (trans, i));
 
 
-  /* Loop over all rules which require lookahead in this state.  First
+  /* Loop over all rules which require look-ahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence.  */
   for (i = 0; i < reds->num; ++i)
     if (reds->rules[i]->prec && reds->rules[i]->prec->prec
      check for shift-reduce conflict, and try to resolve using
      precedence.  */
   for (i = 0; i < reds->num; ++i)
     if (reds->rules[i]->prec && reds->rules[i]->prec->prec
-       && !bitset_disjoint_p (reds->lookaheads[i], lookaheadset))
-      {
-       resolve_sr_conflict (state, i, errs);
-       break;
-      }
+       && !bitset_disjoint_p (reds->look_ahead_tokens[i], look_ahead_set))
+      resolve_sr_conflict (s, i, errors);
 
 
-  /* Loop over all rules which require lookahead in this state.  Check
+  /* Loop over all rules which require look-ahead in this state.  Check
      for conflicts not resolved above.  */
   for (i = 0; i < reds->num; ++i)
     {
      for conflicts not resolved above.  */
   for (i = 0; i < reds->num; ++i)
     {
-      if (!bitset_disjoint_p (reds->lookaheads[i], lookaheadset))
-       conflicts[state->number] = 1;
+      if (!bitset_disjoint_p (reds->look_ahead_tokens[i], look_ahead_set))
+       conflicts[s->number] = 1;
 
 
-      bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
+      bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]);
     }
 }
 
     }
 }
 
@@ -301,18 +303,18 @@ set_conflicts (state_t *state, symbol_t **errs)
 void
 conflicts_solve (void)
 {
 void
 conflicts_solve (void)
 {
-  state_number_t i;
-  /* List of lookaheads on which we explicitly raise a syntax error.  */
-  symbol_t **errs = XMALLOC (symbol_t *, ntokens + 1);
+  state_number i;
+  /* List of look-ahead tokens on which we explicitly raise a syntax error.  */
+  symbol **errors = xnmalloc (ntokens + 1, sizeof *errors);
 
 
-  conflicts = XCALLOC (char, nstates);
-  shiftset = bitset_create (ntokens, BITSET_FIXED);
-  lookaheadset = bitset_create (ntokens, BITSET_FIXED);
+  conflicts = xcalloc (nstates, sizeof *conflicts);
+  shift_set = bitset_create (ntokens, BITSET_FIXED);
+  look_ahead_set = bitset_create (ntokens, BITSET_FIXED);
   obstack_init (&solved_conflicts_obstack);
 
   for (i = 0; i < nstates; i++)
     {
   obstack_init (&solved_conflicts_obstack);
 
   for (i = 0; i < nstates; i++)
     {
-      set_conflicts (states[i], errs);
+      set_conflicts (states[i], errors);
 
       /* For uniformity of the code, make sure all the states have a valid
         `errs' member.  */
 
       /* For uniformity of the code, make sure all the states have a valid
         `errs' member.  */
@@ -320,7 +322,7 @@ conflicts_solve (void)
        states[i]->errs = errs_new (0, 0);
     }
 
        states[i]->errs = errs_new (0, 0);
     }
 
-  free (errs);
+  free (errors);
 }
 
 
 }
 
 
@@ -329,28 +331,28 @@ conflicts_solve (void)
 `---------------------------------------------*/
 
 static int
 `---------------------------------------------*/
 
 static int
-count_sr_conflicts (state_t *state)
+count_sr_conflicts (state *s)
 {
   int i;
   int src_count = 0;
 {
   int i;
   int src_count = 0;
-  transitions_t *transitions = state->transitions;
-  reductions_t *reds = state->reductions;
+  transitions *trans = s->transitions;
+  reductions *reds = s->reductions;
 
 
-  if (!transitions)
+  if (!trans)
     return 0;
 
     return 0;
 
-  bitset_zero (lookaheadset);
-  bitset_zero (shiftset);
+  bitset_zero (look_ahead_set);
+  bitset_zero (shift_set);
 
 
-  FOR_EACH_SHIFT (transitions, i)
-    bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+  FOR_EACH_SHIFT (trans, i)
+    bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));
 
   for (i = 0; i < reds->num; ++i)
 
   for (i = 0; i < reds->num; ++i)
-    bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
+    bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]);
 
 
-  bitset_and (lookaheadset, lookaheadset, shiftset);
+  bitset_and (look_ahead_set, look_ahead_set, shift_set);
 
 
-  src_count = bitset_count (lookaheadset);
+  src_count = bitset_count (look_ahead_set);
 
   return src_count;
 }
 
   return src_count;
 }
@@ -364,10 +366,10 @@ count_sr_conflicts (state_t *state)
 +`----------------------------------------------------------------*/
 
 static int
 +`----------------------------------------------------------------*/
 
 static int
-count_rr_conflicts (state_t *state, int one_per_token)
+count_rr_conflicts (state *s, bool one_per_token)
 {
   int i;
 {
   int i;
-  reductions_t *reds = state->reductions;
+  reductions *reds = s->reductions;
   int rrc_count = 0;
 
   for (i = 0; i < ntokens; i++)
   int rrc_count = 0;
 
   for (i = 0; i < ntokens; i++)
@@ -375,7 +377,7 @@ count_rr_conflicts (state_t *state, int one_per_token)
       int count = 0;
       int j;
       for (j = 0; j < reds->num; ++j)
       int count = 0;
       int j;
       for (j = 0; j < reds->num; ++j)
-       if (bitset_test (reds->lookaheads[j], i))
+       if (bitset_test (reds->look_ahead_tokens[j], i))
          count++;
 
       if (count >= 2)
          count++;
 
       if (count >= 2)
@@ -386,60 +388,20 @@ count_rr_conflicts (state_t *state, int one_per_token)
 }
 
 
 }
 
 
-/*--------------------------------------------------------------.
-| 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++ = '\0';
-
-  return res;
-}
-
-
-/*----------------------------------------------------------------.
-| Same as above, but report the number of conflicts a` la POSIX.  |
-`----------------------------------------------------------------*/
+/*--------------------------------------------------------.
+| Report the number of conflicts, using the Yacc format.  |
+`--------------------------------------------------------*/
 
 static void
 
 static void
-conflict_report_yacc (int src_num, int rrc_num)
+conflict_report (FILE *out, int src_num, int rrc_num)
 {
 {
-  /* If invoked with `--yacc', use the output format specified by
-     POSIX.  */
-  fprintf (stderr, _("conflicts: "));
-  if (src_num > 0)
-    fprintf (stderr, _(" %d shift/reduce"), src_num);
-  if (src_num > 0 && rrc_num > 0)
-    fprintf (stderr, ",");
-  if (rrc_num > 0)
-    fprintf (stderr, _(" %d reduce/reduce"), rrc_num);
-  putc ('\n', stderr);
+  if (src_num && rrc_num)
+    fprintf (out, _("conflicts: %d shift/reduce, %d reduce/reduce\n"),
+            src_num, rrc_num);
+  else if (src_num)
+    fprintf (out, _("conflicts: %d shift/reduce\n"), src_num);
+  else if (rrc_num)
+    fprintf (out, _("conflicts: %d reduce/reduce\n"), rrc_num);
 }
 
 
 }
 
 
@@ -451,16 +413,15 @@ void
 conflicts_output (FILE *out)
 {
   bool printed_sth = false;
 conflicts_output (FILE *out)
 {
   bool printed_sth = false;
-  state_number_t i;
+  state_number i;
   for (i = 0; i < nstates; i++)
     {
   for (i = 0; i < nstates; i++)
     {
-      state_t *s = states[i];
+      state *s = states[i];
       if (conflicts[i])
        {
       if (conflicts[i])
        {
-         fprintf (out, _("State %d contains "), i);
-         fprintf (out, "%s.\n",
-                  conflict_report (count_sr_conflicts (s),
-                                   count_rr_conflicts (s, true)));
+         fprintf (out, _("State %d "), i);
+         conflict_report (out, count_sr_conflicts (s),
+                          count_rr_conflicts (s, true));
          printed_sth = true;
        }
     }
          printed_sth = true;
        }
     }
@@ -471,14 +432,14 @@ conflicts_output (FILE *out)
 /*--------------------------------------------------------.
 | Total the number of S/R and R/R conflicts.  Unlike the  |
 | code in conflicts_output, however, count EACH pair of   |
 /*--------------------------------------------------------.
 | Total the number of S/R and R/R conflicts.  Unlike the  |
 | code in conflicts_output, however, count EACH pair of   |
-| reductions for the same state and lookahead as one      |
+| reductions for the same state and look-ahead as one     |
 | conflict.                                              |
 `--------------------------------------------------------*/
 
 int
 conflicts_total_count (void)
 {
 | conflict.                                              |
 `--------------------------------------------------------*/
 
 int
 conflicts_total_count (void)
 {
-  state_number_t i;
+  state_number i;
   int count;
 
   /* Conflicts by state.  */
   int count;
 
   /* Conflicts by state.  */
@@ -503,14 +464,15 @@ conflicts_print (void)
   /* 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.  */
   /* 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;
+  bool src_ok = false;
+  bool rrc_ok = false;
 
   int src_total = 0;
   int rrc_total = 0;
 
   /* Conflicts by state.  */
   {
 
   int src_total = 0;
   int rrc_total = 0;
 
   /* Conflicts by state.  */
   {
-    state_number_t i;
+    state_number i;
 
     for (i = 0; i < nstates; i++)
       if (conflicts[i])
 
     for (i = 0; i < nstates; i++)
       if (conflicts[i])
@@ -520,32 +482,48 @@ conflicts_print (void)
        }
   }
 
        }
   }
 
-  src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);
+  if (! glr_parser && rrc_total > 0 && expected_rr_conflicts != -1)
+    {
+      warn (_("%%expect-rr applies only to GLR parsers"));
+      expected_rr_conflicts = -1;
+    }
+
+  src_ok =
+    src_total == (expected_sr_conflicts == -1 ? 0 : expected_sr_conflicts);
+  rrc_ok =
+    rrc_total == (expected_rr_conflicts == -1 ? 0 : expected_rr_conflicts);
 
 
-  /* If there are no RR conflicts, and as many SR conflicts as
+  /* If there are as many RR conflicts and SR conflicts as
      expected, then there is nothing to report.  */
      expected, then there is nothing to report.  */
-  if (!rrc_total && src_ok)
+  if (rrc_ok && src_ok)
     return;
 
   /* Report the total number of conflicts on STDERR.  */
     return;
 
   /* Report the total number of conflicts on STDERR.  */
-  if (yacc_flag)
-    conflict_report_yacc (src_total, rrc_total);
-  else
-    warn ("%s", conflict_report (src_total, rrc_total));
+  if (! yacc_flag)
+    fprintf (stderr, "%s: ", current_file);
+  conflict_report (stderr, src_total, rrc_total);
 
 
-  if (expected_conflicts != -1 && !src_ok)
-    complain (ngettext ("expected %d shift/reduce conflict",
+  if (expected_sr_conflicts != -1 || expected_rr_conflicts != -1)
+    {
+      int sr = expected_sr_conflicts == -1 ? 0 : expected_sr_conflicts;
+      int rr = expected_rr_conflicts == -1 ? 0 : expected_rr_conflicts;
+      if (! src_ok)
+       warn (ngettext ("expected %d shift/reduce conflict",
                        "expected %d shift/reduce conflicts",
                        "expected %d shift/reduce conflicts",
-                       expected_conflicts),
-             expected_conflicts);
+                       sr), sr);
+      if (! rrc_ok)
+       warn (ngettext ("expected %d reduce/reduce conflict",
+                       "expected %d reduce/reduce conflicts",
+                       rr), rr);
+    }
 }
 
 
 void
 conflicts_free (void)
 {
 }
 
 
 void
 conflicts_free (void)
 {
-  XFREE (conflicts);
-  bitset_free (shiftset);
-  bitset_free (lookaheadset);
+  free (conflicts);
+  bitset_free (shift_set);
+  bitset_free (look_ahead_set);
   obstack_free (&solved_conflicts_obstack, NULL);
 }
   obstack_free (&solved_conflicts_obstack, NULL);
 }