X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/cd08e51edafa326fd8a6327f0b659fdbceb24dda..2c2035282c525f1474bb2d4ce20a45c183aae93f:/src/conflicts.c diff --git a/src/conflicts.c b/src/conflicts.c index 1c24d7e2..98959cff 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -1,48 +1,53 @@ -/* Find and resolve or report look-ahead conflicts for bison, - Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002 - Free Software Foundation, Inc. +/* Find and resolve or report lookahead conflicts for bison, + + Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004, 2005, + 2006, 2007, 2009 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. + This program 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 3 of the License, 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. + This program 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. */ + along with this program. If not, see . */ +#include #include "system.h" -#include "bitset.h" + +#include + +#include "LR0.h" #include "complain.h" -#include "getargs.h" -#include "symtab.h" +#include "conflicts.h" #include "files.h" +#include "getargs.h" #include "gram.h" -#include "state.h" #include "lalr.h" -#include "conflicts.h" +#include "print-xml.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; -struct obstack solved_conflicts_obstack; +int expected_sr_conflicts = -1; +int expected_rr_conflicts = -1; +static char *conflicts; +static struct obstack solved_conflicts_obstack; +static struct obstack solved_conflicts_xml_obstack; -static bitset shiftset; -static bitset lookaheadset; +static bitset shift_set; +static bitset lookahead_set; -enum conflict_resolution_e +enum conflict_resolution { shift_resolution, reduce_resolution, @@ -58,8 +63,8 @@ enum conflict_resolution_e `----------------------------------------------------------------*/ 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) { @@ -69,24 +74,26 @@ log_resolution (rule_t *rule, symbol_number_t token, case shift_resolution: case right_resolution: obstack_fgrow2 (&solved_conflicts_obstack, - _("\ - Conflict between rule %d and token %s resolved as shift"), - rule->number, + _(" 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"), - rule->number, + _(" 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"), - rule->number, + _(" Conflict between rule %d and token %s" + " resolved as an error"), + r->number, symbols[token]->tag); break; } @@ -97,7 +104,7 @@ log_resolution (rule_t *rule, symbol_number_t token, case shift_resolution: obstack_fgrow2 (&solved_conflicts_obstack, " (%s < %s)", - rule->prec->tag, + r->prec->tag, symbols[token]->tag); break; @@ -105,7 +112,7 @@ log_resolution (rule_t *rule, symbol_number_t token, obstack_fgrow2 (&solved_conflicts_obstack, " (%s < %s)", symbols[token]->tag, - rule->prec->tag); + r->prec->tag); break; case left_resolution: @@ -119,47 +126,121 @@ log_resolution (rule_t *rule, symbol_number_t token, " (%%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"); } + + /* XML report */ + if (xml_flag) + { + /* The description of the resolution. */ + switch (resolution) + { + case shift_resolution: + case right_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + + case reduce_resolution: + case left_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + + case nonassoc_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + } + + /* The reason. */ + switch (resolution) + { + case shift_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + "%s < %s", + xml_escape_n (0, r->prec->tag), + xml_escape_n (1, symbols[token]->tag)); + break; + + case reduce_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + "%s < %s", + xml_escape_n (0, symbols[token]->tag), + xml_escape_n (1, r->prec->tag)); + break; + + case left_resolution: + obstack_fgrow1 (&solved_conflicts_xml_obstack, + "%%left %s", + xml_escape (symbols[token]->tag)); + break; + + case right_resolution: + obstack_fgrow1 (&solved_conflicts_xml_obstack, + "%%right %s", + xml_escape (symbols[token]->tag)); + break; + + case nonassoc_resolution: + obstack_fgrow1 (&solved_conflicts_xml_obstack, + "%%nonassoc %s", + xml_escape (symbols[token]->tag)); + break; + } + + obstack_sgrow (&solved_conflicts_xml_obstack, "\n"); + } } /*------------------------------------------------------------------. | 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. | +| favor of the reduction or as an error (%nonassoc). | `------------------------------------------------------------------*/ 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; - 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 (lookahead_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 in the | +| specified lookahead set. Used when we resolve a shift-reduce | +| conflict in favor of the shift or as an error (%nonassoc). | +`--------------------------------------------------------------------*/ static void -flush_reduce (bitset lookaheads, int token) +flush_reduce (bitset lookahead_tokens, int token) { - bitset_reset (lookaheads, token); + bitset_reset (lookahead_tokens, token); } @@ -169,26 +250,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. | | | -| LOOKAHEAD is the number of the lookahead bitset to consider. | +| RULENO is the number of the lookahead bitset to consider. | | | -| ERRS can be used to store discovered explicit errors. | +| ERRORS and NERRS can be used to store discovered explicit | +| errors. | `------------------------------------------------------------------*/ static void -resolve_sr_conflict (state_t *state, int ruleno, - symbol_t **errs) +resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs) { - 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. */ - rule_t *redrule = reds->rules[ruleno]; + rule *redrule = reds->rules[ruleno]; int redprec = redrule->prec->prec; - bitset lookaheads = reds->lookaheads[ruleno]; - int nerrs = 0; + bitset lookahead_tokens = reds->lookahead_tokens[ruleno]; for (i = 0; i < ntokens; i++) - if (bitset_test (lookaheads, i) - && bitset_test (lookaheadset, i) + if (bitset_test (lookahead_tokens, i) + && bitset_test (lookahead_set, i) && symbols[i]->prec) { /* Shift-reduce conflict occurs for token number i @@ -197,12 +277,12 @@ resolve_sr_conflict (state_t *state, int ruleno, 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); - flush_reduce (lookaheads, i); + flush_reduce (lookahead_tokens, i); } else /* Matching precedence levels. @@ -212,83 +292,86 @@ resolve_sr_conflict (state_t *state, int ruleno, switch (symbols[i]->assoc) { + default: + abort (); + case right_assoc: log_resolution (redrule, i, right_resolution); - flush_reduce (lookaheads, i); + flush_reduce (lookahead_tokens, i); 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); - flush_shift (state, i); - flush_reduce (lookaheads, i); + flush_shift (s, i); + flush_reduce (lookahead_tokens, i); /* Record an explicit error for this token. */ - errs[nerrs++] = symbols[i]; - break; - - case undef_assoc: - assert (symbols[i]->assoc != undef_assoc); + errors[(*nerrs)++] = symbols[i]; break; } } - - /* 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 (obstack_object_size (&solved_conflicts_obstack)) - { - obstack_1grow (&solved_conflicts_obstack, '\0'); - state->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 | -| conflicts. ERRS can be used as storage to compute the list of | -| lookaheads on which this STATE raises a parse error (%nonassoc). | +| conflicts. ERRORS can be used as storage to compute the list of | +| lookahead tokens on which S raises a syntax error (%nonassoc). | `-------------------------------------------------------------------*/ static void -set_conflicts (state_t *state, symbol_t **errs) +set_conflicts (state *s, symbol **errors) { int i; - transitions_t *transitions = state->transitions; - reductions_t *reds = state->reductions; + transitions *trans = s->transitions; + reductions *reds = s->reductions; + int nerrs = 0; - if (state->consistent) + if (s->consistent) return; - bitset_zero (lookaheadset); + bitset_zero (lookahead_set); - FOR_EACH_SHIFT (transitions, i) - bitset_set (lookaheadset, TRANSITION_SYMBOL (transitions, i)); + FOR_EACH_SHIFT (trans, i) + bitset_set (lookahead_set, TRANSITION_SYMBOL (trans, 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 < 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->lookahead_tokens[i], lookahead_set)) + resolve_sr_conflict (s, i, errors, &nerrs); + + 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); + } + if (obstack_object_size (&solved_conflicts_xml_obstack)) + { + obstack_1grow (&solved_conflicts_xml_obstack, '\0'); + s->solved_conflicts_xml = obstack_finish (&solved_conflicts_xml_obstack); + } /* Loop over all rules which require lookahead in this state. Check for conflicts not resolved above. */ for (i = 0; i < reds->num; ++i) { - if (!bitset_disjoint_p (reds->lookaheads[i], lookaheadset)) - conflicts[state->number] = 1; - - bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]); + if (!bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set)) + conflicts[s->number] = 1; + bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]); } } @@ -301,18 +384,19 @@ set_conflicts (state_t *state, symbol_t **errs) void conflicts_solve (void) { - state_number_t i; - /* List of lookaheads on which we explicitly raise a parse error. */ - symbol_t **errs = XMALLOC (symbol_t *, ntokens + 1); + state_number i; + /* List of lookahead 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); + lookahead_set = bitset_create (ntokens, BITSET_FIXED); obstack_init (&solved_conflicts_obstack); + obstack_init (&solved_conflicts_xml_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. */ @@ -320,7 +404,18 @@ conflicts_solve (void) states[i]->errs = errs_new (0, 0); } - free (errs); + free (errors); +} + + +void +conflicts_update_state_numbers (state_number old_to_new[], + state_number nstates_old) +{ + state_number i; + for (i = 0; i < nstates_old; ++i) + if (old_to_new[i] != nstates_old) + conflicts[old_to_new[i]] = conflicts[i]; } @@ -329,28 +424,28 @@ conflicts_solve (void) `---------------------------------------------*/ static int -count_sr_conflicts (state_t *state) +count_sr_conflicts (state *s) { 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; - bitset_zero (lookaheadset); - bitset_zero (shiftset); + bitset_zero (lookahead_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) - bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]); + bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]); - bitset_and (lookaheadset, lookaheadset, shiftset); + bitset_and (lookahead_set, lookahead_set, shift_set); - src_count = bitset_count (lookaheadset); + src_count = bitset_count (lookahead_set); return src_count; } @@ -364,10 +459,10 @@ count_sr_conflicts (state_t *state) +`----------------------------------------------------------------*/ static int -count_rr_conflicts (state_t *state, int one_per_token) +count_rr_conflicts (state *s, bool one_per_token) { int i; - reductions_t *reds = state->reductions; + reductions *reds = s->reductions; int rrc_count = 0; for (i = 0; i < ntokens; i++) @@ -375,7 +470,7 @@ count_rr_conflicts (state_t *state, int one_per_token) int count = 0; int j; for (j = 0; j < reds->num; ++j) - if (bitset_test (reds->lookaheads[j], i)) + if (bitset_test (reds->lookahead_tokens[j], i)) count++; if (count >= 2) @@ -386,60 +481,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 -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); } @@ -450,44 +505,21 @@ conflict_report_yacc (int src_num, int rrc_num) void conflicts_output (FILE *out) { - bool printed_sth = FALSE; - bool *used_rules = XCALLOC (bool, nrules); - state_number_t i; + bool printed_sth = false; + state_number i; for (i = 0; i < nstates; i++) { - state_t *s = states[i]; - reductions_t *reds = s->reductions; - int j; - for (j = 0; j < reds->num; ++j) - used_rules[reds->rules[j]->number] = TRUE; + state *s = states[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))); - printed_sth = TRUE; + 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); - - for (i = 0; i < nstates; i++) - { - state_t *s = states[i]; - reductions_t *r = s->reductions; - int j; - for (j = 0; j < r->num; ++j) - if (!used_rules[r->rules[j]->number]) - { - LOCATION_PRINT (stderr, r->rules[j]->location); - fprintf (stderr, ": %s: %s: ", - _("warning"), - _("rule never reduced because of conflicts")); - rule_print (r->rules[j], stderr); - } - } - free (used_rules); } /*--------------------------------------------------------. @@ -500,7 +532,7 @@ conflicts_output (FILE *out) int conflicts_total_count (void) { - state_number_t i; + state_number i; int count; /* Conflicts by state. */ @@ -509,7 +541,7 @@ conflicts_total_count (void) if (conflicts[i]) { count += count_sr_conflicts (states[i]); - count += count_rr_conflicts (states[i], FALSE); + count += count_rr_conflicts (states[i], false); } return count; } @@ -525,49 +557,72 @@ 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. */ - int src_ok = 0; + bool src_ok; + bool rrc_ok; int src_total = 0; int rrc_total = 0; + int src_expected; + int rrc_expected; /* Conflicts by state. */ { - state_number_t i; + state_number i; for (i = 0; i < nstates; i++) if (conflicts[i]) { src_total += count_sr_conflicts (states[i]); - rrc_total += count_rr_conflicts (states[i], TRUE); + rrc_total += count_rr_conflicts (states[i], true); } } - 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_expected = expected_sr_conflicts == -1 ? 0 : expected_sr_conflicts; + rrc_expected = expected_rr_conflicts == -1 ? 0 : expected_rr_conflicts; + src_ok = src_total == src_expected; + rrc_ok = rrc_total == rrc_expected; - /* 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. */ - if (!rrc_total && src_ok) + if (rrc_ok & src_ok) 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 (expected_conflicts != -1 && !src_ok) - complain (ngettext ("expected %d shift/reduce conflict", - "expected %d shift/reduce conflicts", - expected_conflicts), - expected_conflicts); + if (src_total | rrc_total) + { + if (! yacc_flag) + fprintf (stderr, "%s: ", current_file); + conflict_report (stderr, src_total, rrc_total); + } + + if (expected_sr_conflicts != -1 || expected_rr_conflicts != -1) + { + if (! src_ok) + complain (ngettext ("expected %d shift/reduce conflict", + "expected %d shift/reduce conflicts", + src_expected), + src_expected); + if (! rrc_ok) + complain (ngettext ("expected %d reduce/reduce conflict", + "expected %d reduce/reduce conflicts", + rrc_expected), + rrc_expected); + } } void conflicts_free (void) { - XFREE (conflicts); - bitset_free (shiftset); - bitset_free (lookaheadset); + free (conflicts); + bitset_free (shift_set); + bitset_free (lookahead_set); obstack_free (&solved_conflicts_obstack, NULL); + obstack_free (&solved_conflicts_xml_obstack, NULL); }