X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/0846f581e81ccd73ea43f2a1dc73fd79ffc86b75..a17e599f81825bc01cb237925f34ccc67b51a9a0:/src/conflicts.c?ds=sidebyside diff --git a/src/conflicts.c b/src/conflicts.c index 0f63f401..e26a7adf 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -19,6 +19,7 @@ 02111-1307, USA. */ #include "system.h" +#include "complain.h" #include "getargs.h" #include "files.h" #include "gram.h" @@ -28,15 +29,13 @@ #include "reader.h" #include "LR0.h" -int any_conflicts = 0; errs **err_table = NULL; -int expected_conflicts; +/* -1 stands for not specified. */ +int expected_conflicts = -1; static char *conflicts = NULL; static unsigned *shiftset = NULL; static unsigned *lookaheadset = NULL; -static int src_count; -static int rrc_count; static inline void @@ -61,7 +60,7 @@ flush_shift (int state, int token) shifts *shiftp; int k, i; - shiftp = shift_table[state]; + shiftp = state_table[state].shift_table; if (shiftp) { @@ -69,7 +68,7 @@ flush_shift (int state, int token) for (i = 0; i < k; i++) { if (shiftp->shifts[i] - && token == accessing_symbol[shiftp->shifts[i]]) + && token == state_table[shiftp->shifts[i]].accessing_symbol) (shiftp->shifts[i]) = 0; } } @@ -91,14 +90,14 @@ resolve_sr_conflict (int state, int lookaheadnum) unsigned *fp1; unsigned *fp2; int redprec; - errs *errp = (errs *) xcalloc (sizeof (errs) + ntokens * sizeof (short), 1); + errs *errp = ERRS_ALLOC (ntokens + 1); short *errtokens = errp->errs; /* find the rule to reduce by to get precedence of reduction */ - redprec = rprec[LAruleno[lookaheadnum]]; + redprec = rule_table[LAruleno[lookaheadnum]].prec; mask = 1; - fp1 = LA + lookaheadnum * tokensetsize; + fp1 = LA (lookaheadnum); fp2 = lookaheadset; for (i = 0; i < ntokens; i++) { @@ -171,7 +170,7 @@ resolve_sr_conflict (int state, int lookaheadnum) /* 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); + err_table[state] = ERRS_ALLOC (i + 1); bcopy (errp, err_table[state], i); } else @@ -183,80 +182,53 @@ resolve_sr_conflict (int state, int lookaheadnum) static void set_conflicts (int state) { - int i; - int k; + int i, j; shifts *shiftp; - unsigned *fp2; - unsigned *fp3; - unsigned *fp4; - unsigned *fp1; int symbol; - if (consistent[state]) + if (state_table[state].consistent) return; for (i = 0; i < tokensetsize; i++) lookaheadset[i] = 0; - shiftp = shift_table[state]; + shiftp = state_table[state].shift_table; if (shiftp) - { - k = shiftp->nshifts; - for (i = 0; i < k; i++) - { - symbol = accessing_symbol[shiftp->shifts[i]]; - if (ISVAR (symbol)) - break; - SETBIT (lookaheadset, symbol); - } - } - - k = lookaheads[state + 1]; - fp4 = lookaheadset + tokensetsize; + for (i = 0; i < shiftp->nshifts; i++) + { + symbol = state_table[shiftp->shifts[i]].accessing_symbol; + if (ISVAR (symbol)) + break; + SETBIT (lookaheadset, symbol); + } /* 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 = state_table[state].lookaheads; + i < state_table[state + 1].lookaheads; + ++i) + if (rule_table[LAruleno[i]].prec) + for (j = 0; j < tokensetsize; ++j) + if (LA (i)[j] & lookaheadset[j]) { - if (*fp2++ & *fp3++) - { - resolve_sr_conflict (state, i); - break; - } + resolve_sr_conflict (state, 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 = state_table[state].lookaheads; + i < state_table[state + 1].lookaheads; + ++i) { - fp1 = LA + i * tokensetsize; - fp2 = fp1; - fp3 = lookaheadset; + for (j = 0; j < tokensetsize; ++j) + if (LA (i)[j] & lookaheadset[j]) + conflicts[state] = 1; - while (fp3 < fp4) - { - if (*fp2++ & *fp3++) - { - conflicts[state] = 1; - any_conflicts = 1; - } - } - - fp2 = fp1; - fp3 = lookaheadset; - - while (fp3 < fp4) - *fp3++ |= *fp2++; + for (j = 0; j < tokensetsize; ++j) + lookaheadset[j] |= LA (i)[j]; } } @@ -271,8 +243,6 @@ solve_conflicts (void) err_table = XCALLOC (errs *, nstates); - any_conflicts = 0; - for (i = 0; i < nstates; i++) set_conflicts (i); } @@ -282,7 +252,7 @@ solve_conflicts (void) | Count the number of shift/reduce conflicts. | `---------------------------------------------*/ -static void +static int count_sr_conflicts (int state) { int i; @@ -294,11 +264,11 @@ count_sr_conflicts (int state) unsigned *fp3; int symbol; - src_count = 0; + int src_count = 0; - shiftp = shift_table[state]; + shiftp = state_table[state].shift_table; if (!shiftp) - return; + return 0; for (i = 0; i < tokensetsize; i++) { @@ -311,18 +281,18 @@ count_sr_conflicts (int state) { if (!shiftp->shifts[i]) continue; - symbol = accessing_symbol[shiftp->shifts[i]]; + symbol = state_table[shiftp->shifts[i]].accessing_symbol; if (ISVAR (symbol)) break; SETBIT (shiftset, symbol); } - k = lookaheads[state + 1]; + k = state_table[state + 1].lookaheads; fp3 = lookaheadset + tokensetsize; - for (i = lookaheads[state]; i < k; i++) + for (i = state_table[state].lookaheads; i < k; i++) { - fp1 = LA + i * tokensetsize; + fp1 = LA (i); fp2 = lookaheadset; while (fp2 < fp3) @@ -349,6 +319,8 @@ count_sr_conflicts (int state) fp2++; } } + + return src_count; } @@ -356,33 +328,29 @@ count_sr_conflicts (int state) | Count the number of reduce/reduce conflicts. | `----------------------------------------------*/ -static void +static int count_rr_conflicts (int state) { int i; - int j; - int count; unsigned mask; unsigned *baseword; - unsigned *wordp; - int m; - int n; - rrc_count = 0; + int rrc_count = 0; - m = lookaheads[state]; - n = lookaheads[state + 1]; + int m = state_table[state].lookaheads; + int n = state_table[state + 1].lookaheads; if (n - m < 2) - return; + return 0; mask = 1; - baseword = LA + m * tokensetsize; + baseword = LA (m); for (i = 0; i < ntokens; i++) { - wordp = baseword; + unsigned *wordp = baseword; - count = 0; + int count = 0; + int j; for (j = m; j < n; j++) { if (mask & *wordp) @@ -401,6 +369,8 @@ count_rr_conflicts (int state) baseword++; } } + + return rrc_count; } /*--------------------------------------------------------------. @@ -414,31 +384,23 @@ conflict_report (int src_num, int rrc_num) static char res[4096]; char *cp = res; - if (src_num == 1) + if (src_num >= 1) { - sprintf (cp, _(" 1 shift/reduce conflict")); - cp += strlen (cp); - } - else if (src_num > 1) - { - sprintf (cp, _(" %d shift/reduce conflicts"), src_num); + 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, _(" and")); + sprintf (cp, " %s ", _("and")); cp += strlen (cp); } - if (rrc_num == 1) - { - sprintf (cp, _(" 1 reduce/reduce conflict")); - cp += strlen (cp); - } - else if (rrc_num > 1) + if (rrc_num >= 1) { - sprintf (cp, _(" %d reduce/reduce conflicts"), rrc_num); + sprintf (cp, ngettext ("%d reduce/reduce conflict", + "%d reduce/reduce conflicts", rrc_num), rrc_num); cp += strlen (cp); } @@ -450,38 +412,59 @@ conflict_report (int src_num, int rrc_num) } -/*---------------------------------------------. -| Compute and give a report on the conflicts. | -`---------------------------------------------*/ +/*-----------------------------------------------------------. +| Output the detailed description of states with conflicts. | +`-----------------------------------------------------------*/ void -print_conflicts (FILE *out) +conflicts_output (FILE *out) { + bool printed_sth = FALSE; int i; - int src_total; - int rrc_total; + 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); + printed_sth = TRUE; + } + if (printed_sth) + fputs ("\n\n", out); +} - src_total = 0; - rrc_total = 0; - /* Count the total number of conflicts, and if wanted, give a - detailed report in FOUTPUT. */ +/*------------------------------------------. +| Reporting the total number of conflicts. | +`------------------------------------------*/ + +void +conflicts_print (void) +{ + int 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; + + /* Conflicts by state. */ 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; + if (conflicts[i]) + { + src_total += count_sr_conflicts (i); + rrc_total += count_rr_conflicts (i); + } - if (verbose_flag) - { - fprintf (out, _("State %d contains"), i); - fputs (conflict_report (src_count, rrc_count), out); - } - } - } + src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts); + + /* 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; /* Report the total number of conflicts on STDERR. */ if (yacc_flag) @@ -499,23 +482,26 @@ print_conflicts (FILE *out) } else { - fprintf (stderr, _("%s contains"), infile); + fprintf (stderr, _("%s contains "), infile); fputs (conflict_report (src_total, rrc_total), stderr); } + + if (expected_conflicts != -1 && !src_ok) + { + complain_message_count++; + fprintf (stderr, ngettext ("expected %d shift/reduce conflict\n", + "expected %d shift/reduce conflicts\n", + expected_conflicts), + expected_conflicts); + } } void -print_reductions (int state) +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; @@ -531,77 +517,57 @@ print_reductions (int state) for (i = 0; i < tokensetsize; i++) shiftset[i] = 0; - shiftp = shift_table[state]; + shiftp = state_table[state].shift_table; 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; - /* 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); - } - } + for (i = 0; i < shiftp->nshifts; 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); + } errp = err_table[state]; if (errp) { - k = errp->nerrs; - for (i = 0; i < k; i++) + for (i = 0; i < errp->nerrs; i++) { if (!errp->errs[i]) continue; - symbol = errp->errs[i]; - SETBIT (shiftset, symbol); + SETBIT (shiftset, errp->errs[i]); } } - m = lookaheads[state]; - n = lookaheads[state + 1]; + m = state_table[state].lookaheads; + n = state_table[state + 1].lookaheads; if (n - m == 1 && !nodefault) { + int k; 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 (k = 0; k < tokensetsize; ++k) + lookaheadset[k] = LA (m)[k] & shiftset[k]; for (i = 0; i < ntokens; i++) - { - if (mask & *fp3) - obstack_fgrow3 (&output_obstack, - _(" %-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 (BITISSET (lookaheadset, i)) + fprintf (out, _(" %-4s\t[reduce using rule %d (%s)]\n"), + tags[i], default_rule, + tags[rule_table[default_rule].lhs]); - obstack_fgrow2 (&output_obstack, - _(" $default\treduce using rule %d (%s)\n\n"), - default_rule, tags[rlhs[default_rule]]); + fprintf (out, _(" $default\treduce using rule %d (%s)\n\n"), + default_rule, tags[rule_table[default_rule].lhs]); } else if (n - m >= 1) { + unsigned *fp1, *fp2, *fp3, *fp4; + cmax = 0; default_LA = -1; fp4 = lookaheadset + tokensetsize; @@ -609,7 +575,7 @@ print_reductions (int state) if (!nodefault) for (i = m; i < n; i++) { - fp1 = LA + i * tokensetsize; + fp1 = LA (i); fp2 = shiftset; fp3 = lookaheadset; @@ -651,12 +617,11 @@ print_reductions (int state) if (shiftp) { - k = shiftp->nshifts; - for (i = 0; i < k; i++) + for (i = 0; i < shiftp->nshifts; i++) { if (!shiftp->shifts[i]) continue; - symbol = accessing_symbol[shiftp->shifts[i]]; + symbol = state_table[shiftp->shifts[i]].accessing_symbol; if (ISVAR (symbol)) break; SETBIT (shiftset, symbol); @@ -664,7 +629,7 @@ print_reductions (int state) } mask = 1; - fp1 = LA + m * tokensetsize; + fp1 = LA (m); fp2 = shiftset; for (i = 0; i < ntokens; i++) { @@ -683,12 +648,11 @@ print_reductions (int state) if (count == 0) { if (j != default_LA) - { - rule = LAruleno[j]; - obstack_fgrow3 (&output_obstack, - _(" %-4s\treduce using rule %d (%s)\n"), - tags[i], rule, tags[rlhs[rule]]); - } + fprintf (out, + _(" %-4s\treduce using rule %d (%s)\n"), + tags[i], + LAruleno[j], + tags[rule_table[LAruleno[j]].lhs]); else defaulted = 1; @@ -697,17 +661,17 @@ print_reductions (int state) else { if (defaulted) - { - rule = LAruleno[default_LA]; - obstack_fgrow3 (&output_obstack, - _(" %-4s\treduce using rule %d (%s)\n"), - tags[i], rule, tags[rlhs[rule]]); - defaulted = 0; - } - rule = LAruleno[j]; - obstack_fgrow3 (&output_obstack, + fprintf (out, + _(" %-4s\treduce using rule %d (%s)\n"), + tags[i], + LAruleno[default_LA], + tags[rule_table[LAruleno[default_LA]].lhs]); + defaulted = 0; + fprintf (out, _(" %-4s\t[reduce using rule %d (%s)]\n"), - tags[i], rule, tags[rlhs[rule]]); + tags[i], + LAruleno[j], + tags[rule_table[LAruleno[j]].lhs]); } } @@ -726,11 +690,8 @@ print_reductions (int state) } if (default_LA >= 0) - obstack_fgrow2 (&output_obstack, - _(" $default\treduce using rule %d (%s)\n"), - default_rule, tags[rlhs[default_rule]]); - - obstack_1grow (&output_obstack, '\n'); + fprintf (out, _(" $default\treduce using rule %d (%s)\n"), + default_rule, tags[rule_table[default_rule].lhs]); } }