X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/da2a7671e11663b9ad941aa3e1f3014d6ad950cb..6652eeba585aff3e63b28d04435a4f9d8aeba43c:/src/conflicts.c?ds=sidebyside diff --git a/src/conflicts.c b/src/conflicts.c index bcd6c846..105c5ceb 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -1,25 +1,24 @@ -/* Find and resolve or report look-ahead conflicts for bison, +/* Find and resolve or report lookahead conflicts for bison, - Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004 - Free Software Foundation, Inc. + Copyright (C) 1984, 1989, 1992, 2000-2012 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 @@ -31,6 +30,7 @@ #include "getargs.h" #include "gram.h" #include "lalr.h" +#include "print-xml.h" #include "reader.h" #include "state.h" #include "symtab.h" @@ -39,10 +39,11 @@ int expected_sr_conflicts = -1; int expected_rr_conflicts = -1; static char *conflicts; -struct obstack solved_conflicts_obstack; +static struct obstack solved_conflicts_obstack; +static struct obstack solved_conflicts_xml_obstack; static bitset shift_set; -static bitset look_ahead_set; +static bitset lookahead_set; @@ -63,81 +64,157 @@ enum conflict_resolution static inline void log_resolution (rule *r, symbol_number token, - enum conflict_resolution resolution) + enum conflict_resolution 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; - } + { + case shift_resolution: + case right_resolution: + obstack_printf (&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_printf (&solved_conflicts_obstack, + _(" Conflict between rule %d and token %s" + " resolved as reduce"), + r->number, + symbols[token]->tag); + break; + + case nonassoc_resolution: + obstack_printf (&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; - } + { + case shift_resolution: + obstack_printf (&solved_conflicts_obstack, + " (%s < %s)", + r->prec->tag, + symbols[token]->tag); + break; + + case reduce_resolution: + obstack_printf (&solved_conflicts_obstack, + " (%s < %s)", + symbols[token]->tag, + r->prec->tag); + break; + + case left_resolution: + obstack_printf (&solved_conflicts_obstack, + " (%%left %s)", + symbols[token]->tag); + break; + + case right_resolution: + obstack_printf (&solved_conflicts_obstack, + " (%%right %s)", + symbols[token]->tag); + break; + + case nonassoc_resolution: + obstack_printf (&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_printf (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + + case reduce_resolution: + case left_resolution: + obstack_printf (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + + case nonassoc_resolution: + obstack_printf (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + } + + /* The reason. */ + switch (resolution) + { + case shift_resolution: + obstack_printf (&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_printf (&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_printf (&solved_conflicts_xml_obstack, + "%%left %s", + xml_escape (symbols[token]->tag)); + break; + + case right_resolution: + obstack_printf (&solved_conflicts_xml_obstack, + "%%right %s", + xml_escape (symbols[token]->tag)); + break; + + case nonassoc_resolution: + obstack_printf (&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 @@ -146,24 +223,24 @@ flush_shift (state *s, int token) transitions *trans = s->transitions; int i; - bitset_reset (look_ahead_set, token); + bitset_reset (lookahead_set, token); for (i = 0; i < trans->num; i++) if (!TRANSITION_IS_DISABLED (trans, i) - && TRANSITION_SYMBOL (trans, i) == token) + && TRANSITION_SYMBOL (trans, i) == token) TRANSITION_DISABLE (trans, i); } /*--------------------------------------------------------------------. -| 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. | +| 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 look_ahead_tokens, int token) +flush_reduce (bitset lookahead_tokens, int token) { - bitset_reset (look_ahead_tokens, token); + bitset_reset (lookahead_tokens, token); } @@ -173,83 +250,75 @@ flush_reduce (bitset look_ahead_tokens, 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. | | | -| RULENO is the number of the look-ahead bitset to consider. | +| RULENO is the number of the lookahead bitset to consider. | | | -| ERRORS 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 *s, int ruleno, symbol **errors) +resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs) { 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; + bitset lookahead_tokens = reds->lookahead_tokens[ruleno]; for (i = 0; i < ntokens; i++) - if (bitset_test (look_ahead_tokens, i) - && bitset_test (look_ahead_set, i) - && symbols[i]->prec) + if (bitset_test (lookahead_tokens, i) + && bitset_test (lookahead_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 (symbols[i]->prec < redprec) - { - log_resolution (redrule, i, reduce_resolution); - flush_shift (s, i); - } - else if (symbols[i]->prec > redprec) - { - log_resolution (redrule, i, shift_resolution); - flush_reduce (look_ahead_tokens, i); - } - else - /* Matching precedence levels. - For left association, keep only the reduction. - For right association, keep only the shift. - For nonassociation, keep neither. */ - - switch (symbols[i]->assoc) - { - case right_assoc: - log_resolution (redrule, i, right_resolution); - flush_reduce (look_ahead_tokens, i); - break; - - case left_assoc: - log_resolution (redrule, i, left_resolution); - flush_shift (s, i); - break; - - case non_assoc: - log_resolution (redrule, i, nonassoc_resolution); - flush_shift (s, i); - flush_reduce (look_ahead_tokens, i); - /* Record an explicit error for this token. */ - errors[nerrs++] = symbols[i]; - break; - - case undef_assoc: - abort (); - } + /* Shift-reduce conflict occurs for token number i + and it has a precedence. + The precedence of shifting is that of token i. */ + if (symbols[i]->prec < redprec) + { + log_resolution (redrule, i, reduce_resolution); + flush_shift (s, i); + } + else if (symbols[i]->prec > redprec) + { + log_resolution (redrule, i, shift_resolution); + flush_reduce (lookahead_tokens, i); + } + else + /* Matching precedence levels. + For non-defined associativity, keep both: unexpected + associativity conflict. + For left associativity, keep only the reduction. + For right associativity, keep only the shift. + For nonassociativity, keep neither. */ + + switch (symbols[i]->assoc) + { + case undef_assoc: + abort (); + + case precedence_assoc: + break; + + case right_assoc: + log_resolution (redrule, i, right_resolution); + flush_reduce (lookahead_tokens, i); + break; + + case left_assoc: + log_resolution (redrule, i, left_resolution); + flush_shift (s, i); + break; + + case non_assoc: + log_resolution (redrule, i, nonassoc_resolution); + flush_shift (s, i); + flush_reduce (lookahead_tokens, i); + /* Record an explicit error for this token. */ + errors[(*nerrs)++] = symbols[i]; + break; + } } - - 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); - } } @@ -257,7 +326,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors) | 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). | +| lookahead tokens on which S raises a syntax error (%nonassoc). | `-------------------------------------------------------------------*/ static void @@ -266,31 +335,42 @@ set_conflicts (state *s, symbol **errors) int i; transitions *trans = s->transitions; reductions *reds = s->reductions; + int nerrs = 0; if (s->consistent) return; - bitset_zero (look_ahead_set); + bitset_zero (lookahead_set); FOR_EACH_SHIFT (trans, i) - bitset_set (look_ahead_set, TRANSITION_SYMBOL (trans, i)); + bitset_set (lookahead_set, TRANSITION_SYMBOL (trans, i)); - /* Loop over all rules which require look-ahead in this state. First + /* 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->look_ahead_tokens[i], look_ahead_set)) - resolve_sr_conflict (s, i, errors); + && !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)) + s->solved_conflicts = obstack_finish0 (&solved_conflicts_obstack); + if (obstack_object_size (&solved_conflicts_xml_obstack)) + s->solved_conflicts_xml = obstack_finish0 (&solved_conflicts_xml_obstack); - /* Loop over all rules which require look-ahead in this state. Check + /* 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->look_ahead_tokens[i], look_ahead_set)) - conflicts[s->number] = 1; - - bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[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]); } } @@ -304,28 +384,40 @@ void conflicts_solve (void) { state_number i; - /* List of look-ahead tokens on which we explicitly raise a syntax error. */ + /* List of lookahead tokens on which we explicitly raise a syntax error. */ symbol **errors = xnmalloc (ntokens + 1, sizeof *errors); conflicts = xcalloc (nstates, sizeof *conflicts); shift_set = bitset_create (ntokens, BITSET_FIXED); - look_ahead_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], errors); /* For uniformity of the code, make sure all the states have a valid - `errs' member. */ + `errs' member. */ if (!states[i]->errs) - states[i]->errs = errs_new (0, 0); + states[i]->errs = errs_new (0, 0); } 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]; +} + + /*---------------------------------------------. | Count the number of shift/reduce conflicts. | `---------------------------------------------*/ @@ -341,18 +433,18 @@ count_sr_conflicts (state *s) if (!trans) return 0; - bitset_zero (look_ahead_set); + bitset_zero (lookahead_set); bitset_zero (shift_set); FOR_EACH_SHIFT (trans, i) bitset_set (shift_set, TRANSITION_SYMBOL (trans, i)); for (i = 0; i < reds->num; ++i) - bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]); + bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]); - bitset_and (look_ahead_set, look_ahead_set, shift_set); + bitset_and (lookahead_set, lookahead_set, shift_set); - src_count = bitset_count (look_ahead_set); + src_count = bitset_count (lookahead_set); return src_count; } @@ -377,11 +469,11 @@ count_rr_conflicts (state *s, bool one_per_token) int count = 0; int j; for (j = 0; j < reds->num; ++j) - if (bitset_test (reds->look_ahead_tokens[j], i)) - count++; + if (bitset_test (reds->lookahead_tokens[j], i)) + count++; if (count >= 2) - rrc_count += one_per_token ? 1 : count-1; + rrc_count += one_per_token ? 1 : count-1; } return rrc_count; @@ -397,7 +489,7 @@ 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); + src_num, rrc_num); else if (src_num) fprintf (out, _("conflicts: %d shift/reduce\n"), src_num); else if (rrc_num) @@ -418,12 +510,12 @@ conflicts_output (FILE *out) { 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; - } + { + 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); @@ -432,8 +524,8 @@ 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 | -| reductions for the same state and look-ahead as one | -| conflict. | +| reductions for the same state and lookahead as one | +| conflict. | `--------------------------------------------------------*/ int @@ -447,8 +539,8 @@ conflicts_total_count (void) for (i = 0; i < nstates; i++) if (conflicts[i]) { - count += count_sr_conflicts (states[i]); - count += count_rr_conflicts (states[i], false); + count += count_sr_conflicts (states[i]); + count += count_rr_conflicts (states[i], false); } return count; } @@ -464,11 +556,13 @@ 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. */ - bool src_ok = false; - bool rrc_ok = false; + bool src_ok; + bool rrc_ok; int src_total = 0; int rrc_total = 0; + int src_expected; + int rrc_expected; /* Conflicts by state. */ { @@ -476,45 +570,59 @@ conflicts_print (void) for (i = 0; i < nstates; i++) if (conflicts[i]) - { - src_total += count_sr_conflicts (states[i]); - rrc_total += count_rr_conflicts (states[i], true); - } + { + src_total += count_sr_conflicts (states[i]); + rrc_total += count_rr_conflicts (states[i], true); + } } if (! glr_parser && rrc_total > 0 && expected_rr_conflicts != -1) { - warn (_("%%expect-rr applies only to GLR parsers")); + complain (Wother, _("%%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); + 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 as many RR conflicts and SR conflicts as expected, then there is nothing to report. */ - if (rrc_ok && src_ok) + if (rrc_ok & src_ok) return; /* Report the total number of conflicts on STDERR. */ - 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 (!(warnings_flag & Wconflicts_sr)) + src_total = 0; + if (!(warnings_flag & Wconflicts_rr)) + rrc_total = 0; + } + if (src_total | rrc_total) + { + if (expected_sr_conflicts == -1 && src_total) + set_warning_issued (Wconflicts_sr); + if (expected_rr_conflicts == -1 && rrc_total) + set_warning_issued (Wconflicts_rr); + if (! yacc_flag) + fprintf (stderr, "%s: ", current_file); + conflict_report (stderr, src_total, rrc_total); + } 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", - sr), sr); + complain (complaint, ngettext ("expected %d shift/reduce conflict", + "expected %d shift/reduce conflicts", + src_expected), + src_expected); if (! rrc_ok) - warn (ngettext ("expected %d reduce/reduce conflict", - "expected %d reduce/reduce conflicts", - rr), rr); + complain (complaint, ngettext ("expected %d reduce/reduce conflict", + "expected %d reduce/reduce conflicts", + rrc_expected), + rrc_expected); } } @@ -524,6 +632,7 @@ conflicts_free (void) { free (conflicts); bitset_free (shift_set); - bitset_free (look_ahead_set); + bitset_free (lookahead_set); obstack_free (&solved_conflicts_obstack, NULL); + obstack_free (&solved_conflicts_xml_obstack, NULL); }