while (*sp >= 0)
sp++;
- rule = -(*sp);
+ rule = item_number_as_rule_number (*sp);
rule_lhs_print (&rules[rule], previous_lhs, out);
previous_lhs = rules[rule].lhs;
for (sp = rules[rule].rhs; sp < sp1; sp++)
- fprintf (out, " %s", symbol_tag_get (symbols[*sp]));
+ fprintf (out, " %s", symbols[*sp]->tag);
fputs (" .", out);
for (/* Nothing */; *sp >= 0; ++sp)
- fprintf (out, " %s", symbol_tag_get (symbols[*sp]));
+ fprintf (out, " %s", symbols[*sp]->tag);
/* Display the lookaheads? */
if (report_flag & report_lookaheads)
static void
print_transitions (state_t *state, FILE *out, bool display_transitions_p)
{
- transitions_t *transitions = state->shifts;
+ transitions_t *transitions = state->transitions;
size_t width = 0;
int i;
&& TRANSITION_IS_SHIFT (transitions, i) == display_transitions_p)
{
symbol_t *symbol = symbols[TRANSITION_SYMBOL (transitions, i)];
- max_length (&width, symbol_tag_get (symbol));
+ max_length (&width, symbol->tag);
}
/* Nothing to report. */
&& TRANSITION_IS_SHIFT (transitions, i) == display_transitions_p)
{
symbol_t *symbol = symbols[TRANSITION_SYMBOL (transitions, i)];
- const char *tag = symbol_tag_get (symbol);
- state_number_t state1 = transitions->states[i];
+ const char *tag = symbol->tag;
+ state_t *state1 = transitions->states[i];
int j;
fprintf (out, " %s", tag);
for (j = width - strlen (tag); j > 0; --j)
fputc (' ', out);
if (display_transitions_p)
- fprintf (out, _("shift, and go to state %d\n"), state1);
+ fprintf (out, _("shift, and go to state %d\n"), state1->number);
else
- fprintf (out, _("go to state %d\n"), state1);
+ fprintf (out, _("go to state %d\n"), state1->number);
}
}
int i;
/* Compute the width of the lookaheads column. */
- for (i = 0; i < errp->nerrs; ++i)
- if (errp->errs[i])
- max_length (&width, symbol_tag_get (symbols[errp->errs[i]]));
+ for (i = 0; i < errp->num; ++i)
+ if (errp->symbols[i])
+ max_length (&width, errp->symbols[i]->tag);
/* Nothing to report. */
if (!width)
width += 2;
/* Report lookaheads and errors. */
- for (i = 0; i < errp->nerrs; ++i)
- if (errp->errs[i])
+ for (i = 0; i < errp->num; ++i)
+ if (errp->symbols[i])
{
- const char *tag = symbol_tag_get (symbols[errp->errs[i]]);
+ const char *tag = errp->symbols[i]->tag;
int j;
fprintf (out, " %s", tag);
for (j = width - strlen (tag); j > 0; --j)
/* No need for a lookahead. */
if (state->consistent)
- return &rules[redp->rules[0]];
+ return redp->rules[0];
/* 1. Each reduction is possibly masked by the lookaheads on which
we shift (S/R conflicts)... */
bitset_zero (shiftset);
{
- transitions_t *transitions = state->shifts;
- for (i = 0; i < transitions->num && TRANSITION_IS_SHIFT (transitions, i); i++)
- if (!TRANSITION_IS_DISABLED (transitions, i))
- {
- /* If this state has a shift for the error token, don't use a
+ transitions_t *transitions = state->transitions;
+ FOR_EACH_SHIFT (transitions, i)
+ {
+ /* If this state has a shift for the error token, don't use a
default rule. */
- if (TRANSITION_IS_ERROR (transitions, i))
- return NULL;
- bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
- }
+ if (TRANSITION_IS_ERROR (transitions, i))
+ return NULL;
+ bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+ }
}
/* 2. Each reduction is possibly masked by the lookaheads on which
we raise an error (due to %nonassoc). */
{
errs_t *errp = state->errs;
- for (i = 0; i < errp->nerrs; i++)
- if (errp->errs[i])
- bitset_set (shiftset, errp->errs[i]);
+ for (i = 0; i < errp->num; i++)
+ if (errp->symbols[i])
+ bitset_set (shiftset, errp->symbols[i]->number);
}
- for (i = 0; i < state->nlookaheads; ++i)
+ for (i = 0; i < redp->num; ++i)
{
int count = 0;
/* How many non-masked lookaheads are there for this reduction?
*/
- bitset_andn (lookaheadset, state->lookaheads[i], shiftset);
+ bitset_andn (lookaheadset, redp->lookaheads[i], shiftset);
count = bitset_count (lookaheadset);
if (count > cmax)
{
cmax = count;
- default_rule = state->lookaheads_rule[i];
+ default_rule = redp->rules[i];
}
/* 3. And finally, each reduction is possibly masked by previous
reductions (in R/R conflicts, we keep the first reductions).
*/
- bitset_or (shiftset, shiftset, state->lookaheads[i]);
+ bitset_or (shiftset, shiftset, redp->lookaheads[i]);
}
return default_rule;
fputc (' ', out);
if (!enabled)
fputc ('[', out);
- fprintf (out, _("reduce using rule %d (%s)"),
- rule->number - 1, symbol_tag_get (rule->lhs));
+ if (rule->number)
+ fprintf (out, _("reduce using rule %d (%s)"),
+ rule->number, rule->lhs->tag);
+ else
+ fprintf (out, _("accept"));
if (!enabled)
fputc (']', out);
fputc ('\n', out);
static void
print_reductions (FILE *out, state_t *state)
{
- transitions_t *transitions = state->shifts;
+ transitions_t *transitions = state->transitions;
reductions_t *redp = state->reductions;
rule_t *default_rule = NULL;
size_t width = 0;
int i, j;
- if (redp->nreds == 0)
+ if (redp->num == 0)
return;
default_rule = state_default_rule (state);
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));
/* Compute the width of the lookaheads column. */
if (default_rule)
width = strlen (_("$default"));
- for (i = 0; i < ntokens; i++)
- {
- int count = bitset_test (shiftset, i);
- for (j = 0; j < state->nlookaheads; ++j)
- if (bitset_test (state->lookaheads[j], i))
- {
- if (count == 0)
- {
- if (state->lookaheads_rule[j] != default_rule)
- max_length (&width, symbol_tag_get (symbols[i]));
- count++;
- }
- else
- {
- max_length (&width, symbol_tag_get (symbols[i]));
- }
- }
- }
+ if (redp->lookaheads)
+ for (i = 0; i < ntokens; i++)
+ {
+ int count = bitset_test (shiftset, i);
+
+ for (j = 0; j < redp->num; ++j)
+ if (bitset_test (redp->lookaheads[j], i))
+ {
+ if (count == 0)
+ {
+ if (redp->rules[j] != default_rule)
+ max_length (&width, symbols[i]->tag);
+ count++;
+ }
+ else
+ {
+ max_length (&width, symbols[i]->tag);
+ }
+ }
+ }
/* Nothing to report. */
if (!width)
width += 2;
/* Report lookaheads (or $default) and reductions. */
- for (i = 0; i < ntokens; i++)
- {
- int defaulted = 0;
- int count = bitset_test (shiftset, i);
+ if (redp->lookaheads)
+ for (i = 0; i < ntokens; i++)
+ {
+ int defaulted = 0;
+ int count = bitset_test (shiftset, i);
- for (j = 0; j < state->nlookaheads; ++j)
- if (bitset_test (state->lookaheads[j], i))
- {
- if (count == 0)
- {
- if (state->lookaheads_rule[j] != default_rule)
- print_reduction (out, width,
- symbol_tag_get (symbols[i]),
- state->lookaheads_rule[j], TRUE);
- else
- defaulted = 1;
- count++;
- }
- else
- {
- if (defaulted)
+ for (j = 0; j < redp->num; ++j)
+ if (bitset_test (redp->lookaheads[j], i))
+ {
+ if (count == 0)
+ {
+ if (redp->rules[j] != default_rule)
+ print_reduction (out, width,
+ symbols[i]->tag,
+ redp->rules[j], true);
+ else
+ defaulted = 1;
+ count++;
+ }
+ else
+ {
+ if (defaulted)
+ print_reduction (out, width,
+ symbols[i]->tag,
+ default_rule, true);
+ defaulted = 0;
print_reduction (out, width,
- symbol_tag_get (symbols[i]),
- default_rule, TRUE);
- defaulted = 0;
- print_reduction (out, width,
- symbol_tag_get (symbols[i]),
- state->lookaheads_rule[j], FALSE);
- }
- }
- }
+ symbols[i]->tag,
+ redp->rules[j], false);
+ }
+ }
+ }
if (default_rule)
print_reduction (out, width,
- _("$default"), default_rule, TRUE);
+ _("$default"), default_rule, true);
}
static void
print_actions (FILE *out, state_t *state)
{
- reductions_t *redp = state->reductions;
- transitions_t *transitions = state->shifts;
-
- if (transitions->num == 0 && redp->nreds == 0)
- {
- fputc ('\n', out);
- if (state->number == final_state->number)
- fprintf (out, _(" $default\taccept\n"));
- else
- fprintf (out, _(" NO ACTIONS\n"));
- return;
- }
-
/* Print shifts. */
- print_transitions (state, out, TRUE);
+ print_transitions (state, out, true);
print_errs (out, state);
print_reductions (out, state);
/* Print gotos. */
- print_transitions (state, out, FALSE);
+ print_transitions (state, out, false);
}
print_actions (out, state);
if ((report_flag & report_solved_conflicts)
&& state->solved_conflicts)
- fputs (state->solved_conflicts, out);
+ {
+ fputc ('\n', out);
+ fputs (state->solved_conflicts, out);
+ }
}
\f
/*-----------------------------------------.
for (i = 0; i < max_user_token_number + 1; i++)
if (token_translations[i] != undeftoken->number)
{
- const char *tag = symbol_tag_get (symbols[token_translations[i]]);
+ const char *tag = symbols[token_translations[i]]->tag;
rule_number_t r;
item_number_t *rhsp;
END_TEST (50);
sprintf (buffer, " (%d)", i);
- for (r = 1; r < nrules + 1; r++)
+ for (r = 0; r < nrules; r++)
for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
if (item_number_as_symbol_number (*rhsp) == token_translations[i])
{
END_TEST (65);
- sprintf (buffer + strlen (buffer), " %d", r - 1);
+ sprintf (buffer + strlen (buffer), " %d", r);
break;
}
fprintf (out, "%s\n", buffer);
{
int left_count = 0, right_count = 0;
rule_number_t r;
- const char *tag = symbol_tag_get (symbols[i]);
+ const char *tag = symbols[i]->tag;
- for (r = 1; r < nrules + 1; r++)
+ for (r = 0; r < nrules; r++)
{
item_number_t *rhsp;
if (rules[r].lhs->number == i)
END_TEST (50);
sprintf (buffer + strlen (buffer), _(" on left:"));
- for (r = 1; r < nrules + 1; r++)
+ for (r = 0; r < nrules; r++)
{
END_TEST (65);
if (rules[r].lhs->number == i)
- sprintf (buffer + strlen (buffer), " %d", r - 1);
+ sprintf (buffer + strlen (buffer), " %d", r);
}
}
sprintf (buffer + strlen (buffer), ",");
END_TEST (50);
sprintf (buffer + strlen (buffer), _(" on right:"));
- for (r = 1; r < nrules + 1; r++)
+ for (r = 0; r < nrules; r++)
{
item_number_t *rhsp;
for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
if (item_number_as_symbol_number (*rhsp) == i)
{
END_TEST (65);
- sprintf (buffer + strlen (buffer), " %d", r - 1);
+ sprintf (buffer + strlen (buffer), " %d", r);
break;
}
}
FILE *out = xfopen (spec_verbose_file, "w");
reduce_output (out);
+ grammar_rules_partial_print (out,
+ _("Rules never reduced"), rule_never_reduced_p);
conflicts_output (out);
print_grammar (out);
projects / bison.git / blobdiff