X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/709ae8c6ee619a2bf89a26ddd7575bdeb5d1896f..7ea5e9779b59230a43edfe24cf395a47841a3823:/src/conflicts.c diff --git a/src/conflicts.c b/src/conflicts.c index cbd002d5..746fcb50 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -21,6 +21,7 @@ #include "system.h" #include "complain.h" #include "getargs.h" +#include "symtab.h" #include "files.h" #include "gram.h" #include "state.h" @@ -38,13 +39,14 @@ static unsigned *lookaheadset = NULL; static inline void -log_resolution (int state, int LAno, int token, char *resolution) +log_resolution (state_t *state, int LAno, int token, char *resolution) { 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,9 +57,9 @@ 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 = state_table[state]->shifts; + shifts *shiftp = state->shifts; int i; RESETBIT (lookaheadset, token); @@ -88,28 +90,28 @@ flush_reduce (int lookahead, int token) `------------------------------------------------------------------*/ static void -resolve_sr_conflict (int state, int lookahead) +resolve_sr_conflict (state_t *state, int lookahead) { int i; /* find the rule to reduce by to get precedence of reduction */ - int redprec = rule_table[LAruleno[lookahead]].prec; - errs *errp = ERRS_ALLOC (ntokens + 1); - short *errtokens = errp->errs; + int redprec = rules[LAruleno[lookahead]].prec; + errs *errp = errs_new (ntokens + 1); + errp->nerrs = 0; for (i = 0; i < ntokens; i++) if (BITISSET (LA (lookahead), i) && BITISSET (lookaheadset, i) - && sprec[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 (sprec[i] > redprec) + else if (symbols[i]->prec > redprec) { log_resolution (state, lookahead, i, _("shift")); flush_reduce (lookahead, i); @@ -120,7 +122,7 @@ resolve_sr_conflict (int state, int lookahead) For right association, keep only the shift. For nonassociation, keep neither. */ - switch (sassoc[i]) + switch (symbols[i]->assoc) { case right_assoc: log_resolution (state, lookahead, i, _("shift")); @@ -137,34 +139,31 @@ resolve_sr_conflict (int state, int lookahead) flush_shift (state, i); flush_reduce (lookahead, i); /* Record an explicit error for this token. */ - *errtokens++ = i; + errp->errs[errp->nerrs++] = i; break; } } - errp->nerrs = errtokens - errp->errs; /* Some tokens have been explicitly made errors. Allocate a permanent errs structure for this state, to record them. */ - i = (char *) errtokens - (char *) errp; - state_table[state]->errs = ERRS_ALLOC (i + 1); - memcpy (state_table[state]->errs, errp, i); + state->errs = errs_dup (errp); free (errp); } static void -set_conflicts (int state) +set_conflicts (state_t *state) { int i, j; shifts *shiftp; - if (state_table[state]->consistent) + if (state->consistent) return; for (i = 0; i < tokensetsize; i++) lookaheadset[i] = 0; - shiftp = state_table[state]->shifts; + 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)); @@ -172,30 +171,26 @@ set_conflicts (int state) /* Loop over all rules which require lookahead in this state. First check for shift-reduce conflict, and try to resolve using precedence */ - for (i = state_table[state]->lookaheads; - i < state_table[state + 1]->lookaheads; - ++i) - if (rule_table[LAruleno[i]].prec) + for (i = 0; i < state->nlookaheads; ++i) + if (rules[LAruleno[state->lookaheadsp + i]].prec) for (j = 0; j < tokensetsize; ++j) - if (LA (i)[j] & lookaheadset[j]) + if (LA (state->lookaheadsp + i)[j] & lookaheadset[j]) { - resolve_sr_conflict (state, i); + 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 = state_table[state]->lookaheads; - i < state_table[state + 1]->lookaheads; - ++i) + for (i = 0; i < state->nlookaheads; ++i) { for (j = 0; j < tokensetsize; ++j) - if (LA (i)[j] & lookaheadset[j]) - conflicts[state] = 1; + if (LA (state->lookaheadsp + i)[j] & lookaheadset[j]) + conflicts[state->number] = 1; for (j = 0; j < tokensetsize; ++j) - lookaheadset[j] |= LA (i)[j]; + lookaheadset[j] |= LA (state->lookaheadsp + i)[j]; } } @@ -209,7 +204,7 @@ solve_conflicts (void) lookaheadset = XCALLOC (unsigned, tokensetsize); for (i = 0; i < nstates; i++) - set_conflicts (i); + set_conflicts (states[i]); } @@ -218,11 +213,11 @@ solve_conflicts (void) `---------------------------------------------*/ static int -count_sr_conflicts (int state) +count_sr_conflicts (state_t *state) { int i, k; int src_count = 0; - shifts *shiftp = state_table[state]->shifts; + shifts *shiftp = state->shifts; if (!shiftp) return 0; @@ -237,11 +232,9 @@ count_sr_conflicts (int state) if (!SHIFT_IS_DISABLED (shiftp, i)) SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); - for (i = state_table[state]->lookaheads; - i < state_table[state + 1]->lookaheads; - ++i) + for (i = 0; i < state->nlookaheads; ++i) for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] |= LA (i)[k]; + lookaheadset[k] |= LA (state->lookaheadsp + i)[k]; for (k = 0; k < tokensetsize; ++k) lookaheadset[k] &= shiftset[k]; @@ -259,23 +252,20 @@ count_sr_conflicts (int state) `----------------------------------------------*/ static int -count_rr_conflicts (int state) +count_rr_conflicts (state_t *state) { int i; int rrc_count = 0; - int m = state_table[state]->lookaheads; - int n = state_table[state + 1]->lookaheads; - - if (n - m < 2) + if (state->nlookaheads < 2) return 0; for (i = 0; i < ntokens; i++) { int count = 0; int j; - for (j = m; j < n; j++) - if (BITISSET (LA (m), j)) + for (j = 0; j < state->nlookaheads; ++j) + if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j)) count++; if (count >= 2) @@ -337,8 +327,8 @@ conflicts_output (FILE *out) 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) @@ -367,8 +357,8 @@ 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]); } src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts); @@ -409,143 +399,6 @@ conflicts_print (void) } -void -print_reductions (FILE *out, int state) -{ - int i; - int j; - int m; - int n; - shifts *shiftp; - errs *errp; - int nodefault = 0; - - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; - - shiftp = state_table[state]->shifts; - for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) - if (!SHIFT_IS_DISABLED (shiftp, i)) - { - /* if this state has a shift for the error token, don't use a - default rule. */ - if (SHIFT_IS_ERROR (shiftp, i)) - nodefault = 1; - SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); - } - - errp = state_table[state]->errs; - if (errp) - for (i = 0; i < errp->nerrs; i++) - if (errp->errs[i]) - SETBIT (shiftset, errp->errs[i]); - - m = state_table[state]->lookaheads; - n = state_table[state + 1]->lookaheads; - - if (n - m == 1 && !nodefault) - { - int k; - int default_rule = LAruleno[m]; - - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] = LA (m)[k] & shiftset[k]; - - for (i = 0; i < ntokens; i++) - if (BITISSET (lookaheadset, i)) - fprintf (out, _(" %-4s\t[reduce using rule %d (%s)]\n"), - tags[i], default_rule, - tags[rule_table[default_rule].lhs]); - - fprintf (out, _(" $default\treduce using rule %d (%s)\n\n"), - default_rule, tags[rule_table[default_rule].lhs]); - } - else if (n - m >= 1) - { - int k; - - int cmax = 0; - int default_LA = -1; - int default_rule = 0; - - if (!nodefault) - for (i = m; i < n; i++) - { - int count = 0; - - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] = LA (i)[k] & ~shiftset[k]; - - for (j = 0; j < ntokens; j++) - if (BITISSET (lookaheadset, j)) - count++; - - if (count > cmax) - { - cmax = count; - default_LA = i; - default_rule = LAruleno[i]; - } - - for (k = 0; k < tokensetsize; ++k) - shiftset[k] |= lookaheadset[k]; - } - - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; - - for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) - if (!SHIFT_IS_DISABLED (shiftp, i)) - SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); - - for (i = 0; i < ntokens; i++) - { - int defaulted = 0; - int count = BITISSET (shiftset, i); - - for (j = m; j < n; j++) - { - if (BITISSET (LA (m), j)) - { - if (count == 0) - { - if (j != default_LA) - fprintf (out, - _(" %-4s\treduce using rule %d (%s)\n"), - tags[i], - LAruleno[j], - tags[rule_table[LAruleno[j]].lhs]); - else - defaulted = 1; - - count++; - } - else - { - if (defaulted) - 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], - LAruleno[j], - tags[rule_table[LAruleno[j]].lhs]); - } - } - } - } - - if (default_LA >= 0) - fprintf (out, _(" $default\treduce using rule %d (%s)\n"), - default_rule, tags[rule_table[default_rule].lhs]); - } -} - - void free_conflicts (void) {