X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ccaf65bc6331dfb0684876a7475c6474b99125ea..b25d88f6d2e2f4b59927aacecdc0a9e44a34b5d9:/src/print.c?ds=sidebyside diff --git a/src/print.c b/src/print.c index c531b04c..ae2ead9a 100644 --- a/src/print.c +++ b/src/print.c @@ -97,16 +97,16 @@ print_core (FILE *out, state_t *state) 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) @@ -125,7 +125,7 @@ print_core (FILE *out, state_t *state) 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; @@ -135,7 +135,7 @@ print_transitions (state_t *state, FILE *out, bool display_transitions_p) && 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. */ @@ -151,17 +151,17 @@ print_transitions (state_t *state, FILE *out, bool display_transitions_p) && 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); } } @@ -178,9 +178,9 @@ print_errs (FILE *out, state_t *state) 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) @@ -190,10 +190,10 @@ print_errs (FILE *out, state_t *state) 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) @@ -218,52 +218,51 @@ state_default_rule (state_t *state) /* 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; @@ -287,8 +286,11 @@ print_reduction (FILE *out, size_t width, 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); @@ -302,44 +304,45 @@ print_reduction (FILE *out, size_t width, 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) @@ -349,41 +352,42 @@ print_reductions (FILE *out, state_t *state) 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); } @@ -395,25 +399,12 @@ print_reductions (FILE *out, state_t *state) 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); } @@ -431,7 +422,10 @@ print_state (FILE *out, state_t *state) 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); + } } /*-----------------------------------------. @@ -463,7 +457,7 @@ print_grammar (FILE *out) 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; @@ -473,12 +467,12 @@ print_grammar (FILE *out) 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); @@ -491,9 +485,9 @@ print_grammar (FILE *out) { 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) @@ -517,11 +511,11 @@ print_grammar (FILE *out) 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); } } @@ -531,14 +525,14 @@ print_grammar (FILE *out) 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; } } @@ -557,6 +551,8 @@ print_results (void) 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);