src/conflicts.c

/* Find and resolve or report look-ahead conflicts for bison,
   Copyright 1984, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.

   This file is part of Bison, the GNU Compiler Compiler.

   Bison is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   Bison is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with Bison; see the file COPYING.  If not, write to the Free
   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

#include "system.h"
#include "complain.h"
#include "getargs.h"
#include "files.h"
#include "gram.h"
#include "state.h"
#include "lalr.h"
#include "conflicts.h"
#include "reader.h"
#include "LR0.h"

/* -1 stands for not specified. */
int expected_conflicts = -1;
static char *conflicts = NULL;

static unsigned *shiftset = NULL;
static unsigned *lookaheadset = NULL;
\f

static inline void
log_resolution (state_t *state, int LAno, int token, char *resolution)
{
  if (verbose_flag)
    obstack_fgrow4 (&output_obstack,
		    _("\
Conflict in state %d between rule %d and token %s resolved as %s.\n"),
		    state->number, 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
flush_shift (state_t *state, int token)
{
  shifts *shiftp = state->shifts;
  int i;

  RESETBIT (lookaheadset, token);
  for (i = 0; i < shiftp->nshifts; i++)
    if (!SHIFT_IS_DISABLED (shiftp, i) && SHIFT_SYMBOL (shiftp, i) == token)
      SHIFT_DISABLE (shiftp, 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.                                             |
`-------------------------------------------------------------------*/

static void
flush_reduce (int lookahead, int token)
{
  RESETBIT (LA (lookahead), token);
}


/*------------------------------------------------------------------.
| 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 (state_t *state, int lookahead)
{
  int i;
  /* find the rule to reduce by to get precedence of reduction  */
  int redprec = rule_table[LAruleno[lookahead]].prec;
  errs *errp = errs_new (ntokens + 1);
  errp->nerrs = 0;

  for (i = 0; i < ntokens; i++)
    if (BITISSET (LA (lookahead), i)
	&& BITISSET (lookaheadset, i)
	&& sprec[i])
      {
	/* Shift-reduce conflict occurs for token number i
	   and it has a precedence.
	   The precedence of shifting is that of token i.  */
	if (sprec[i] < redprec)
	  {
	    log_resolution (state, lookahead, i, _("reduce"));
	    flush_shift (state, i);
	  }
	else if (sprec[i] > redprec)
	  {
	    log_resolution (state, lookahead, i, _("shift"));
	    flush_reduce (lookahead, i);
	  }
	else
	  /* Matching precedence levels.
	     For left association, keep only the reduction.
	     For right association, keep only the shift.
	     For nonassociation, keep neither.  */

	  switch (sassoc[i])
	    {
	    case right_assoc:
	      log_resolution (state, lookahead, i, _("shift"));
	      flush_reduce (lookahead, i);
	      break;

	    case left_assoc:
	      log_resolution (state, lookahead, i, _("reduce"));
	      flush_shift (state, i);
	      break;

	    case non_assoc:
	      log_resolution (state, lookahead, i, _("an error"));
	      flush_shift (state, i);
	      flush_reduce (lookahead, i);
	      /* Record an explicit error for this token.  */
	      errp->errs[errp->nerrs++] = i;
	      break;
	    }
      }

  /* Some tokens have been explicitly made errors.  Allocate a
     permanent errs structure for this state, to record them.  */
  state->errs = errs_dup (errp);
  free (errp);
}


static void
set_conflicts (state_t *state)
{
  int i, j;
  shifts *shiftp;

  if (state->consistent)
    return;

  for (i = 0; i < tokensetsize; i++)
    lookaheadset[i] = 0;

  shiftp = state->shifts;
  for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
    if (!SHIFT_IS_DISABLED (shiftp, i))
      SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, 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 = 0; i < state->nlookaheads; ++i)
    if (rule_table[LAruleno[state->lookaheadsp + i]].prec)
      for (j = 0; j < tokensetsize; ++j)
	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
	  {
	    resolve_sr_conflict (state, state->lookaheadsp + i);
	    break;
	  }


  /* Loop over all rules which require lookahead in this state.  Check
     for conflicts not resolved above.  */
  for (i = 0; i < state->nlookaheads; ++i)
    {
      for (j = 0; j < tokensetsize; ++j)
	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
	  conflicts[state->number] = 1;

      for (j = 0; j < tokensetsize; ++j)
	lookaheadset[j] |= LA (state->lookaheadsp + i)[j];
    }
}

void
solve_conflicts (void)
{
  int i;

  conflicts = XCALLOC (char, nstates);
  shiftset = XCALLOC (unsigned, tokensetsize);
  lookaheadset = XCALLOC (unsigned, tokensetsize);

  for (i = 0; i < nstates; i++)
    set_conflicts (state_table[i]);
}


/*---------------------------------------------.
| Count the number of shift/reduce conflicts.  |
`---------------------------------------------*/

static int
count_sr_conflicts (state_t *state)
{
  int i, k;
  int src_count = 0;
  shifts *shiftp = state->shifts;

  if (!shiftp)
    return 0;

  for (i = 0; i < tokensetsize; i++)
    {
      shiftset[i] = 0;
      lookaheadset[i] = 0;
    }

  for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
    if (!SHIFT_IS_DISABLED (shiftp, i))
      SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));

  for (i = 0; i < state->nlookaheads; ++i)
    for (k = 0; k < tokensetsize; ++k)
      lookaheadset[k] |= LA (state->lookaheadsp + i)[k];

  for (k = 0; k < tokensetsize; ++k)
    lookaheadset[k] &= shiftset[k];

  for (i = 0; i < ntokens; i++)
    if (BITISSET (lookaheadset, i))
      src_count++;

  return src_count;
}


/*----------------------------------------------.
| Count the number of reduce/reduce conflicts.  |
`----------------------------------------------*/

static int
count_rr_conflicts (state_t *state)
{
  int i;
  int rrc_count = 0;

  if (state->nlookaheads < 2)
    return 0;

  for (i = 0; i < ntokens; i++)
    {
      int count = 0;
      int j;
      for (j = 0; j < state->nlookaheads; ++j)
	if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j))
	  count++;

      if (count >= 2)
	rrc_count++;
    }

  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)
{
  bool printed_sth = FALSE;
  int i;
  for (i = 0; i < nstates; i++)
    if (conflicts[i])
      {
	fprintf (out, _("State %d contains "), i);
	fputs (conflict_report (count_sr_conflicts (state_table[i]),
				count_rr_conflicts (state_table[i])), out);
	printed_sth = TRUE;
      }
  if (printed_sth)
    fputs ("\n\n", 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 (state_table[i]);
	rrc_total += count_rr_conflicts (state_table[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
free_conflicts (void)
{
  XFREE (conflicts);
  XFREE (shiftset);
  XFREE (lookaheadset);
}
Commit	Line	Data
	1	/* Find and resolve or report look-ahead conflicts for bison,
	2	Copyright 1984, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.
	3
	4	This file is part of Bison, the GNU Compiler Compiler.
	5
	6	Bison is free software; you can redistribute it and/or modify it
	7	under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	Bison is distributed in the hope that it will be useful, but
	12	WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with Bison; see the file COPYING. If not, write to the Free
	18	Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	19	02111-1307, USA. */
	20
	21	#include "system.h"
	22	#include "complain.h"
	23	#include "getargs.h"
	24	#include "files.h"
	25	#include "gram.h"
	26	#include "state.h"
	27	#include "lalr.h"
	28	#include "conflicts.h"
	29	#include "reader.h"
	30	#include "LR0.h"
	31
	32	/* -1 stands for not specified. */
	33	int expected_conflicts = -1;
	34	static char *conflicts = NULL;
	35
	36	static unsigned *shiftset = NULL;
	37	static unsigned *lookaheadset = NULL;
	38	\f
	39
	40	static inline void
	41	log_resolution (state_t state, int LAno, int token, char resolution)
	42	{
	43	if (verbose_flag)
	44	obstack_fgrow4 (&output_obstack,
	45	_("\
	46	Conflict in state %d between rule %d and token %s resolved as %s.\n"),
	47	state->number, LAruleno[LAno], tags[token], resolution);
	48	}
	49
	50
	51	/*------------------------------------------------------------------.
	52	\| Turn off the shift recorded for the specified token in the \|
	53	\| specified state. Used when we resolve a shift-reduce conflict in \|
	54	\| favor of the reduction. \|
	55	`------------------------------------------------------------------*/
	56
	57	static void
	58	flush_shift (state_t *state, int token)
	59	{
	60	shifts *shiftp = state->shifts;
	61	int i;
	62
	63	RESETBIT (lookaheadset, token);
	64	for (i = 0; i < shiftp->nshifts; i++)
	65	if (!SHIFT_IS_DISABLED (shiftp, i) && SHIFT_SYMBOL (shiftp, i) == token)
	66	SHIFT_DISABLE (shiftp, i);
	67	}
	68
	69
	70	/*-------------------------------------------------------------------.
	71	\| Turn off the reduce recorded for the specified token for the \|
	72	\| specified lookahead. Used when we resolve a shift-reduce conflict \|
	73	\| in favor of the shift. \|
	74	`-------------------------------------------------------------------*/
	75
	76	static void
	77	flush_reduce (int lookahead, int token)
	78	{
	79	RESETBIT (LA (lookahead), token);
	80	}
	81
	82
	83	/*------------------------------------------------------------------.
	84	\| Attempt to resolve shift-reduce conflict for one rule by means of \|
	85	\| precedence declarations. It has already been checked that the \|
	86	\| rule has a precedence. A conflict is resolved by modifying the \|
	87	\| shift or reduce tables so that there is no longer a conflict. \|
	88	`------------------------------------------------------------------*/
	89
	90	static void
	91	resolve_sr_conflict (state_t *state, int lookahead)
	92	{
	93	int i;
	94	/* find the rule to reduce by to get precedence of reduction */
	95	int redprec = rule_table[LAruleno[lookahead]].prec;
	96	errs *errp = errs_new (ntokens + 1);
	97	errp->nerrs = 0;
	98
	99	for (i = 0; i < ntokens; i++)
	100	if (BITISSET (LA (lookahead), i)
	101	&& BITISSET (lookaheadset, i)
	102	&& sprec[i])
	103	{
	104	/* Shift-reduce conflict occurs for token number i
	105	and it has a precedence.
	106	The precedence of shifting is that of token i. */
	107	if (sprec[i] < redprec)
	108	{
	109	log_resolution (state, lookahead, i, _("reduce"));
	110	flush_shift (state, i);
	111	}
	112	else if (sprec[i] > redprec)
	113	{
	114	log_resolution (state, lookahead, i, _("shift"));
	115	flush_reduce (lookahead, i);
	116	}
	117	else
	118	/* Matching precedence levels.
	119	For left association, keep only the reduction.
	120	For right association, keep only the shift.
	121	For nonassociation, keep neither. */
	122
	123	switch (sassoc[i])
	124	{
	125	case right_assoc:
	126	log_resolution (state, lookahead, i, _("shift"));
	127	flush_reduce (lookahead, i);
	128	break;
	129
	130	case left_assoc:
	131	log_resolution (state, lookahead, i, _("reduce"));
	132	flush_shift (state, i);
	133	break;
	134
	135	case non_assoc:
	136	log_resolution (state, lookahead, i, _("an error"));
	137	flush_shift (state, i);
	138	flush_reduce (lookahead, i);
	139	/* Record an explicit error for this token. */
	140	errp->errs[errp->nerrs++] = i;
	141	break;
	142	}
	143	}
	144
	145	/* Some tokens have been explicitly made errors. Allocate a
	146	permanent errs structure for this state, to record them. */
	147	state->errs = errs_dup (errp);
	148	free (errp);
	149	}
	150
	151
	152	static void
	153	set_conflicts (state_t *state)
	154	{
	155	int i, j;
	156	shifts *shiftp;
	157
	158	if (state->consistent)
	159	return;
	160
	161	for (i = 0; i < tokensetsize; i++)
	162	lookaheadset[i] = 0;
	163
	164	shiftp = state->shifts;
	165	for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
	166	if (!SHIFT_IS_DISABLED (shiftp, i))
	167	SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));
	168
	169	/* Loop over all rules which require lookahead in this state. First
	170	check for shift-reduce conflict, and try to resolve using
	171	precedence */
	172	for (i = 0; i < state->nlookaheads; ++i)
	173	if (rule_table[LAruleno[state->lookaheadsp + i]].prec)
	174	for (j = 0; j < tokensetsize; ++j)
	175	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
	176	{
	177	resolve_sr_conflict (state, state->lookaheadsp + i);
	178	break;
	179	}
	180
	181
	182	/* Loop over all rules which require lookahead in this state. Check
	183	for conflicts not resolved above. */
	184	for (i = 0; i < state->nlookaheads; ++i)
	185	{
	186	for (j = 0; j < tokensetsize; ++j)
	187	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
	188	conflicts[state->number] = 1;
	189
	190	for (j = 0; j < tokensetsize; ++j)
	191	lookaheadset[j] \|= LA (state->lookaheadsp + i)[j];
	192	}
	193	}
	194
	195	void
	196	solve_conflicts (void)
	197	{
	198	int i;
	199
	200	conflicts = XCALLOC (char, nstates);
	201	shiftset = XCALLOC (unsigned, tokensetsize);
	202	lookaheadset = XCALLOC (unsigned, tokensetsize);
	203
	204	for (i = 0; i < nstates; i++)
	205	set_conflicts (state_table[i]);
	206	}
	207
	208
	209	/*---------------------------------------------.
	210	\| Count the number of shift/reduce conflicts. \|
	211	`---------------------------------------------*/
	212
	213	static int
	214	count_sr_conflicts (state_t *state)
	215	{
	216	int i, k;
	217	int src_count = 0;
	218	shifts *shiftp = state->shifts;
	219
	220	if (!shiftp)
	221	return 0;
	222
	223	for (i = 0; i < tokensetsize; i++)
	224	{
	225	shiftset[i] = 0;
	226	lookaheadset[i] = 0;
	227	}
	228
	229	for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
	230	if (!SHIFT_IS_DISABLED (shiftp, i))
	231	SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
	232
	233	for (i = 0; i < state->nlookaheads; ++i)
	234	for (k = 0; k < tokensetsize; ++k)
	235	lookaheadset[k] \|= LA (state->lookaheadsp + i)[k];
	236
	237	for (k = 0; k < tokensetsize; ++k)
	238	lookaheadset[k] &= shiftset[k];
	239
	240	for (i = 0; i < ntokens; i++)
	241	if (BITISSET (lookaheadset, i))
	242	src_count++;
	243
	244	return src_count;
	245	}
	246
	247
	248	/*----------------------------------------------.
	249	\| Count the number of reduce/reduce conflicts. \|
	250	`----------------------------------------------*/
	251
	252	static int
	253	count_rr_conflicts (state_t *state)
	254	{
	255	int i;
	256	int rrc_count = 0;
	257
	258	if (state->nlookaheads < 2)
	259	return 0;
	260
	261	for (i = 0; i < ntokens; i++)
	262	{
	263	int count = 0;
	264	int j;
	265	for (j = 0; j < state->nlookaheads; ++j)
	266	if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j))
	267	count++;
	268
	269	if (count >= 2)
	270	rrc_count++;
	271	}
	272
	273	return rrc_count;
	274	}
	275
	276	/*--------------------------------------------------------------.
	277	\| Return a human readable string which reports shift/reduce and \|
	278	\| reduce/reduce conflict numbers (SRC_NUM, RRC_NUM). \|
	279	`--------------------------------------------------------------*/
	280
	281	static const char *
	282	conflict_report (int src_num, int rrc_num)
	283	{
	284	static char res[4096];
	285	char *cp = res;
	286
	287	if (src_num >= 1)
	288	{
	289	sprintf (cp, ngettext ("%d shift/reduce conflict",
	290	"%d shift/reduce conflicts", src_num), src_num);
	291	cp += strlen (cp);
	292	}
	293
	294	if (src_num > 0 && rrc_num > 0)
	295	{
	296	sprintf (cp, " %s ", _("and"));
	297	cp += strlen (cp);
	298	}
	299
	300	if (rrc_num >= 1)
	301	{
	302	sprintf (cp, ngettext ("%d reduce/reduce conflict",
	303	"%d reduce/reduce conflicts", rrc_num), rrc_num);
	304	cp += strlen (cp);
	305	}
	306
	307	*cp++ = '.';
	308	*cp++ = '\n';
	309	*cp++ = '\0';
	310
	311	return res;
	312	}
	313
	314
	315	/*-----------------------------------------------------------.
	316	\| Output the detailed description of states with conflicts. \|
	317	`-----------------------------------------------------------*/
	318
	319	void
	320	conflicts_output (FILE *out)
	321	{
	322	bool printed_sth = FALSE;
	323	int i;
	324	for (i = 0; i < nstates; i++)
	325	if (conflicts[i])
	326	{
	327	fprintf (out, _("State %d contains "), i);
	328	fputs (conflict_report (count_sr_conflicts (state_table[i]),
	329	count_rr_conflicts (state_table[i])), out);
	330	printed_sth = TRUE;
	331	}
	332	if (printed_sth)
	333	fputs ("\n\n", out);
	334	}
	335
	336
	337	/*------------------------------------------.
	338	\| Reporting the total number of conflicts. \|
	339	`------------------------------------------*/
	340
	341	void
	342	conflicts_print (void)
	343	{
	344	int i;
	345
	346	/* Is the number of SR conflicts OK? Either EXPECTED_CONFLICTS is
	347	not set, and then we want 0 SR, or else it is specified, in which
	348	case we want equality. */
	349	int src_ok = 0;
	350
	351	int src_total = 0;
	352	int rrc_total = 0;
	353
	354	/* Conflicts by state. */
	355	for (i = 0; i < nstates; i++)
	356	if (conflicts[i])
	357	{
	358	src_total += count_sr_conflicts (state_table[i]);
	359	rrc_total += count_rr_conflicts (state_table[i]);
	360	}
	361
	362	src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);
	363
	364	/* If there are no RR conflicts, and as many SR conflicts as
	365	expected, then there is nothing to report. */
	366	if (!rrc_total && src_ok)
	367	return;
	368
	369	/* Report the total number of conflicts on STDERR. */
	370	if (yacc_flag)
	371	{
	372	/* If invoked with `--yacc', use the output format specified by
	373	POSIX. */
	374	fprintf (stderr, _("conflicts: "));
	375	if (src_total > 0)
	376	fprintf (stderr, _(" %d shift/reduce"), src_total);
	377	if (src_total > 0 && rrc_total > 0)
	378	fprintf (stderr, ",");
	379	if (rrc_total > 0)
	380	fprintf (stderr, _(" %d reduce/reduce"), rrc_total);
	381	putc ('\n', stderr);
	382	}
	383	else
	384	{
	385	fprintf (stderr, _("%s contains "), infile);
	386	fputs (conflict_report (src_total, rrc_total), stderr);
	387	}
	388
	389	if (expected_conflicts != -1 && !src_ok)
	390	{
	391	complain_message_count++;
	392	fprintf (stderr, ngettext ("expected %d shift/reduce conflict\n",
	393	"expected %d shift/reduce conflicts\n",
	394	expected_conflicts),
	395	expected_conflicts);
	396	}
	397	}
	398
	399
	400	void
	401	free_conflicts (void)
	402	{
	403	XFREE (conflicts);
	404	XFREE (shiftset);
	405	XFREE (lookaheadset);
	406	}