X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/1a2b5d37e1d44b47cd51220945f4ba29c228a419..b408954b40e74d85ee90544ea7e296dbc99356c9:/src/conflicts.c diff --git a/src/conflicts.c b/src/conflicts.c index 3a979410..0ba2e5ac 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -1,5 +1,6 @@ /* 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 + Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -19,6 +20,7 @@ 02111-1307, USA. */ #include "system.h" +#include "bitset.h" #include "complain.h" #include "getargs.h" #include "symtab.h" @@ -33,20 +35,93 @@ /* -1 stands for not specified. */ int expected_conflicts = -1; static char *conflicts = NULL; +struct obstack solved_conflicts_obstack; + +static bitset shiftset; +static bitset lookaheadset; -static unsigned *shiftset = NULL; -static unsigned *lookaheadset = NULL; +enum conflict_resolution_e + { + shift_resolution, + reduce_resolution, + left_resolution, + right_resolution, + nonassoc_resolution, + }; + + static inline void -log_resolution (state_t *state, int LAno, int token, char *resolution) +log_resolution (int lookahead, int token, + enum conflict_resolution_e resolution) { - if (verbose_flag) - obstack_fgrow4 (&output_obstack, - _("\ -Conflict in state %d between rule %d and token %s resolved as %s.\n"), - state->number, LAruleno[LAno], symbols[token]->tag, - resolution); + if (report_flag & report_solved_conflicts) + { + /* The description of the resolution. */ + switch (resolution) + { + case shift_resolution: + case left_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + _("\ + Conflict between rule %d and token %s resolved as shift"), + LArule[lookahead]->number, + symbols[token]->tag); + break; + case reduce_resolution: + case right_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + _("\ + Conflict between rule %d and token %s resolved as reduce"), + LArule[lookahead]->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, + symbols[token]->tag); + break; + } + + /* The reason. */ + switch (resolution) + { + case shift_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + " (%s < %s)", + LArule[lookahead]->prec->tag, + symbols[token]->tag); + break; + + case reduce_resolution: + obstack_fgrow2 (&solved_conflicts_obstack, + " (%s < %s)", + symbols[token]->tag, + LArule[lookahead]->prec->tag); + break; + + case left_resolution: + obstack_printf (&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"); + } } @@ -62,7 +137,7 @@ flush_shift (state_t *state, int token) shifts *shiftp = state->shifts; int i; - RESETBIT (lookaheadset, token); + bitset_reset (lookaheadset, token); for (i = 0; i < shiftp->nshifts; i++) if (!SHIFT_IS_DISABLED (shiftp, i) && SHIFT_SYMBOL (shiftp, i) == token) SHIFT_DISABLE (shiftp, i); @@ -78,7 +153,7 @@ flush_shift (state_t *state, int token) static void flush_reduce (int lookahead, int token) { - RESETBIT (LA (lookahead), token); + bitset_reset (LA[lookahead], token); } @@ -94,13 +169,13 @@ resolve_sr_conflict (state_t *state, int lookahead) { int i; /* find the rule to reduce by to get precedence of reduction */ - int redprec = rules[LAruleno[lookahead]].prec; + int redprec = LArule[lookahead]->prec->prec; errs *errp = errs_new (ntokens + 1); errp->nerrs = 0; for (i = 0; i < ntokens; i++) - if (BITISSET (LA (lookahead), i) - && BITISSET (lookaheadset, i) + if (bitset_test (LA[lookahead], i) + && bitset_test (lookaheadset, i) && symbols[i]->prec) { /* Shift-reduce conflict occurs for token number i @@ -108,12 +183,12 @@ resolve_sr_conflict (state_t *state, int lookahead) The precedence of shifting is that of token i. */ if (symbols[i]->prec < redprec) { - log_resolution (state, lookahead, i, _("reduce")); + log_resolution (lookahead, i, reduce_resolution); flush_shift (state, i); } else if (symbols[i]->prec > redprec) { - log_resolution (state, lookahead, i, _("shift")); + log_resolution (lookahead, i, shift_resolution); flush_reduce (lookahead, i); } else @@ -125,17 +200,17 @@ resolve_sr_conflict (state_t *state, int lookahead) switch (symbols[i]->assoc) { case right_assoc: - log_resolution (state, lookahead, i, _("shift")); + log_resolution (lookahead, i, right_resolution); flush_reduce (lookahead, i); break; case left_assoc: - log_resolution (state, lookahead, i, _("reduce")); + log_resolution (lookahead, i, left_resolution); flush_shift (state, i); break; case non_assoc: - log_resolution (state, lookahead, i, _("an error")); + log_resolution (lookahead, i, nonassoc_resolution); flush_shift (state, i); flush_reduce (lookahead, i); /* Record an explicit error for this token. */ @@ -148,63 +223,66 @@ resolve_sr_conflict (state_t *state, int lookahead) permanent errs structure for this state, to record them. */ state->errs = errs_dup (errp); free (errp); + + if (obstack_object_size (&solved_conflicts_obstack)) + { + obstack_1grow (&solved_conflicts_obstack, '\0'); + state->solved_conflicts = obstack_finish (&solved_conflicts_obstack); + } } static void set_conflicts (state_t *state) { - int i, j; + int i; shifts *shiftp; if (state->consistent) return; - for (i = 0; i < tokensetsize; i++) - lookaheadset[i] = 0; + bitset_zero (lookaheadset); shiftp = 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)); + bitset_set (lookaheadset, SHIFT_SYMBOL (shiftp, 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 < state->nlookaheads; ++i) - if (rules[LAruleno[state->lookaheadsp + i]].prec) - for (j = 0; j < tokensetsize; ++j) - if (LA (state->lookaheadsp + i)[j] & lookaheadset[j]) - { - resolve_sr_conflict (state, state->lookaheadsp + i); - break; - } - + if (LArule[state->lookaheadsp + i]->prec + && LArule[state->lookaheadsp + i]->prec->prec + && !bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset)) + { + resolve_sr_conflict (state, state->lookaheadsp + i); + break; + } /* Loop over all rules which require lookahead in this state. Check for conflicts not resolved above. */ for (i = 0; i < state->nlookaheads; ++i) { - for (j = 0; j < tokensetsize; ++j) - if (LA (state->lookaheadsp + i)[j] & lookaheadset[j]) - conflicts[state->number] = 1; + if (!bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset)) + conflicts[state->number] = 1; - for (j = 0; j < tokensetsize; ++j) - lookaheadset[j] |= LA (state->lookaheadsp + i)[j]; + bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); } } void -solve_conflicts (void) +conflicts_solve (void) { - int i; + size_t i; conflicts = XCALLOC (char, nstates); - shiftset = XCALLOC (unsigned, tokensetsize); - lookaheadset = XCALLOC (unsigned, tokensetsize); + shiftset = bitset_create (ntokens, BITSET_FIXED); + lookaheadset = bitset_create (ntokens, BITSET_FIXED); + obstack_init (&solved_conflicts_obstack); for (i = 0; i < nstates; i++) - set_conflicts (state_table[i]); + set_conflicts (states[i]); } @@ -215,33 +293,26 @@ solve_conflicts (void) static int count_sr_conflicts (state_t *state) { - int i, k; + int i; int src_count = 0; shifts *shiftp = state->shifts; if (!shiftp) return 0; - for (i = 0; i < tokensetsize; i++) - { - shiftset[i] = 0; - lookaheadset[i] = 0; - } + bitset_zero (lookaheadset); + bitset_zero (shiftset); for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) if (!SHIFT_IS_DISABLED (shiftp, i)) - SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); + bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i)); for (i = 0; i < state->nlookaheads; ++i) - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] |= LA (state->lookaheadsp + i)[k]; + bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] &= shiftset[k]; + bitset_and (lookaheadset, lookaheadset, shiftset); - for (i = 0; i < ntokens; i++) - if (BITISSET (lookaheadset, i)) - src_count++; + src_count = bitset_count (lookaheadset); return src_count; } @@ -265,7 +336,7 @@ count_rr_conflicts (state_t *state) int count = 0; int j; for (j = 0; j < state->nlookaheads; ++j) - if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j)) + if (bitset_test (LA[state->lookaheadsp + j], i)) count++; if (count >= 2) @@ -322,13 +393,13 @@ void conflicts_output (FILE *out) { bool printed_sth = FALSE; - int i; + size_t i; for (i = 0; i < nstates; i++) if (conflicts[i]) { fprintf (out, _("State %d contains "), i); - fputs (conflict_report (count_sr_conflicts (state_table[i]), - count_rr_conflicts (state_table[i])), out); + fputs (conflict_report (count_sr_conflicts (states[i]), + count_rr_conflicts (states[i])), out); printed_sth = TRUE; } if (printed_sth) @@ -343,7 +414,7 @@ conflicts_output (FILE *out) void conflicts_print (void) { - int i; + 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 @@ -357,8 +428,8 @@ conflicts_print (void) for (i = 0; i < nstates; i++) if (conflicts[i]) { - src_total += count_sr_conflicts (state_table[i]); - rrc_total += count_rr_conflicts (state_table[i]); + src_total += count_sr_conflicts (states[i]); + rrc_total += count_rr_conflicts (states[i]); } src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts); @@ -400,9 +471,10 @@ conflicts_print (void) void -free_conflicts (void) +conflicts_free (void) { XFREE (conflicts); - XFREE (shiftset); - XFREE (lookaheadset); + bitset_free (shiftset); + bitset_free (lookaheadset); + obstack_free (&solved_conflicts_obstack, NULL); }