X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/1dd15b6ea60d170ea443f8c1756052cb4ea33c14..e342c3beaf9d73616e8ff6fe005b97f3a72c0476:/src/conflicts.c diff --git a/src/conflicts.c b/src/conflicts.c index 36f1d00c..73ad45e9 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -1,6 +1,6 @@ /* 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. @@ -36,12 +36,13 @@ #include "symtab.h" /* -1 stands for not specified. */ -int expected_conflicts = -1; +int expected_sr_conflicts = -1; +int expected_rr_conflicts = -1; static char *conflicts = NULL; struct obstack solved_conflicts_obstack; -static bitset shiftset; -static bitset lookaheadset; +static bitset shift_set; +static bitset look_ahead_set; @@ -145,7 +146,7 @@ flush_shift (state *s, int token) transitions *trans = s->transitions; int i; - bitset_reset (lookaheadset, token); + bitset_reset (look_ahead_set, token); for (i = 0; i < trans->num; i++) if (!TRANSITION_IS_DISABLED (trans, i) && TRANSITION_SYMBOL (trans, i) == token) @@ -153,16 +154,16 @@ flush_shift (state *s, int token) } -/*-------------------------------------------------------------------. -| 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 (bitset lookaheads, int token) +flush_reduce (bitset look_ahead_tokens, int token) { - bitset_reset (lookaheads, token); + bitset_reset (look_ahead_tokens, token); } @@ -172,7 +173,7 @@ 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 look-ahead bitset to consider. | | | | ERRORS can be used to store discovered explicit errors. | `------------------------------------------------------------------*/ @@ -185,12 +186,12 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors) /* Find the rule to reduce by to get precedence of reduction. */ rule *redrule = reds->rules[ruleno]; 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++) - 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 @@ -204,7 +205,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors) 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. @@ -216,7 +217,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors) { case right_assoc: log_resolution (redrule, i, right_resolution); - flush_reduce (lookaheads, i); + flush_reduce (look_ahead_tokens, i); break; case left_assoc: @@ -227,7 +228,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors) case non_assoc: log_resolution (redrule, i, nonassoc_resolution); flush_shift (s, i); - flush_reduce (lookaheads, i); + flush_reduce (look_ahead_tokens, i); /* Record an explicit error for this token. */ errors[nerrs++] = symbols[i]; break; @@ -237,9 +238,12 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors) } } - /* 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 (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)) { @@ -253,7 +257,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 | -| lookaheads on which S raises a syntax error (%nonassoc). | +| look-ahead tokens on which S raises a syntax error (%nonassoc). | `-------------------------------------------------------------------*/ static void @@ -266,30 +270,27 @@ set_conflicts (state *s, symbol **errors) if (s->consistent) return; - bitset_zero (lookaheadset); + bitset_zero (look_ahead_set); FOR_EACH_SHIFT (trans, i) - bitset_set (lookaheadset, TRANSITION_SYMBOL (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 - && !bitset_disjoint_p (reds->lookaheads[i], lookaheadset)) - { - resolve_sr_conflict (s, i, errors); - 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) { - if (!bitset_disjoint_p (reds->lookaheads[i], lookaheadset)) + 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]); } } @@ -303,12 +304,12 @@ void conflicts_solve (void) { state_number i; - /* List of lookaheads on which we explicitly raise a syntax error. */ + /* List of look-ahead tokens on which we explicitly raise a syntax error. */ symbol **errors = MALLOC (errors, ntokens + 1); CALLOC (conflicts, nstates); - shiftset = bitset_create (ntokens, BITSET_FIXED); - lookaheadset = bitset_create (ntokens, BITSET_FIXED); + 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++) @@ -340,18 +341,18 @@ count_sr_conflicts (state *s) if (!trans) return 0; - bitset_zero (lookaheadset); - bitset_zero (shiftset); + bitset_zero (look_ahead_set); + bitset_zero (shift_set); FOR_EACH_SHIFT (trans, i) - bitset_set (shiftset, TRANSITION_SYMBOL (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 (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; } @@ -365,7 +366,7 @@ count_sr_conflicts (state *s) +`----------------------------------------------------------------*/ static int -count_rr_conflicts (state *s, int one_per_token) +count_rr_conflicts (state *s, bool one_per_token) { int i; reductions *reds = s->reductions; @@ -376,7 +377,7 @@ count_rr_conflicts (state *s, 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->look_ahead_tokens[j], i)) count++; if (count >= 2) @@ -387,60 +388,20 @@ count_rr_conflicts (state *s, 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); } @@ -458,10 +419,9 @@ conflicts_output (FILE *out) 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))); + fprintf (out, _("State %d "), i); + conflict_report (out, count_sr_conflicts (s), + count_rr_conflicts (s, true)); printed_sth = true; } } @@ -472,7 +432,7 @@ 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 lookahead as one | +| reductions for the same state and look-ahead as one | | conflict. | `--------------------------------------------------------*/ @@ -504,7 +464,8 @@ 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 = false; + bool rrc_ok = false; int src_total = 0; int rrc_total = 0; @@ -521,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; + } - /* If there are no RR conflicts, and as many SR conflicts as + 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 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 (! 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_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) { - free (conflicts); - bitset_free (shiftset); - bitset_free (lookaheadset); + XFREE (conflicts); + bitset_free (shift_set); + bitset_free (look_ahead_set); obstack_free (&solved_conflicts_obstack, NULL); }