X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/b408954b40e74d85ee90544ea7e296dbc99356c9..32e1e0a4865d64946a5497aff057d7be28c1cc3d:/src/conflicts.c?ds=sidebyside diff --git a/src/conflicts.c b/src/conflicts.c index 0ba2e5ac..02876817 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -48,12 +48,17 @@ enum conflict_resolution_e reduce_resolution, left_resolution, right_resolution, - nonassoc_resolution, + nonassoc_resolution }; +/*----------------------------------------------------------------. +| Explain how an SR conflict between TOKEN and RULE was resolved: | +| RESOLUTION. | +`----------------------------------------------------------------*/ + static inline void -log_resolution (int lookahead, int token, +log_resolution (rule_t *rule, int token, enum conflict_resolution_e resolution) { if (report_flag & report_solved_conflicts) @@ -66,7 +71,7 @@ log_resolution (int lookahead, int token, obstack_fgrow2 (&solved_conflicts_obstack, _("\ Conflict between rule %d and token %s resolved as shift"), - LArule[lookahead]->number, + rule->number, symbols[token]->tag); break; case reduce_resolution: @@ -74,14 +79,14 @@ log_resolution (int lookahead, int token, obstack_fgrow2 (&solved_conflicts_obstack, _("\ Conflict between rule %d and token %s resolved as reduce"), - LArule[lookahead]->number, + rule->number, symbols[token]->tag); break; case nonassoc_resolution: obstack_fgrow2 (&solved_conflicts_obstack, _("\ Conflict between rule %d and token %s resolved as an error"), - LArule[lookahead]->number, + rule->number, symbols[token]->tag); break; } @@ -92,7 +97,7 @@ log_resolution (int lookahead, int token, case shift_resolution: obstack_fgrow2 (&solved_conflicts_obstack, " (%s < %s)", - LArule[lookahead]->prec->tag, + rule->prec->tag, symbols[token]->tag); break; @@ -100,11 +105,11 @@ log_resolution (int lookahead, int token, obstack_fgrow2 (&solved_conflicts_obstack, " (%s < %s)", symbols[token]->tag, - LArule[lookahead]->prec->tag); + rule->prec->tag); break; case left_resolution: - obstack_printf (&solved_conflicts_obstack, + obstack_fgrow1 (&solved_conflicts_obstack, " (%%left %s)", symbols[token]->tag); break; @@ -134,7 +139,7 @@ log_resolution (int lookahead, int token, static void flush_shift (state_t *state, int token) { - shifts *shiftp = state->shifts; + shifts_t *shiftp = state->shifts; int i; bitset_reset (lookaheadset, token); @@ -151,9 +156,9 @@ flush_shift (state_t *state, int token) `-------------------------------------------------------------------*/ static void -flush_reduce (int lookahead, int token) +flush_reduce (bitset lookaheads, int token) { - bitset_reset (LA[lookahead], token); + bitset_reset (lookaheads, token); } @@ -162,19 +167,23 @@ 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. | +| | +| LOOKAHEAD is the number of the lookahead bitset to consider. | `------------------------------------------------------------------*/ 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 = LArule[lookahead]->prec->prec; + /* Find the rule to reduce by to get precedence of reduction. */ + rule_t *redrule = state->lookaheads_rule[lookahead]; + int redprec = redrule->prec->prec; + bitset lookaheads = state->lookaheads[lookahead]; errs *errp = errs_new (ntokens + 1); errp->nerrs = 0; for (i = 0; i < ntokens; i++) - if (bitset_test (LA[lookahead], i) + if (bitset_test (lookaheads, i) && bitset_test (lookaheadset, i) && symbols[i]->prec) { @@ -183,13 +192,13 @@ resolve_sr_conflict (state_t *state, int lookahead) The precedence of shifting is that of token i. */ if (symbols[i]->prec < redprec) { - log_resolution (lookahead, i, reduce_resolution); + log_resolution (redrule, i, reduce_resolution); flush_shift (state, i); } else if (symbols[i]->prec > redprec) { - log_resolution (lookahead, i, shift_resolution); - flush_reduce (lookahead, i); + log_resolution (redrule, i, shift_resolution); + flush_reduce (lookaheads, i); } else /* Matching precedence levels. @@ -200,22 +209,26 @@ resolve_sr_conflict (state_t *state, int lookahead) switch (symbols[i]->assoc) { case right_assoc: - log_resolution (lookahead, i, right_resolution); - flush_reduce (lookahead, i); + log_resolution (redrule, i, right_resolution); + flush_reduce (lookaheads, i); break; case left_assoc: - log_resolution (lookahead, i, left_resolution); + log_resolution (redrule, i, left_resolution); flush_shift (state, i); break; case non_assoc: - log_resolution (lookahead, i, nonassoc_resolution); + log_resolution (redrule, i, nonassoc_resolution); flush_shift (state, i); - flush_reduce (lookahead, i); + flush_reduce (lookaheads, i); /* Record an explicit error for this token. */ errp->errs[errp->nerrs++] = i; break; + + case undef_assoc: + assert (symbols[i]->assoc != undef_assoc); + break; } } @@ -236,7 +249,7 @@ static void set_conflicts (state_t *state) { int i; - shifts *shiftp; + shifts_t *shiftp; if (state->consistent) return; @@ -250,13 +263,13 @@ set_conflicts (state_t *state) /* Loop over all rules which require lookahead in this state. First check for shift-reduce conflict, and try to resolve using - precedence */ + precedence. */ for (i = 0; i < state->nlookaheads; ++i) - if (LArule[state->lookaheadsp + i]->prec - && LArule[state->lookaheadsp + i]->prec->prec - && !bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset)) + if (state->lookaheads_rule[i]->prec + && state->lookaheads_rule[i]->prec->prec + && !bitset_disjoint_p (state->lookaheads[i], lookaheadset)) { - resolve_sr_conflict (state, state->lookaheadsp + i); + resolve_sr_conflict (state, i); break; } @@ -264,17 +277,17 @@ set_conflicts (state_t *state) for conflicts not resolved above. */ for (i = 0; i < state->nlookaheads; ++i) { - if (!bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset)) + if (!bitset_disjoint_p (state->lookaheads[i], lookaheadset)) conflicts[state->number] = 1; - bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); + bitset_or (lookaheadset, lookaheadset, state->lookaheads[i]); } } void conflicts_solve (void) { - size_t i; + state_number_t i; conflicts = XCALLOC (char, nstates); shiftset = bitset_create (ntokens, BITSET_FIXED); @@ -295,7 +308,7 @@ count_sr_conflicts (state_t *state) { int i; int src_count = 0; - shifts *shiftp = state->shifts; + shifts_t *shiftp = state->shifts; if (!shiftp) return 0; @@ -308,7 +321,7 @@ count_sr_conflicts (state_t *state) bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i)); for (i = 0; i < state->nlookaheads; ++i) - bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); + bitset_or (lookaheadset, lookaheadset, state->lookaheads[i]); bitset_and (lookaheadset, lookaheadset, shiftset); @@ -318,12 +331,15 @@ count_sr_conflicts (state_t *state) } -/*----------------------------------------------. -| 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 (state_t *state) +count_rr_conflicts (state_t *state, int one_per_token) { int i; int rrc_count = 0; @@ -336,11 +352,11 @@ count_rr_conflicts (state_t *state) int count = 0; int j; for (j = 0; j < state->nlookaheads; ++j) - if (bitset_test (LA[state->lookaheadsp + j], i)) + if (bitset_test (state->lookaheads[j], i)) count++; if (count >= 2) - rrc_count++; + rrc_count += one_per_token ? 1 : count-1; } return rrc_count; @@ -393,19 +409,43 @@ void conflicts_output (FILE *out) { bool printed_sth = FALSE; - size_t i; + state_number_t i; for (i = 0; i < nstates; i++) if (conflicts[i]) { fprintf (out, _("State %d contains "), i); fputs (conflict_report (count_sr_conflicts (states[i]), - count_rr_conflicts (states[i])), out); + count_rr_conflicts (states[i], TRUE)), out); 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 lookahead as one | +| conflict. | +`--------------------------------------------------------*/ + +int +conflicts_total_count (void) +{ + state_number_t i; + int count; + + /* Conflicts by state. */ + count = 0; + for (i = 0; i < nstates; i++) + if (conflicts[i]) + { + count += count_sr_conflicts (states[i]); + count += count_rr_conflicts (states[i], FALSE); + } + return count; +} + /*------------------------------------------. | Reporting the total number of conflicts. | @@ -414,8 +454,6 @@ conflicts_output (FILE *out) void conflicts_print (void) { - size_t 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. */ @@ -425,12 +463,16 @@ conflicts_print (void) int rrc_total = 0; /* Conflicts by state. */ - for (i = 0; i < nstates; i++) - if (conflicts[i]) - { - src_total += count_sr_conflicts (states[i]); - rrc_total += count_rr_conflicts (states[i]); - } + { + state_number_t 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); + } + } src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);