X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/be750e4c49acede25b7e0cd3a2f5b58e759583fd..57beea57768aeaae6eee4bedbecae7d295018065:/src/conflicts.c diff --git a/src/conflicts.c b/src/conflicts.c index f10c36b3..ede39690 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -1,5 +1,7 @@ /* Find and resolve or report look-ahead conflicts for bison, - Copyright 1984, 1989, 1992, 2000, 2001 Free Software Foundation, Inc. + + Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004 + Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -15,36 +17,120 @@ 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. */ + Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. */ #include "system.h" + +#include + +#include "LR0.h" #include "complain.h" -#include "getargs.h" +#include "conflicts.h" #include "files.h" +#include "getargs.h" #include "gram.h" -#include "state.h" #include "lalr.h" -#include "conflicts.h" #include "reader.h" -#include "LR0.h" +#include "state.h" +#include "symtab.h" /* -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; + +static bitset shift_set; +static bitset look_ahead_set; -static unsigned *shiftset = NULL; -static unsigned *lookaheadset = NULL; +enum conflict_resolution + { + shift_resolution, + reduce_resolution, + left_resolution, + right_resolution, + nonassoc_resolution + }; + + +/*----------------------------------------------------------------. +| Explain how an SR conflict between TOKEN and RULE was resolved: | +| RESOLUTION. | +`----------------------------------------------------------------*/ + static inline void -log_resolution (int state, int LAno, int token, char *resolution) +log_resolution (rule *r, symbol_number token, + enum conflict_resolution resolution) { - if (verbose_flag) - obstack_fgrow4 (&output_obstack, - _("\ -Conflict in state %d between rule %d and token %s resolved as %s.\n"), - state, LAruleno[LAno], tags[token], resolution); + if (report_flag & report_solved_conflicts) + { + /* The description of the resolution. */ + switch (resolution) + { + case shift_resolution: + case right_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + _("\ + Conflict between rule %d and token %s resolved as shift"), + r->number, + symbols[token]->tag); + break; + case reduce_resolution: + case left_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + _("\ + Conflict between rule %d and token %s resolved as reduce"), + 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"), + r->number, + symbols[token]->tag); + break; + } + + /* The reason. */ + switch (resolution) + { + case shift_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + " (%s < %s)", + r->prec->tag, + symbols[token]->tag); + break; + + case reduce_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + " (%s < %s)", + symbols[token]->tag, + r->prec->tag); + break; + + case left_resolution: + obstack_fgrow1 (&solved_conflicts_obstack, + " (%%left %s)", + symbols[token]->tag); + break; + + case right_resolution: + obstack_fgrow1 (&solved_conflicts_obstack, + " (%%right %s)", + symbols[token]->tag); + break; + case nonassoc_resolution: + obstack_fgrow1 (&solved_conflicts_obstack, + " (%%nonassoc %s)", + symbols[token]->tag); + break; + } + obstack_sgrow (&solved_conflicts_obstack, ".\n"); + } } @@ -55,28 +141,29 @@ Conflict in state %d between rule %d and token %s resolved as %s.\n"), `------------------------------------------------------------------*/ static void -flush_shift (int state, int token) +flush_shift (state *s, int token) { - shifts *shiftp = state_table[state]->shifts; + transitions *trans = s->transitions; 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); + 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 -flush_reduce (int lookahead, int token) +flush_reduce (bitset look_ahead_tokens, int token) { - RESETBIT (LA (lookahead), token); + bitset_reset (look_ahead_tokens, token); } @@ -85,34 +172,40 @@ flush_reduce (int lookahead, int token) | 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. | +| | +| RULENO is the number of the look-ahead bitset to consider. | +| | +| ERRORS can be used to store discovered explicit errors. | `------------------------------------------------------------------*/ static void -resolve_sr_conflict (int state, int lookahead) +resolve_sr_conflict (state *s, int ruleno, symbol **errors) { - int i; - /* find the rule to reduce by to get precedence of reduction */ - int redprec = rule_table[LAruleno[lookahead]].prec; - errs *errp = ERRS_ALLOC (ntokens + 1); - short *errtokens = errp->errs; + symbol_number i; + reductions *reds = s->reductions; + /* Find the rule to reduce by to get precedence of reduction. */ + rule *redrule = reds->rules[ruleno]; + int redprec = redrule->prec->prec; + bitset look_ahead_tokens = reds->look_ahead_tokens[ruleno]; + int nerrs = 0; for (i = 0; i < ntokens; i++) - if (BITISSET (LA (lookahead), i) - && BITISSET (lookaheadset, i) - && sprec[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 and it has a precedence. The precedence of shifting is that of token i. */ - if (sprec[i] < redprec) + if (symbols[i]->prec < redprec) { - log_resolution (state, lookahead, i, _("reduce")); - flush_shift (state, i); + log_resolution (redrule, i, reduce_resolution); + flush_shift (s, i); } - else if (sprec[i] > redprec) + else if (symbols[i]->prec > redprec) { - log_resolution (state, lookahead, i, _("shift")); - flush_reduce (lookahead, i); + log_resolution (redrule, i, shift_resolution); + flush_reduce (look_ahead_tokens, i); } else /* Matching precedence levels. @@ -120,96 +213,116 @@ resolve_sr_conflict (int state, int lookahead) For right association, keep only the shift. For nonassociation, keep neither. */ - switch (sassoc[i]) + switch (symbols[i]->assoc) { case right_assoc: - log_resolution (state, lookahead, i, _("shift")); - flush_reduce (lookahead, i); + log_resolution (redrule, i, right_resolution); + flush_reduce (look_ahead_tokens, i); break; case left_assoc: - log_resolution (state, lookahead, i, _("reduce")); - flush_shift (state, i); + log_resolution (redrule, i, left_resolution); + flush_shift (s, i); break; case non_assoc: - log_resolution (state, lookahead, i, _("an error")); - flush_shift (state, i); - flush_reduce (lookahead, i); + log_resolution (redrule, i, nonassoc_resolution); + flush_shift (s, i); + flush_reduce (look_ahead_tokens, i); /* Record an explicit error for this token. */ - *errtokens++ = i; + errors[nerrs++] = symbols[i]; break; + + case undef_assoc: + abort (); } } - errp->nerrs = errtokens - errp->errs; - /* Some tokens have been explicitly made errors. Allocate a - permanent errs structure for this state, to record them. */ - i = (char *) errtokens - (char *) errp; - state_table[state]->errs = ERRS_ALLOC (i + 1); - memcpy (state_table[state]->errs, errp, i); - free (errp); + 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'); + s->solved_conflicts = obstack_finish (&solved_conflicts_obstack); + } } +/*-------------------------------------------------------------------. +| Solve the S/R conflicts of state S using the | +| precedence/associativity, and flag it inconsistent if it still has | +| 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 -set_conflicts (int state) +set_conflicts (state *s, symbol **errors) { - int i, j; - shifts *shiftp; + int i; + transitions *trans = s->transitions; + reductions *reds = s->reductions; - if (state_table[state]->consistent) + if (s->consistent) return; - for (i = 0; i < tokensetsize; i++) - lookaheadset[i] = 0; + bitset_zero (look_ahead_set); - shiftp = state_table[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)); + 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 = 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; - } + precedence. */ + for (i = 0; i < reds->num; ++i) + if (reds->rules[i]->prec && reds->rules[i]->prec->prec + && !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 = state_table[state]->lookaheads; - i < state_table[state + 1]->lookaheads; - ++i) + for (i = 0; i < reds->num; ++i) { - for (j = 0; j < tokensetsize; ++j) - if (LA (i)[j] & lookaheadset[j]) - conflicts[state] = 1; + if (!bitset_disjoint_p (reds->look_ahead_tokens[i], look_ahead_set)) + conflicts[s->number] = 1; - for (j = 0; j < tokensetsize; ++j) - lookaheadset[j] |= LA (i)[j]; + bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]); } } + +/*----------------------------------------------------------------. +| Solve all the S/R conflicts using the precedence/associativity, | +| and flag as inconsistent the states that still have conflicts. | +`----------------------------------------------------------------*/ + void -solve_conflicts (void) +conflicts_solve (void) { - int i; + 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 = XCALLOC (unsigned, tokensetsize); - lookaheadset = XCALLOC (unsigned, tokensetsize); + 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++) - set_conflicts (i); + { + set_conflicts (states[i], errors); + + /* For uniformity of the code, make sure all the states have a valid + `errs' member. */ + if (!states[i]->errs) + states[i]->errs = errs_new (0, 0); + } + + free (errors); } @@ -218,109 +331,77 @@ solve_conflicts (void) `---------------------------------------------*/ static int -count_sr_conflicts (int state) +count_sr_conflicts (state *s) { - int i, k; + int i; int src_count = 0; - shifts *shiftp = state_table[state]->shifts; + transitions *trans = s->transitions; + reductions *reds = s->reductions; - if (!shiftp) + if (!trans) return 0; - for (i = 0; i < tokensetsize; i++) - { - shiftset[i] = 0; - lookaheadset[i] = 0; - } + bitset_zero (look_ahead_set); + bitset_zero (shift_set); - 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_EACH_SHIFT (trans, i) + bitset_set (shift_set, TRANSITION_SYMBOL (trans, i)); - for (i = state_table[state]->lookaheads; - i < state_table[state + 1]->lookaheads; - ++i) - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] |= LA (i)[k]; + for (i = 0; i < reds->num; ++i) + bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]); - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] &= shiftset[k]; + bitset_and (look_ahead_set, look_ahead_set, shift_set); - for (i = 0; i < ntokens; i++) - if (BITISSET (lookaheadset, i)) - src_count++; + src_count = bitset_count (look_ahead_set); return src_count; } -/*----------------------------------------------. -| Count the number of reduce/reduce conflicts. | -`----------------------------------------------*/ +/*----------------------------------------------------------------. +| Count the number of reduce/reduce conflicts. If ONE_PER_TOKEN, | +| count one conflict for each token that has any reduce/reduce | +| conflicts. Otherwise, count one conflict for each pair of | +| conflicting reductions. | ++`----------------------------------------------------------------*/ static int -count_rr_conflicts (int state) +count_rr_conflicts (state *s, bool one_per_token) { int i; + reductions *reds = s->reductions; int rrc_count = 0; - int m = state_table[state]->lookaheads; - int n = state_table[state + 1]->lookaheads; - - if (n - m < 2) - return 0; - for (i = 0; i < ntokens; i++) { int count = 0; int j; - for (j = m; j < n; j++) - if (BITISSET (LA (m), j)) + for (j = 0; j < reds->num; ++j) + if (bitset_test (reds->look_ahead_tokens[j], i)) count++; if (count >= 2) - rrc_count++; + rrc_count += one_per_token ? 1 : count-1; } 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'; +/*--------------------------------------------------------. +| Report the number of conflicts, using the Yacc format. | +`--------------------------------------------------------*/ - return res; +static void +conflict_report (FILE *out, int src_num, int rrc_num) +{ + 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); } @@ -331,18 +412,45 @@ conflict_report (int src_num, int rrc_num) void conflicts_output (FILE *out) { - bool printed_sth = FALSE; - int i; + bool printed_sth = false; + state_number i; + for (i = 0; i < nstates; i++) + { + state *s = states[i]; + if (conflicts[i]) + { + fprintf (out, _("State %d "), i); + conflict_report (out, count_sr_conflicts (s), + count_rr_conflicts (s, true)); + printed_sth = true; + } + } + if (printed_sth) + fputs ("\n\n", out); +} + +/*--------------------------------------------------------. +| 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 look-ahead as one | +| conflict. | +`--------------------------------------------------------*/ + +int +conflicts_total_count (void) +{ + state_number i; + int count; + + /* Conflicts by state. */ + count = 0; 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); - printed_sth = TRUE; + count += count_sr_conflicts (states[i]); + count += count_rr_conflicts (states[i], false); } - if (printed_sth) - fputs ("\n\n", out); + return count; } @@ -353,198 +461,69 @@ conflicts_output (FILE *out) 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; + bool src_ok = false; + bool rrc_ok = false; 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; + { + state_number i; - /* 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); - } + for (i = 0; i < nstates; i++) + if (conflicts[i]) + { + src_total += count_sr_conflicts (states[i]); + rrc_total += count_rr_conflicts (states[i], true); + } + } - if (expected_conflicts != -1 && !src_ok) + if (! glr_parser && rrc_total > 0 && expected_rr_conflicts != -1) { - complain_message_count++; - fprintf (stderr, ngettext ("expected %d shift/reduce conflict\n", - "expected %d shift/reduce conflicts\n", - expected_conflicts), - expected_conflicts); + warn (_("%%expect-rr applies only to GLR parsers")); + expected_rr_conflicts = -1; } -} - - -void -print_reductions (FILE *out, int state) -{ - int i; - int j; - int m = state_table[state]->lookaheads; - int n = state_table[state + 1]->lookaheads; - shifts *shiftp = state_table[state]->shifts; - errs *errp = state_table[state]->errs; - int nodefault = 0; - - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; - - 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; - SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); - } - - if (errp) - for (i = 0; i < errp->nerrs; i++) - if (errp->errs[i]) - SETBIT (shiftset, errp->errs[i]); - if (n - m == 1 && !nodefault) - { - int k; - int default_rule = LAruleno[m]; + src_ok = + src_total == (expected_sr_conflicts == -1 ? 0 : expected_sr_conflicts); + rrc_ok = + rrc_total == (expected_rr_conflicts == -1 ? 0 : expected_rr_conflicts); - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] = LA (m)[k] & shiftset[k]; + /* If there are as many RR conflicts and SR conflicts as + expected, then there is nothing to report. */ + if (rrc_ok && src_ok) + return; - for (i = 0; i < ntokens; i++) - if (BITISSET (lookaheadset, i)) - fprintf (out, _(" %-4s\t[reduce using rule %d (%s)]\n"), - tags[i], default_rule, - tags[rule_table[default_rule].lhs]); + /* Report the total number of conflicts on STDERR. */ + if (! yacc_flag) + fprintf (stderr, "%s: ", current_file); + conflict_report (stderr, src_total, rrc_total); - fprintf (out, _(" $default\treduce using rule %d (%s)\n\n"), - default_rule, tags[rule_table[default_rule].lhs]); - } - else if (n - m >= 1) + if (expected_sr_conflicts != -1 || expected_rr_conflicts != -1) { - int k; - - int cmax = 0; - int default_LA = -1; - int default_rule = 0; - - if (!nodefault) - for (i = m; i < n; i++) - { - int count = 0; - - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] = LA (i)[k] & ~shiftset[k]; - - for (j = 0; j < ntokens; j++) - if (BITISSET (lookaheadset, j)) - count++; - - if (count > cmax) - { - cmax = count; - default_LA = i; - default_rule = LAruleno[i]; - } - - for (k = 0; k < tokensetsize; ++k) - shiftset[k] |= lookaheadset[k]; - } - - for (i = 0; i < tokensetsize; i++) - shiftset[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 < ntokens; i++) - { - int defaulted = 0; - int count = BITISSET (shiftset, i); - - for (j = m; j < n; j++) - { - if (BITISSET (LA (m), j)) - { - if (count == 0) - { - if (j != default_LA) - fprintf (out, - _(" %-4s\treduce using rule %d (%s)\n"), - tags[i], - LAruleno[j], - tags[rule_table[LAruleno[j]].lhs]); - else - defaulted = 1; - - count++; - } - else - { - if (defaulted) - fprintf (out, - _(" %-4s\treduce using rule %d (%s)\n"), - tags[i], - LAruleno[default_LA], - tags[rule_table[LAruleno[default_LA]].lhs]); - defaulted = 0; - fprintf (out, - _(" %-4s\t[reduce using rule %d (%s)]\n"), - tags[i], - LAruleno[j], - tags[rule_table[LAruleno[j]].lhs]); - } - } - } - } - - if (default_LA >= 0) - fprintf (out, _(" $default\treduce using rule %d (%s)\n"), - default_rule, tags[rule_table[default_rule].lhs]); + 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", + sr), sr); + if (! rrc_ok) + warn (ngettext ("expected %d reduce/reduce conflict", + "expected %d reduce/reduce conflicts", + rr), rr); } } void -free_conflicts (void) +conflicts_free (void) { - XFREE (conflicts); - XFREE (shiftset); - XFREE (lookaheadset); + free (conflicts); + bitset_free (shift_set); + bitset_free (look_ahead_set); + obstack_free (&solved_conflicts_obstack, NULL); }