X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/de326cc0de0e14b33c64d40171eb74640ff2e20a..f9abaa2c4c5c77c5b6bdcfc0149c0af5adc8cc39:/src/conflicts.c?ds=inline diff --git a/src/conflicts.c b/src/conflicts.c index 60a5edec..e08256a1 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -1,5 +1,5 @@ /* Find and resolve or report look-ahead conflicts for bison, - Copyright 1984, 1989, 1992, 2000, 2001 Free Software Foundation, Inc. + Copyright 1984, 1989, 1992, 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -19,8 +19,10 @@ 02111-1307, USA. */ #include "system.h" +#include "bitset.h" #include "complain.h" #include "getargs.h" +#include "symtab.h" #include "files.h" #include "gram.h" #include "state.h" @@ -29,22 +31,23 @@ #include "reader.h" #include "LR0.h" -errs **err_table = NULL; /* -1 stands for not specified. */ int expected_conflicts = -1; static char *conflicts = NULL; -static unsigned *shiftset = NULL; -static unsigned *lookaheadset = NULL; +static bitset shiftset; +static bitset lookaheadset; static inline void -log_resolution (int state, int LAno, int token, char *resolution) +log_resolution (state_t *state, int LAno, int token, char *resolution) { - obstack_fgrow4 (&output_obstack, - _("\ + if (verbose_flag) + obstack_fgrow4 (&output_obstack, + _("\ Conflict in state %d between rule %d and token %s resolved as %s.\n"), - state, LAruleno[LAno], tags[token], resolution); + state->number, LAruleno[LAno], symbols[token]->tag, + resolution); } @@ -55,23 +58,28 @@ Conflict in state %d between rule %d and token %s resolved as %s.\n"), `------------------------------------------------------------------*/ static void -flush_shift (int state, int token) +flush_shift (state_t *state, int token) { - shifts *shiftp; - int k, i; + shifts *shiftp = state->shifts; + int i; - shiftp = state_table[state].shift_table; + 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); +} - if (shiftp) - { - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - if (shiftp->shifts[i] - && token == state_table[shiftp->shifts[i]].accessing_symbol) - (shiftp->shifts[i]) = 0; - } - } + +/*-------------------------------------------------------------------. +| 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. | +`-------------------------------------------------------------------*/ + +static void +flush_reduce (int lookahead, int token) +{ + bitset_reset (LA[lookahead], token); } @@ -83,190 +91,124 @@ flush_shift (int state, int token) `------------------------------------------------------------------*/ static void -resolve_sr_conflict (int state, int lookaheadnum) +resolve_sr_conflict (state_t *state, int lookahead) { int i; - int mask; - unsigned *fp1; - unsigned *fp2; - int redprec; - errs *errp = (errs *) xcalloc (sizeof (errs) + ntokens * sizeof (short), 1); - short *errtokens = errp->errs; - /* find the rule to reduce by to get precedence of reduction */ - redprec = rprec[LAruleno[lookaheadnum]]; + int redprec = rules[LAruleno[lookahead]].prec; + errs *errp = errs_new (ntokens + 1); + errp->nerrs = 0; - mask = 1; - fp1 = LA + lookaheadnum * tokensetsize; - fp2 = lookaheadset; for (i = 0; i < ntokens; i++) - { - if ((mask & *fp2 & *fp1) && sprec[i]) + if (bitset_test (LA[lookahead], i) + && bitset_test (lookaheadset, 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 (sprec[i] < redprec) + if (symbols[i]->prec < redprec) + { + log_resolution (state, lookahead, i, _("reduce")); + flush_shift (state, i); + } + else if (symbols[i]->prec > redprec) + { + log_resolution (state, lookahead, i, _("shift")); + flush_reduce (lookahead, 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) { - log_resolution (state, lookaheadnum, i, _("reduce")); - *fp2 &= ~mask; /* flush the shift for this token */ + case right_assoc: + log_resolution (state, lookahead, i, _("shift")); + flush_reduce (lookahead, i); + break; + + case left_assoc: + log_resolution (state, lookahead, i, _("reduce")); flush_shift (state, i); + break; + + case non_assoc: + log_resolution (state, lookahead, i, _("an error")); + flush_shift (state, i); + flush_reduce (lookahead, i); + /* Record an explicit error for this token. */ + errp->errs[errp->nerrs++] = i; + break; } - else if (sprec[i] > redprec) - { - log_resolution (state, lookaheadnum, i, _("shift")); - *fp1 &= ~mask; /* flush the reduce for this token */ - } - else - { - /* Matching precedence levels. - For left association, keep only the reduction. - For right association, keep only the shift. - For nonassociation, keep neither. */ - - switch (sassoc[i]) - { - case right_assoc: - log_resolution (state, lookaheadnum, i, _("shift")); - break; - - case left_assoc: - log_resolution (state, lookaheadnum, i, _("reduce")); - break; - - case non_assoc: - log_resolution (state, lookaheadnum, i, _("an error")); - break; - } - - if (sassoc[i] != right_assoc) - { - *fp2 &= ~mask; /* flush the shift for this token */ - flush_shift (state, i); - } - if (sassoc[i] != left_assoc) - { - *fp1 &= ~mask; /* flush the reduce for this token */ - } - if (sassoc[i] == non_assoc) - { - /* Record an explicit error for this token. */ - *errtokens++ = i; - } - } - } - - mask <<= 1; - if (mask == 0) - { - mask = 1; - fp2++; - fp1++; - } - } - errp->nerrs = errtokens - errp->errs; - if (errp->nerrs) - { - /* Some tokens have been explicitly made errors. Allocate - a permanent errs structure for this state, to record them. */ - i = (char *) errtokens - (char *) errp; - err_table[state] = (errs *) xcalloc ((unsigned int) i, 1); - bcopy (errp, err_table[state], i); - } - else - err_table[state] = 0; + } + + /* Some tokens have been explicitly made errors. Allocate a + permanent errs structure for this state, to record them. */ + state->errs = errs_dup (errp); free (errp); } static void -set_conflicts (int state) +set_conflicts (state_t *state) { - int i; - int k; + int i, j; shifts *shiftp; - unsigned *fp2; - unsigned *fp3; - unsigned *fp4; - unsigned *fp1; - int symbol; - if (state_table[state].consistent) + if (state->consistent) return; - for (i = 0; i < tokensetsize; i++) - lookaheadset[i] = 0; - - shiftp = state_table[state].shift_table; - if (shiftp) - { - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - symbol = state_table[shiftp->shifts[i]].accessing_symbol; - if (ISVAR (symbol)) - break; - SETBIT (lookaheadset, symbol); - } - } + bitset_zero (lookaheadset); - k = lookaheads[state + 1]; - fp4 = lookaheadset + tokensetsize; + shiftp = state->shifts; + for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) + if (!SHIFT_IS_DISABLED (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 = lookaheads[state]; i < k; i++) - if (rprec[LAruleno[i]]) - { - fp1 = LA + i * tokensetsize; - fp2 = fp1; - fp3 = lookaheadset; - - while (fp3 < fp4) + for (i = 0; i < state->nlookaheads; ++i) + if (rules[LAruleno[state->lookaheadsp + i]].prec) + for (j = 0; j < ntokens; ++j) + if (bitset_test (LA[state->lookaheadsp + i], j) + && bitset_test (lookaheadset, j)) { - if (*fp2++ & *fp3++) - { - resolve_sr_conflict (state, i); - break; - } + 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 = lookaheads[state]; i < k; i++) + for (i = 0; i < state->nlookaheads; ++i) { - fp1 = LA + i * tokensetsize; - fp2 = fp1; - fp3 = lookaheadset; + /* FIXME: Here, I need something like `bitset_disjoint_p'. */ + for (j = 0; j < ntokens; ++j) + if (bitset_test (LA[state->lookaheadsp + i], j) + && bitset_test (lookaheadset, j)) + conflicts[state->number] = 1; - while (fp3 < fp4) - if (*fp2++ & *fp3++) - conflicts[state] = 1; - - fp2 = fp1; - fp3 = lookaheadset; - - while (fp3 < fp4) - *fp3++ |= *fp2++; + bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); } } void solve_conflicts (void) { - int i; + size_t i; conflicts = XCALLOC (char, nstates); - shiftset = XCALLOC (unsigned, tokensetsize); - lookaheadset = XCALLOC (unsigned, tokensetsize); - - err_table = XCALLOC (errs *, nstates); + shiftset = bitset_create (ntokens, BITSET_FIXED); + bitset_zero (shiftset); + lookaheadset = bitset_create (ntokens, BITSET_FIXED); + bitset_zero (lookaheadset); for (i = 0; i < nstates; i++) - set_conflicts (i); + set_conflicts (states[i]); } @@ -275,72 +217,30 @@ solve_conflicts (void) `---------------------------------------------*/ static int -count_sr_conflicts (int state) +count_sr_conflicts (state_t *state) { int i; - int k; - int mask; - shifts *shiftp; - unsigned *fp1; - unsigned *fp2; - unsigned *fp3; - int symbol; - int src_count = 0; + shifts *shiftp = state->shifts; - shiftp = state_table[state].shift_table; if (!shiftp) return 0; - for (i = 0; i < tokensetsize; i++) - { - shiftset[i] = 0; - lookaheadset[i] = 0; - } - - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - if (!shiftp->shifts[i]) - continue; - symbol = state_table[shiftp->shifts[i]].accessing_symbol; - if (ISVAR (symbol)) - break; - SETBIT (shiftset, symbol); - } - - k = lookaheads[state + 1]; - fp3 = lookaheadset + tokensetsize; + bitset_zero (lookaheadset); + bitset_zero (shiftset); - for (i = lookaheads[state]; i < k; i++) - { - fp1 = LA + i * tokensetsize; - fp2 = lookaheadset; + for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) + if (!SHIFT_IS_DISABLED (shiftp, i)) + bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i)); - while (fp2 < fp3) - *fp2++ |= *fp1++; - } + for (i = 0; i < state->nlookaheads; ++i) + bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); - fp1 = shiftset; - fp2 = lookaheadset; + bitset_and (lookaheadset, lookaheadset, shiftset); - while (fp2 < fp3) - *fp2++ &= *fp1++; - - mask = 1; - fp2 = lookaheadset; for (i = 0; i < ntokens; i++) - { - if (mask & *fp2) - src_count++; - - mask <<= 1; - if (mask == 0) - { - mask = 1; - fp2++; - } - } + if (bitset_test (lookaheadset, i)) + src_count++; return src_count; } @@ -351,45 +251,24 @@ count_sr_conflicts (int state) `----------------------------------------------*/ static int -count_rr_conflicts (int state) +count_rr_conflicts (state_t *state) { int i; - unsigned mask; - unsigned *baseword; - int rrc_count = 0; - int m = lookaheads[state]; - int n = lookaheads[state + 1]; - - if (n - m < 2) + if (state->nlookaheads < 2) return 0; - mask = 1; - baseword = LA + m * tokensetsize; for (i = 0; i < ntokens; i++) { - unsigned *wordp = baseword; - int count = 0; int j; - for (j = m; j < n; j++) - { - if (mask & *wordp) - count++; - - wordp += tokensetsize; - } + for (j = 0; j < state->nlookaheads; ++j) + if (bitset_test (LA[state->lookaheadsp + j], i)) + count++; if (count >= 2) rrc_count++; - - mask <<= 1; - if (mask == 0) - { - mask = 1; - baseword++; - } } return rrc_count; @@ -441,14 +320,18 @@ conflict_report (int src_num, int rrc_num) void conflicts_output (FILE *out) { - int i; + bool printed_sth = FALSE; + size_t i; for (i = 0; i < nstates; i++) if (conflicts[i]) { fprintf (out, _("State %d contains "), i); - fputs (conflict_report (count_sr_conflicts (i), - count_rr_conflicts (i)), out); + fputs (conflict_report (count_sr_conflicts (states[i]), + count_rr_conflicts (states[i])), out); + printed_sth = TRUE; } + if (printed_sth) + fputs ("\n\n", out); } @@ -459,7 +342,12 @@ 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 + case we want equality. */ + int src_ok = 0; int src_total = 0; int rrc_total = 0; @@ -468,266 +356,44 @@ conflicts_print (void) for (i = 0; i < nstates; i++) if (conflicts[i]) { - src_total += count_sr_conflicts (i); - rrc_total += count_rr_conflicts (i); + src_total += count_sr_conflicts (states[i]); + rrc_total += count_rr_conflicts (states[i]); } - /* Report the total number of conflicts on STDERR. */ - if (src_total || rrc_total) - { - if (yacc_flag) - { - /* If invoked with `--yacc', use the output format specified by - POSIX. */ - fprintf (stderr, _("conflicts: ")); - if (src_total > 0) - fprintf (stderr, _(" %d shift/reduce"), src_total); - if (src_total > 0 && rrc_total > 0) - fprintf (stderr, ","); - if (rrc_total > 0) - fprintf (stderr, _(" %d reduce/reduce"), rrc_total); - putc ('\n', stderr); - } - else - { - fprintf (stderr, _("%s contains "), infile); - fputs (conflict_report (src_total, rrc_total), stderr); - } - } - - if (expected_conflicts != -1 - && src_total != expected_conflicts) - { - complain_message_count++; - fprintf (stderr, ngettext ("expected %d shift/reduce conflict", - "expected %d shift/reduce conflicts", - expected_conflicts), - expected_conflicts); - } -} - - -void -print_reductions (FILE *out, int state) -{ - int i; - int j; - int k; - unsigned *fp1; - unsigned *fp2; - unsigned *fp3; - unsigned *fp4; - int rule; - int symbol; - unsigned mask; - int m; - int n; - int default_LA; - int default_rule = 0; - int cmax; - int count; - shifts *shiftp; - errs *errp; - int nodefault = 0; + src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts); - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; + /* If there are no RR conflicts, and as many SR conflicts as + expected, then there is nothing to report. */ + if (!rrc_total && src_ok) + return; - shiftp = state_table[state].shift_table; - if (shiftp) + /* Report the total number of conflicts on STDERR. */ + if (yacc_flag) { - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - if (!shiftp->shifts[i]) - continue; - symbol = state_table[shiftp->shifts[i]].accessing_symbol; - if (ISVAR (symbol)) - break; - /* if this state has a shift for the error token, - don't use a default rule. */ - if (symbol == error_token_number) - nodefault = 1; - SETBIT (shiftset, symbol); - } + /* If invoked with `--yacc', use the output format specified by + POSIX. */ + fprintf (stderr, _("conflicts: ")); + if (src_total > 0) + fprintf (stderr, _(" %d shift/reduce"), src_total); + if (src_total > 0 && rrc_total > 0) + fprintf (stderr, ","); + if (rrc_total > 0) + fprintf (stderr, _(" %d reduce/reduce"), rrc_total); + putc ('\n', stderr); } - - errp = err_table[state]; - if (errp) + else { - k = errp->nerrs; - for (i = 0; i < k; i++) - { - if (!errp->errs[i]) - continue; - symbol = errp->errs[i]; - SETBIT (shiftset, symbol); - } + fprintf (stderr, _("%s contains "), infile); + fputs (conflict_report (src_total, rrc_total), stderr); } - m = lookaheads[state]; - n = lookaheads[state + 1]; - - if (n - m == 1 && !nodefault) - { - default_rule = LAruleno[m]; - - fp1 = LA + m * tokensetsize; - fp2 = shiftset; - fp3 = lookaheadset; - fp4 = lookaheadset + tokensetsize; - - while (fp3 < fp4) - *fp3++ = *fp1++ & *fp2++; - - mask = 1; - fp3 = lookaheadset; - - for (i = 0; i < ntokens; i++) - { - if (mask & *fp3) - fprintf (out, _(" %-4s\t[reduce using rule %d (%s)]\n"), - tags[i], default_rule, tags[rlhs[default_rule]]); - - mask <<= 1; - if (mask == 0) - { - mask = 1; - fp3++; - } - } - - fprintf (out, _(" $default\treduce using rule %d (%s)\n\n"), - default_rule, tags[rlhs[default_rule]]); - } - else if (n - m >= 1) + if (expected_conflicts != -1 && !src_ok) { - cmax = 0; - default_LA = -1; - fp4 = lookaheadset + tokensetsize; - - if (!nodefault) - for (i = m; i < n; i++) - { - fp1 = LA + i * tokensetsize; - fp2 = shiftset; - fp3 = lookaheadset; - - while (fp3 < fp4) - *fp3++ = *fp1++ & (~(*fp2++)); - - count = 0; - mask = 1; - fp3 = lookaheadset; - for (j = 0; j < ntokens; j++) - { - if (mask & *fp3) - count++; - - mask <<= 1; - if (mask == 0) - { - mask = 1; - fp3++; - } - } - - if (count > cmax) - { - cmax = count; - default_LA = i; - default_rule = LAruleno[i]; - } - - fp2 = shiftset; - fp3 = lookaheadset; - - while (fp3 < fp4) - *fp2++ |= *fp3++; - } - - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; - - if (shiftp) - { - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - if (!shiftp->shifts[i]) - continue; - symbol = state_table[shiftp->shifts[i]].accessing_symbol; - if (ISVAR (symbol)) - break; - SETBIT (shiftset, symbol); - } - } - - mask = 1; - fp1 = LA + m * tokensetsize; - fp2 = shiftset; - for (i = 0; i < ntokens; i++) - { - int defaulted = 0; - - if (mask & *fp2) - count = 1; - else - count = 0; - - fp3 = fp1; - for (j = m; j < n; j++) - { - if (mask & *fp3) - { - if (count == 0) - { - if (j != default_LA) - { - rule = LAruleno[j]; - fprintf (out, - _(" %-4s\treduce using rule %d (%s)\n"), - tags[i], rule, tags[rlhs[rule]]); - } - else - defaulted = 1; - - count++; - } - else - { - if (defaulted) - { - rule = LAruleno[default_LA]; - fprintf (out, - _(" %-4s\treduce using rule %d (%s)\n"), - tags[i], rule, tags[rlhs[rule]]); - defaulted = 0; - } - rule = LAruleno[j]; - fprintf (out, - _(" %-4s\t[reduce using rule %d (%s)]\n"), - tags[i], rule, tags[rlhs[rule]]); - } - } - - fp3 += tokensetsize; - } - - mask <<= 1; - if (mask == 0) - { - mask = 1; - /* We tried incrementing just fp1, and just fp2; both seem wrong. - It seems necessary to increment both in sync. */ - fp1++; - fp2++; - } - } - - if (default_LA >= 0) - fprintf (out, _(" $default\treduce using rule %d (%s)\n"), - default_rule, tags[rlhs[default_rule]]); + complain_message_count++; + fprintf (stderr, ngettext ("expected %d shift/reduce conflict\n", + "expected %d shift/reduce conflicts\n", + expected_conflicts), + expected_conflicts); } } @@ -736,6 +402,6 @@ void free_conflicts (void) { XFREE (conflicts); - XFREE (shiftset); - XFREE (lookaheadset); + bitset_free (shiftset); + bitset_free (lookaheadset); }