X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/b65534e5a42df3058ebca6aa7e0a726af59184ce..2c2035282c525f1474bb2d4ce20a45c183aae93f:/src/conflicts.c?ds=sidebyside diff --git a/src/conflicts.c b/src/conflicts.c index 29656f32..98959cff 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -1,753 +1,628 @@ -/* Find and resolve or report look-ahead conflicts for bison, - Copyright (C) 1984, 1989, 1992 Free Software Foundation, Inc. +/* Find and resolve or report lookahead conflicts for bison, -This file is part of Bison, the GNU Compiler Compiler. + Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004, 2005, + 2006, 2007, 2009 Free Software Foundation, Inc. -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 file is part of Bison, the GNU Compiler Compiler. -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 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. -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, 675 Mass Ave, Cambridge, MA 02139, USA. */ + 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. -#include + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include #include "system.h" -#include "machine.h" -#include "new.h" + +#include + +#include "LR0.h" +#include "complain.h" +#include "conflicts.h" #include "files.h" +#include "getargs.h" #include "gram.h" +#include "lalr.h" +#include "print-xml.h" +#include "reader.h" #include "state.h" +#include "symtab.h" + +/* -1 stands for not specified. */ +int expected_sr_conflicts = -1; +int expected_rr_conflicts = -1; +static char *conflicts; +static struct obstack solved_conflicts_obstack; +static struct obstack solved_conflicts_xml_obstack; + +static bitset shift_set; +static bitset lookahead_set; + + + +enum conflict_resolution + { + shift_resolution, + reduce_resolution, + left_resolution, + right_resolution, + nonassoc_resolution + }; + + +/*----------------------------------------------------------------. +| Explain how an SR conflict between TOKEN and RULE was resolved: | +| RESOLUTION. | +`----------------------------------------------------------------*/ + +static inline void +log_resolution (rule *r, symbol_number token, + 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; + } + /* 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; + } -extern char **tags; -extern int tokensetsize; -extern char *consistent; -extern short *accessing_symbol; -extern shifts **shift_table; -extern unsigned *LA; -extern short *LAruleno; -extern short *lookaheads; -extern int verboseflag; + obstack_sgrow (&solved_conflicts_obstack, ".\n"); + } -void set_conflicts(); -void resolve_sr_conflict(); -void flush_shift(); -void log_resolution(); -void total_conflicts(); -void count_sr_conflicts(); -void count_rr_conflicts(); + /* XML report */ + if (xml_flag) + { + /* The description of the resolution. */ + switch (resolution) + { + case shift_resolution: + case right_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + + case reduce_resolution: + case left_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + + case nonassoc_resolution: + obstack_fgrow2 (&solved_conflicts_xml_obstack, + " ", + r->number, + xml_escape (symbols[token]->tag)); + break; + } -char any_conflicts; -char *conflicts; -errs **err_table; -int expected_conflicts; + /* The reason. */ + switch (resolution) + { + case shift_resolution: + obstack_fgrow2 (&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_fgrow2 (&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_fgrow1 (&solved_conflicts_xml_obstack, + "%%left %s", + xml_escape (symbols[token]->tag)); + break; + + case right_resolution: + obstack_fgrow1 (&solved_conflicts_xml_obstack, + "%%right %s", + xml_escape (symbols[token]->tag)); + break; + + case nonassoc_resolution: + obstack_fgrow1 (&solved_conflicts_xml_obstack, + "%%nonassoc %s", + xml_escape (symbols[token]->tag)); + break; + } + obstack_sgrow (&solved_conflicts_xml_obstack, "\n"); + } +} -static unsigned *shiftset; -static unsigned *lookaheadset; -static int src_total; -static int rrc_total; -static int src_count; -static int rrc_count; +/*------------------------------------------------------------------. +| 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 or as an error (%nonassoc). | +`------------------------------------------------------------------*/ -void -initialize_conflicts() +static void +flush_shift (state *s, int token) { - register int i; -/* register errs *sp; JF unused */ - - conflicts = NEW2(nstates, char); - shiftset = NEW2(tokensetsize, unsigned); - lookaheadset = NEW2(tokensetsize, unsigned); + transitions *trans = s->transitions; + int i; + + bitset_reset (lookahead_set, token); + for (i = 0; i < trans->num; i++) + if (!TRANSITION_IS_DISABLED (trans, i) + && TRANSITION_SYMBOL (trans, i) == token) + TRANSITION_DISABLE (trans, i); +} - err_table = NEW2(nstates, errs *); - any_conflicts = 0; +/*--------------------------------------------------------------------. +| 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). | +`--------------------------------------------------------------------*/ - for (i = 0; i < nstates; i++) - set_conflicts(i); +static void +flush_reduce (bitset lookahead_tokens, int token) +{ + bitset_reset (lookahead_tokens, token); } -void -set_conflicts(state) -int state; +/*------------------------------------------------------------------. +| Attempt to resolve shift-reduce conflict for one rule by means of | +| 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. | +| | +| RULENO is the number of the lookahead bitset to consider. | +| | +| ERRORS and NERRS can be used to store discovered explicit | +| errors. | +`------------------------------------------------------------------*/ + +static void +resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs) { - register int i; - register int k; - register shifts *shiftp; - register unsigned *fp2; - register unsigned *fp3; - register unsigned *fp4; - register unsigned *fp1; - register int symbol; - - if (consistent[state]) return; - - for (i = 0; i < tokensetsize; i++) - lookaheadset[i] = 0; - - shiftp = shift_table[state]; - if (shiftp) - { - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - symbol = accessing_symbol[shiftp->shifts[i]]; - if (ISVAR(symbol)) break; - SETBIT(lookaheadset, symbol); - } - } + 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 lookahead_tokens = reds->lookahead_tokens[ruleno]; - k = lookaheads[state + 1]; - fp4 = lookaheadset + tokensetsize; - - /* 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]]) + for (i = 0; i < ntokens; i++) + if (bitset_test (lookahead_tokens, i) + && bitset_test (lookahead_set, i) + && symbols[i]->prec) { - fp1 = LA + i * tokensetsize; - fp2 = fp1; - fp3 = lookaheadset; - - while (fp3 < fp4) + /* 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) { - if (*fp2++ & *fp3++) - { - resolve_sr_conflict(state, i); - break; - } + log_resolution (redrule, i, reduce_resolution); + flush_shift (s, i); } - } - - /* loop over all rules which require lookahead in this state */ - /* Check for conflicts not resolved above. */ - - for (i = lookaheads[state]; i < k; i++) - { - fp1 = LA + i * tokensetsize; - fp2 = fp1; - fp3 = lookaheadset; + else if (symbols[i]->prec > redprec) + { + log_resolution (redrule, i, shift_resolution); + flush_reduce (lookahead_tokens, i); + } + else + /* Matching precedence levels. + For left association, keep only the reduction. + For right association, keep only the shift. + For nonassociation, keep neither. */ - while (fp3 < fp4) - { - if (*fp2++ & *fp3++) + switch (symbols[i]->assoc) { - conflicts[state] = 1; - any_conflicts = 1; + default: + abort (); + + 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; } - } - - fp2 = fp1; - fp3 = lookaheadset; - - while (fp3 < fp4) - *fp3++ |= *fp2++; - } + } } +/*-------------------------------------------------------------------. +| 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 | +| lookahead tokens on which S raises a syntax error (%nonassoc). | +`-------------------------------------------------------------------*/ -/* Attempt to resolve shift-reduce conflict for one rule -by means of 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. */ - -void -resolve_sr_conflict(state, lookaheadnum) -int state; -int lookaheadnum; +static void +set_conflicts (state *s, symbol **errors) { - register int i; - register int mask; - register unsigned *fp1; - register unsigned *fp2; - register int redprec; - errs *errp = (errs *) xmalloc (sizeof(errs) + ntokens * sizeof(short)); - short *errtokens = errp->errs; - - /* find the rule to reduce by to get precedence of reduction */ - redprec = rprec[LAruleno[lookaheadnum]]; - - mask = 1; - fp1 = LA + lookaheadnum * tokensetsize; - fp2 = lookaheadset; - for (i = 0; i < ntokens; i++) - { - if ((mask & *fp2 & *fp1) && sprec[i]) - /* 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 (verboseflag) log_resolution(state, lookaheadnum, i, "reduce"); - *fp2 &= ~mask; /* flush the shift for this token */ - flush_shift(state, i); - } - else if (sprec[i] > redprec) - { - if (verboseflag) 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: - if (verboseflag) log_resolution(state, lookaheadnum, i, "shift"); - break; - - case LEFT_ASSOC: - if (verboseflag) log_resolution(state, lookaheadnum, i, "reduce"); - break; - - case NON_ASSOC: - if (verboseflag) 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 *) xmalloc ((unsigned int)i); - bcopy (errp, err_table[state], i); - } - else - err_table[state] = 0; - free(errp); -} + int i; + transitions *trans = s->transitions; + reductions *reds = s->reductions; + int nerrs = 0; + if (s->consistent) + return; + bitset_zero (lookahead_set); -/* 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. */ + FOR_EACH_SHIFT (trans, i) + bitset_set (lookahead_set, TRANSITION_SYMBOL (trans, i)); -void -flush_shift(state, token) -int state; -int token; -{ - register shifts *shiftp; - register int k, i; -/* register unsigned symbol; JF unused */ + /* 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->lookahead_tokens[i], lookahead_set)) + resolve_sr_conflict (s, i, errors, &nerrs); - shiftp = shift_table[state]; + 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); + } + if (obstack_object_size (&solved_conflicts_xml_obstack)) + { + obstack_1grow (&solved_conflicts_xml_obstack, '\0'); + s->solved_conflicts_xml = obstack_finish (&solved_conflicts_xml_obstack); + } - if (shiftp) + /* Loop over all rules which require lookahead in this state. Check + for conflicts not resolved above. */ + for (i = 0; i < reds->num; ++i) { - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - if (shiftp->shifts[i] && token == accessing_symbol[shiftp->shifts[i]]) - (shiftp->shifts[i]) = 0; - } + if (!bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set)) + conflicts[s->number] = 1; + bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]); } } -void -log_resolution(state, LAno, token, resolution) -int state, LAno, token; -char *resolution; -{ - fprintf(foutput, - "Conflict in state %d between rule %d and token %s resolved as %s.\n", - state, LAruleno[LAno], tags[token], resolution); -} - +/*----------------------------------------------------------------. +| Solve all the S/R conflicts using the precedence/associativity, | +| and flag as inconsistent the states that still have conflicts. | +`----------------------------------------------------------------*/ void -conflict_log() +conflicts_solve (void) { - register int i; + state_number i; + /* List of lookahead tokens on which we explicitly raise a syntax error. */ + symbol **errors = xnmalloc (ntokens + 1, sizeof *errors); - src_total = 0; - rrc_total = 0; + conflicts = xcalloc (nstates, sizeof *conflicts); + shift_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++) { - if (conflicts[i]) - { - count_sr_conflicts(i); - count_rr_conflicts(i); - src_total += src_count; - rrc_total += rrc_count; - } + set_conflicts (states[i], errors); + + /* For uniformity of the code, make sure all the states have a valid + `errs' member. */ + if (!states[i]->errs) + states[i]->errs = errs_new (0, 0); } - total_conflicts(); + free (errors); } - + void -verbose_conflict_log() +conflicts_update_state_numbers (state_number old_to_new[], + state_number nstates_old) { - register int i; - - src_total = 0; - rrc_total = 0; - - for (i = 0; i < nstates; i++) - { - if (conflicts[i]) - { - count_sr_conflicts(i); - count_rr_conflicts(i); - src_total += src_count; - rrc_total += rrc_count; - - fprintf(foutput, "State %d contains", i); - - if (src_count == 1) - fprintf(foutput, " 1 shift/reduce conflict"); - else if (src_count > 1) - fprintf(foutput, " %d shift/reduce conflicts", src_count); - - if (src_count > 0 && rrc_count > 0) - fprintf(foutput, " and"); - - if (rrc_count == 1) - fprintf(foutput, " 1 reduce/reduce conflict"); - else if (rrc_count > 1) - fprintf(foutput, " %d reduce/reduce conflicts", rrc_count); - - putc('.', foutput); - putc('\n', foutput); - } - } - - total_conflicts(); + state_number i; + for (i = 0; i < nstates_old; ++i) + if (old_to_new[i] != nstates_old) + conflicts[old_to_new[i]] = conflicts[i]; } -void -total_conflicts() +/*---------------------------------------------. +| Count the number of shift/reduce conflicts. | +`---------------------------------------------*/ + +static int +count_sr_conflicts (state *s) { - extern int fixed_outfiles; + int i; + int src_count = 0; + transitions *trans = s->transitions; + reductions *reds = s->reductions; - if (src_total == expected_conflicts && rrc_total == 0) - return; + if (!trans) + return 0; - if (fixed_outfiles) - { - /* If invoked under the name `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); + bitset_zero (lookahead_set); + bitset_zero (shift_set); - if (src_total == 1) - fprintf(stderr, " 1 shift/reduce conflict"); - else if (src_total > 1) - fprintf(stderr, " %d shift/reduce conflicts", src_total); + FOR_EACH_SHIFT (trans, i) + bitset_set (shift_set, TRANSITION_SYMBOL (trans, i)); - if (src_total > 0 && rrc_total > 0) - fprintf(stderr, " and"); + for (i = 0; i < reds->num; ++i) + bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]); - if (rrc_total == 1) - fprintf(stderr, " 1 reduce/reduce conflict"); - else if (rrc_total > 1) - fprintf(stderr, " %d reduce/reduce conflicts", rrc_total); + bitset_and (lookahead_set, lookahead_set, shift_set); - putc('.', stderr); - putc('\n', stderr); - } -} + src_count = bitset_count (lookahead_set); + return src_count; +} -void -count_sr_conflicts(state) -int state; -{ - register int i; - register int k; - register int mask; - register shifts *shiftp; - register unsigned *fp1; - register unsigned *fp2; - register unsigned *fp3; - register int symbol; - src_count = 0; +/*----------------------------------------------------------------. +| 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. | ++`----------------------------------------------------------------*/ - shiftp = shift_table[state]; - if (!shiftp) return; +static int +count_rr_conflicts (state *s, bool one_per_token) +{ + int i; + reductions *reds = s->reductions; + int rrc_count = 0; - for (i = 0; i < tokensetsize; i++) + for (i = 0; i < ntokens; i++) { - shiftset[i] = 0; - lookaheadset[i] = 0; + int count = 0; + int j; + for (j = 0; j < reds->num; ++j) + if (bitset_test (reds->lookahead_tokens[j], i)) + count++; + + if (count >= 2) + rrc_count += one_per_token ? 1 : count-1; } - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - if (! shiftp->shifts[i]) continue; - symbol = accessing_symbol[shiftp->shifts[i]]; - if (ISVAR(symbol)) break; - SETBIT(shiftset, symbol); - } + return rrc_count; +} - k = lookaheads[state + 1]; - fp3 = lookaheadset + tokensetsize; - for (i = lookaheads[state]; i < k; i++) - { - fp1 = LA + i * tokensetsize; - fp2 = lookaheadset; +/*--------------------------------------------------------. +| Report the number of conflicts, using the Yacc format. | +`--------------------------------------------------------*/ - while (fp2 < fp3) - *fp2++ |= *fp1++; - } +static void +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); + 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); +} - fp1 = shiftset; - fp2 = lookaheadset; - while (fp2 < fp3) - *fp2++ &= *fp1++; +/*-----------------------------------------------------------. +| Output the detailed description of states with conflicts. | +`-----------------------------------------------------------*/ - mask = 1; - fp2 = lookaheadset; - for (i = 0; i < ntokens; i++) +void +conflicts_output (FILE *out) +{ + bool printed_sth = false; + state_number i; + for (i = 0; i < nstates; i++) { - if (mask & *fp2) - src_count++; - - mask <<= 1; - if (mask == 0) + state *s = states[i]; + if (conflicts[i]) { - mask = 1; - fp2++; + 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); } +/*--------------------------------------------------------. +| 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. | +`--------------------------------------------------------*/ -void -count_rr_conflicts(state) -int state; +int +conflicts_total_count (void) { - register int i; - register int j; - register int count; - register unsigned mask; - register unsigned *baseword; - register unsigned *wordp; - register int m; - register int n; - - rrc_count = 0; - - m = lookaheads[state]; - n = lookaheads[state + 1]; + state_number i; + int count; - if (n - m < 2) return; - - mask = 1; - baseword = LA + m * tokensetsize; - for (i = 0; i < ntokens; i++) - { - wordp = baseword; - - count = 0; - for (j = m; j < n; j++) - { - if (mask & *wordp) - count++; - - wordp += tokensetsize; - } - - if (count >= 2) rrc_count++; - - mask <<= 1; - if (mask == 0) - { - mask = 1; - baseword++; - } - } + /* 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. | +`------------------------------------------*/ + void -print_reductions(state) -int state; +conflicts_print (void) { - register int i; - register int j; - register int k; - register unsigned *fp1; - register unsigned *fp2; - register unsigned *fp3; - register unsigned *fp4; - register int rule; - register int symbol; - register unsigned mask; - register int m; - register int n; - register int default_LA; - register int default_rule; - register int cmax; - register int count; - register shifts *shiftp; - register errs *errp; - int nodefault = 0; - - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; - - shiftp = shift_table[state]; - if (shiftp) - { - k = shiftp->nshifts; - for (i = 0; i < k; 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. */ + bool src_ok; + bool rrc_ok; + + int src_total = 0; + int rrc_total = 0; + int src_expected; + int rrc_expected; + + /* Conflicts by state. */ + { + state_number i; + + for (i = 0; i < nstates; i++) + if (conflicts[i]) { - if (! shiftp->shifts[i]) continue; - symbol = accessing_symbol[shiftp->shifts[i]]; - 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); + src_total += count_sr_conflicts (states[i]); + rrc_total += count_rr_conflicts (states[i], true); } - } + } - errp = err_table[state]; - if (errp) + if (! glr_parser && rrc_total > 0 && expected_rr_conflicts != -1) { - k = errp->nerrs; - for (i = 0; i < k; i++) - { - if (! errp->errs[i]) continue; - symbol = errp->errs[i]; - SETBIT(shiftset, symbol); - } + warn (_("%%expect-rr applies only to GLR parsers")); + expected_rr_conflicts = -1; } - m = lookaheads[state]; - n = lookaheads[state + 1]; - - if (n - m == 1 && ! nodefault) - { - default_rule = LAruleno[m]; + 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; - 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(foutput, " %-4s\t[reduce using rule %d (%s)]\n", - tags[i], default_rule, tags[rlhs[default_rule]]); - - mask <<= 1; - if (mask == 0) - { - mask = 1; - fp3++; - } - } + /* If there are as many RR conflicts and SR conflicts as + expected, then there is nothing to report. */ + if (rrc_ok & src_ok) + return; - fprintf(foutput, " $default\treduce using rule %d (%s)\n\n", - default_rule, tags[rlhs[default_rule]]); - } - else if (n - m >= 1) + /* Report the total number of conflicts on STDERR. */ + if (src_total | rrc_total) { - 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 = accessing_symbol[shiftp->shifts[i]]; - 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(foutput, " %-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(foutput, " %-4s\treduce using rule %d (%s)\n", - tags[i], rule, tags[rlhs[rule]]); - defaulted = 0; - } - rule = LAruleno[j]; - fprintf(foutput, " %-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(foutput, " $default\treduce using rule %d (%s)\n", - default_rule, tags[rlhs[default_rule]]); - } + if (! yacc_flag) + fprintf (stderr, "%s: ", current_file); + conflict_report (stderr, src_total, rrc_total); + } - putc('\n', foutput); + if (expected_sr_conflicts != -1 || expected_rr_conflicts != -1) + { + if (! src_ok) + complain (ngettext ("expected %d shift/reduce conflict", + "expected %d shift/reduce conflicts", + src_expected), + src_expected); + if (! rrc_ok) + complain (ngettext ("expected %d reduce/reduce conflict", + "expected %d reduce/reduce conflicts", + rrc_expected), + rrc_expected); } } void -finalize_conflicts() +conflicts_free (void) { - FREE(conflicts); - FREE(shiftset); - FREE(lookaheadset); + free (conflicts); + bitset_free (shift_set); + bitset_free (lookahead_set); + obstack_free (&solved_conflicts_obstack, NULL); + obstack_free (&solved_conflicts_xml_obstack, NULL); }