switch (resolution)
{
case shift_resolution:
- case left_resolution:
+ case right_resolution:
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as shift"),
symbols[token]->tag);
break;
case reduce_resolution:
- case right_resolution:
+ case left_resolution:
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as reduce"),
static void
flush_shift (state_t *state, int token)
{
- transitions_t *transitions = state->shifts;
+ transitions_t *transitions = state->transitions;
int i;
bitset_reset (lookaheadset, token);
| shift or reduce tables so that there is no longer a conflict. |
| |
| LOOKAHEAD is the number of the lookahead bitset to consider. |
+| |
+| ERRS can be used to store discovered explicit errors. |
`------------------------------------------------------------------*/
static void
-resolve_sr_conflict (state_t *state, int lookahead)
+resolve_sr_conflict (state_t *state, int lookahead,
+ symbol_t **errs)
{
symbol_number_t i;
/* Find the rule to reduce by to get precedence of reduction. */
rule_t *redrule = state->lookaheads_rule[lookahead];
int redprec = redrule->prec->prec;
bitset lookaheads = state->lookaheads[lookahead];
- errs_t *errp = errs_new (ntokens + 1);
- errp->num = 0;
+ int nerrs = 0;
for (i = 0; i < ntokens; i++)
if (bitset_test (lookaheads, i)
flush_shift (state, i);
flush_reduce (lookaheads, i);
/* Record an explicit error for this token. */
- errp->symbols[errp->num++] = i;
+ errs[nerrs++] = symbols[i];
break;
case undef_assoc:
/* 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);
+ state_errs_set (state, nerrs, errs);
if (obstack_object_size (&solved_conflicts_obstack))
{
}
+/*-------------------------------------------------------------------.
+| Solve the S/R conflicts of STATE using the |
+| precedence/associativity, and flag it inconsistent if it still has |
+| conflicts. ERRS can be used as storage to compute the list of |
+| lookaheads on which this STATE raises a parse error (%nonassoc). |
+`-------------------------------------------------------------------*/
+
static void
-set_conflicts (state_t *state)
+set_conflicts (state_t *state, symbol_t **errs)
{
int i;
- transitions_t *transitions;
+ transitions_t *transitions = state->transitions;
if (state->consistent)
return;
bitset_zero (lookaheadset);
- transitions = state->shifts;
- for (i = 0; i < transitions->num && TRANSITION_IS_SHIFT (transitions, i); i++)
- if (!TRANSITION_IS_DISABLED (transitions, i))
- bitset_set (lookaheadset, TRANSITION_SYMBOL (transitions, i));
+ FOR_EACH_SHIFT (transitions, i)
+ bitset_set (lookaheadset, TRANSITION_SYMBOL (transitions, i));
/* Loop over all rules which require lookahead in this state. First
check for shift-reduce conflict, and try to resolve using
&& state->lookaheads_rule[i]->prec->prec
&& !bitset_disjoint_p (state->lookaheads[i], lookaheadset))
{
- resolve_sr_conflict (state, i);
+ resolve_sr_conflict (state, i, errs);
break;
}
}
}
+
+/*----------------------------------------------------------------.
+| Solve all the S/R conflicts using the precedence/associativity, |
+| and flag as inconsistent the states that still have conflicts. |
+`----------------------------------------------------------------*/
+
void
conflicts_solve (void)
{
state_number_t i;
+ /* List of lookaheads on which we explicitly raise a parse error. */
+ symbol_t **errs = XMALLOC (symbol_t *, ntokens + 1);
conflicts = XCALLOC (char, nstates);
shiftset = bitset_create (ntokens, BITSET_FIXED);
obstack_init (&solved_conflicts_obstack);
for (i = 0; i < nstates; i++)
- set_conflicts (states[i]);
+ {
+ set_conflicts (states[i], errs);
+
+ /* 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);
+ }
+
+ free (errs);
}
{
int i;
int src_count = 0;
- transitions_t *transitions = state->shifts;
+ transitions_t *transitions = state->transitions;
if (!transitions)
return 0;
bitset_zero (lookaheadset);
bitset_zero (shiftset);
- for (i = 0; i < transitions->num && TRANSITION_IS_SHIFT (transitions, i); i++)
- if (!TRANSITION_IS_DISABLED (transitions, i))
- bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+ FOR_EACH_SHIFT (transitions, i)
+ bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
for (i = 0; i < state->nlookaheads; ++i)
bitset_or (lookaheadset, lookaheadset, state->lookaheads[i]);
conflicts_output (FILE *out)
{
bool printed_sth = FALSE;
+ bool *used_rules = XCALLOC (bool, nrules);
state_number_t i;
for (i = 0; i < nstates; i++)
- if (conflicts[i])
- {
- fprintf (out, _("State %d contains "), i);
- fputs (conflict_report (count_sr_conflicts (states[i]),
- count_rr_conflicts (states[i], TRUE)), out);
- printed_sth = TRUE;
- }
+ {
+ state_t *s = states[i];
+ int j;
+ for (j = 0; j < s->reductions->num; ++j)
+ used_rules[s->reductions->rules[j]->number] = TRUE;
+ if (conflicts[i])
+ {
+ fprintf (out, _("State %d contains "), i);
+ fputs (conflict_report (count_sr_conflicts (s),
+ count_rr_conflicts (s, TRUE)), out);
+ printed_sth = TRUE;
+ }
+ }
if (printed_sth)
fputs ("\n\n", out);
+
+ for (i = 0; i < nstates; i++)
+ {
+ state_t *s = states[i];
+ reductions_t *r = s->reductions;
+ int j;
+ for (j = 0; j < r->num; ++j)
+ if (!used_rules[r->rules[j]->number])
+ {
+ LOCATION_PRINT (stderr, r->rules[j]->location);
+ fprintf (stderr, ": %s: %s: ",
+ _("warning"),
+ _("rule never reduced because of conflicts"));
+ rule_print (r->rules[j], stderr);
+ }
+ }
+ free (used_rules);
}
/*--------------------------------------------------------.
projects / bison.git / blobdiff