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
-resolve_sr_conflict (state_t *state, int lookahead,
- symbol_number_t *errs)
+resolve_sr_conflict (state_t *state, int ruleno,
+ symbol_t **errs)
{
symbol_number_t i;
+ reductions_t *reds = state->reductions;
/* Find the rule to reduce by to get precedence of reduction. */
- rule_t *redrule = state->lookaheads_rule[lookahead];
+ rule_t *redrule = reds->rules[ruleno];
int redprec = redrule->prec->prec;
- bitset lookaheads = state->lookaheads[lookahead];
+ bitset lookaheads = reds->lookaheads[ruleno];
int nerrs = 0;
for (i = 0; i < ntokens; i++)
flush_shift (state, i);
flush_reduce (lookaheads, i);
/* Record an explicit error for this token. */
- errs[nerrs++] = i;
+ errs[nerrs++] = symbols[i];
break;
case undef_assoc:
| 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). |
+| lookaheads on which this STATE raises a syntax error (%nonassoc). |
`-------------------------------------------------------------------*/
static void
-set_conflicts (state_t *state, symbol_number_t *errs)
+set_conflicts (state_t *state, symbol_t **errs)
{
int i;
transitions_t *transitions = state->transitions;
+ reductions_t *reds = state->reductions;
if (state->consistent)
return;
bitset_zero (lookaheadset);
- 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
precedence. */
- for (i = 0; i < state->nlookaheads; ++i)
- if (state->lookaheads_rule[i]->prec
- && state->lookaheads_rule[i]->prec->prec
- && !bitset_disjoint_p (state->lookaheads[i], lookaheadset))
+ for (i = 0; i < reds->num; ++i)
+ if (reds->rules[i]->prec && reds->rules[i]->prec->prec
+ && !bitset_disjoint_p (reds->lookaheads[i], lookaheadset))
{
resolve_sr_conflict (state, i, errs);
break;
/* Loop over all rules which require lookahead in this state. Check
for conflicts not resolved above. */
- for (i = 0; i < state->nlookaheads; ++i)
+ for (i = 0; i < reds->num; ++i)
{
- if (!bitset_disjoint_p (state->lookaheads[i], lookaheadset))
+ if (!bitset_disjoint_p (reds->lookaheads[i], lookaheadset))
conflicts[state->number] = 1;
- bitset_or (lookaheadset, lookaheadset, state->lookaheads[i]);
+ bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
}
}
conflicts_solve (void)
{
state_number_t i;
- /* List of lookaheads on which we explicitly raise a parse error. */
- symbol_number_t *errs = XMALLOC (symbol_number_t, ntokens + 1);
+ /* List of lookaheads on which we explicitly raise a syntax error. */
+ symbol_t **errs = XMALLOC (symbol_t *, ntokens + 1);
conflicts = XCALLOC (char, nstates);
shiftset = bitset_create (ntokens, BITSET_FIXED);
int i;
int src_count = 0;
transitions_t *transitions = state->transitions;
+ reductions_t *reds = state->reductions;
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]);
+ for (i = 0; i < reds->num; ++i)
+ bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
bitset_and (lookaheadset, lookaheadset, shiftset);
count_rr_conflicts (state_t *state, int one_per_token)
{
int i;
+ reductions_t *reds = state->reductions;
int rrc_count = 0;
- if (state->nlookaheads < 2)
- return 0;
-
for (i = 0; i < ntokens; i++)
{
int count = 0;
int j;
- for (j = 0; j < state->nlookaheads; ++j)
- if (bitset_test (state->lookaheads[j], i))
+ for (j = 0; j < reds->num; ++j)
+ if (bitset_test (reds->lookaheads[j], i))
count++;
if (count >= 2)
return rrc_count;
}
+
/*--------------------------------------------------------------.
| Return a human readable string which reports shift/reduce and |
| reduce/reduce conflict numbers (SRC_NUM, RRC_NUM). |
cp += strlen (cp);
}
- *cp++ = '.';
- *cp++ = '\n';
*cp++ = '\0';
return res;
}
+/*----------------------------------------------------------------.
+| Same as above, but report the number of conflicts a` la POSIX. |
+`----------------------------------------------------------------*/
+
+static void
+conflict_report_yacc (int src_num, int rrc_num)
+{
+ /* If invoked with `--yacc', use the output format specified by
+ POSIX. */
+ fprintf (stderr, _("conflicts: "));
+ if (src_num > 0)
+ fprintf (stderr, _(" %d shift/reduce"), src_num);
+ if (src_num > 0 && rrc_num > 0)
+ fprintf (stderr, ",");
+ if (rrc_num > 0)
+ fprintf (stderr, _(" %d reduce/reduce"), rrc_num);
+ putc ('\n', stderr);
+}
+
+
/*-----------------------------------------------------------.
| Output the detailed description of states with conflicts. |
`-----------------------------------------------------------*/
void
conflicts_output (FILE *out)
{
- bool printed_sth = FALSE;
+ bool printed_sth = false;
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];
+ if (conflicts[i])
+ {
+ fprintf (out, _("State %d contains "), i);
+ fprintf (out, "%s.\n",
+ conflict_report (count_sr_conflicts (s),
+ count_rr_conflicts (s, true)));
+ printed_sth = true;
+ }
+ }
if (printed_sth)
fputs ("\n\n", out);
}
if (conflicts[i])
{
count += count_sr_conflicts (states[i]);
- count += count_rr_conflicts (states[i], FALSE);
+ count += count_rr_conflicts (states[i], false);
}
return count;
}
if (conflicts[i])
{
src_total += count_sr_conflicts (states[i]);
- rrc_total += count_rr_conflicts (states[i], TRUE);
+ rrc_total += count_rr_conflicts (states[i], true);
}
}
/* Report the total number of conflicts on STDERR. */
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);
- }
+ conflict_report_yacc (src_total, rrc_total);
else
- {
- fprintf (stderr, _("%s contains "), infile);
- fputs (conflict_report (src_total, rrc_total), stderr);
- }
+ warn ("%s", conflict_report (src_total, rrc_total));
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);
- }
+ complain (ngettext ("expected %d shift/reduce conflict",
+ "expected %d shift/reduce conflicts",
+ expected_conflicts),
+ expected_conflicts);
}
projects / bison.git / blobdiff