From 577f5943e8d93dfe9fb3eb6eeabce0aca04bdcf2 Mon Sep 17 00:00:00 2001 From: Akim Demaille Date: Sun, 12 Jul 2020 15:16:51 +0200 Subject: [PATCH] style: s/lookahead_tokens/lookaheads/g Currently we use both names. Let's stick to the short one. * src/AnnotationList.c, src/conflicts.c, src/counterexample.c, * src/getargs.c, src/getargs.h, src/graphviz.c, src/ielr.c, * src/lalr.c, src/print-graph.c, src/print-xml.c, src/print.c, * src/state-item.c, src/state.c, src/state.h, src/tables.c: s/lookahead_token/lookahead/gi. --- src/AnnotationList.c | 10 ++++----- src/conflicts.c | 34 ++++++++++++++--------------- src/counterexample.c | 16 +++++++------- src/getargs.c | 2 +- src/getargs.h | 2 +- src/graphviz.c | 4 ++-- src/ielr.c | 2 +- src/lalr.c | 51 +++++++++++++++++++++----------------------- src/print-graph.c | 6 +++--- src/print-xml.c | 20 ++++++++--------- src/print.c | 20 ++++++++--------- src/state-item.c | 4 ++-- src/state.c | 14 ++++++------ src/state.h | 10 ++++----- src/tables.c | 8 +++---- tests/torture.at | 8 +++---- 16 files changed, 104 insertions(+), 107 deletions(-) diff --git a/src/AnnotationList.c b/src/AnnotationList.c index 421643b21..92b6690f2 100644 --- a/src/AnnotationList.c +++ b/src/AnnotationList.c @@ -169,10 +169,10 @@ AnnotationList__compute_conflicted_tokens (bitset shift_tokens, bitset_copy (tokens, shift_tokens); for (int i = 0; i < reds->num; ++i) { - bitset_and (conflicted_tokens_rule, tokens, reds->lookahead_tokens[i]); + bitset_and (conflicted_tokens_rule, tokens, reds->lookaheads[i]); bitset_or (conflicted_tokens, conflicted_tokens, conflicted_tokens_rule); - bitset_or (tokens, tokens, reds->lookahead_tokens[i]); + bitset_or (tokens, tokens, reds->lookaheads[i]); /* Check that rules are sorted on rule number or the next step in AnnotationList__compute_from_inadequacies will misbehave. */ aver (i == 0 || reds->rules[i-1] < reds->rules[i]); @@ -401,7 +401,7 @@ AnnotationList__compute_from_inadequacies ( struct obstack *annotations_obstackp, InadequacyListNodeCount *inadequacy_list_node_count) { - /* Return an empty list if s->lookahead_tokens = NULL. */ + /* Return an empty list if s->lookaheads = NULL. */ if (s->consistent) return; @@ -422,7 +422,7 @@ AnnotationList__compute_from_inadequacies ( /* Allocate the annotation node. */ { for (int rule_i = 0; rule_i < s->reductions->num; ++rule_i) - if (bitset_test (s->reductions->lookahead_tokens[rule_i], + if (bitset_test (s->reductions->lookaheads[rule_i], conflicted_token)) ++contribution_count; if (bitset_test (shift_tokens, conflicted_token)) @@ -445,7 +445,7 @@ AnnotationList__compute_from_inadequacies ( for (int rule_i = 0; rule_i < s->reductions->num; ++rule_i) { rule *the_rule = s->reductions->rules[rule_i]; - if (bitset_test (s->reductions->lookahead_tokens[rule_i], + if (bitset_test (s->reductions->lookaheads[rule_i], conflicted_token)) { bitset_set (actions, rule_i); diff --git a/src/conflicts.c b/src/conflicts.c index f33f1b1bb..b6307358f 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -250,9 +250,9 @@ flush_shift (state *s, int token) `--------------------------------------------------------------------*/ static void -flush_reduce (bitset lookahead_tokens, int token) +flush_reduce (bitset lookaheads, int token) { - bitset_reset (lookahead_tokens, token); + bitset_reset (lookaheads, token); } @@ -275,10 +275,10 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs) /* Find the rule to reduce by to get precedence of reduction. */ rule *redrule = reds->rules[ruleno]; int redprec = redrule->prec->prec; - bitset lookahead_tokens = reds->lookahead_tokens[ruleno]; + bitset lookaheads = reds->lookaheads[ruleno]; for (symbol_number i = 0; i < ntokens; ++i) - if (bitset_test (lookahead_tokens, i) + if (bitset_test (lookaheads, i) && bitset_test (lookahead_set, i) && symbols[i]->content->prec) { @@ -295,7 +295,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs) { register_precedence (i, redrule->prec->number); log_resolution (redrule, i, shift_resolution); - flush_reduce (lookahead_tokens, i); + flush_reduce (lookaheads, i); } else /* Matching precedence levels. @@ -316,7 +316,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs) case right_assoc: register_assoc (i, redrule->prec->number); log_resolution (redrule, i, right_resolution); - flush_reduce (lookahead_tokens, i); + flush_reduce (lookaheads, i); break; case left_assoc: @@ -329,7 +329,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs) register_assoc (i, redrule->prec->number); log_resolution (redrule, i, nonassoc_resolution); flush_shift (s, i); - flush_reduce (lookahead_tokens, i); + flush_reduce (lookaheads, i); /* Record an explicit error for this token. */ errors[(*nerrs)++] = symbols[i]; break; @@ -369,7 +369,7 @@ set_conflicts (state *s, symbol **errors) for (int i = 0; i < reds->num; ++i) if (reds->rules[i]->prec && reds->rules[i]->prec->prec - && !bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set)) + && !bitset_disjoint_p (reds->lookaheads[i], lookahead_set)) resolve_sr_conflict (s, i, errors, &nerrs); if (nerrs) @@ -385,13 +385,13 @@ set_conflicts (state *s, symbol **errors) /* Loop over all rules which require lookahead in this state. Check for conflicts not resolved above. - reds->lookahead_tokens can be NULL if the LR type is LR(0). */ - if (reds->lookahead_tokens) + reds->lookaheads can be NULL if the LR type is LR(0). */ + if (reds->lookaheads) for (int i = 0; i < reds->num; ++i) { - if (!bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set)) + if (!bitset_disjoint_p (reds->lookaheads[i], lookahead_set)) conflicts[s->number] = true; - bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]); + bitset_or (lookahead_set, lookahead_set, reds->lookaheads[i]); } } @@ -460,7 +460,7 @@ count_state_sr_conflicts (const state *s) } for (int i = 0; i < reds->num; ++i) - bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]); + bitset_or (lookahead_set, lookahead_set, reds->lookaheads[i]); bitset_and (lookahead_set, lookahead_set, shift_set); @@ -499,7 +499,7 @@ count_state_rr_conflicts (const state *s) { int count = 0; for (int j = 0; j < reds->num; ++j) - count += bitset_test (reds->lookahead_tokens[j], i); + count += bitset_test (reds->lookaheads[j], i); if (2 <= count) res += count-1; } @@ -534,7 +534,7 @@ count_rule_state_sr_conflicts (rule *r, state *s) for (int i = 0; i < reds->num; ++i) if (reds->rules[i] == r) { - bitset lookaheads = reds->lookahead_tokens[i]; + bitset lookaheads = reds->lookaheads[i]; int j; FOR_EACH_SHIFT (trans, j) res += bitset_test (lookaheads, TRANSITION_SYMBOL (trans, j)); @@ -576,8 +576,8 @@ count_rule_state_rr_conflicts (rule *r, state *s) if (reds->rules[j] != r) { bitset_and (lookaheads, - reds->lookahead_tokens[i], - reds->lookahead_tokens[j]); + reds->lookaheads[i], + reds->lookaheads[j]); res += bitset_count (lookaheads); } bitset_free (lookaheads); diff --git a/src/counterexample.c b/src/counterexample.c index adb13caa5..6735cd458 100644 --- a/src/counterexample.c +++ b/src/counterexample.c @@ -1286,7 +1286,7 @@ counterexample_report_state (const state *s, FILE *out, const char *prefix) { const state_number sn = s->number; const reductions *reds = s->reductions; - bitset lookahead_tokens = bitset_create (ntokens, BITSET_FIXED); + bitset lookaheads = bitset_create (ntokens, BITSET_FIXED); for (int i = 0; i < reds->num; ++i) { const rule *r1 = reds->rules[i]; @@ -1296,25 +1296,25 @@ counterexample_report_state (const state *s, FILE *out, const char *prefix) { item_number conf = *state_items[c2].item; if (item_number_is_symbol_number (conf) - && bitset_test (reds->lookahead_tokens[i], conf)) + && bitset_test (reds->lookaheads[i], conf)) counterexample_report_shift_reduce (c1, c2, conf, out, prefix); } for (int j = i+1; j < reds->num; ++j) { const rule *r2 = reds->rules[j]; // Conflicts: common lookaheads. - bitset_intersection (lookahead_tokens, - reds->lookahead_tokens[i], - reds->lookahead_tokens[j]); - if (!bitset_empty_p (lookahead_tokens)) + bitset_intersection (lookaheads, + reds->lookaheads[i], + reds->lookaheads[j]); + if (!bitset_empty_p (lookaheads)) for (state_item_number c2 = state_item_map[sn]; c2 < state_item_map[sn + 1]; ++c2) if (!SI_DISABLED (c2) && item_rule (state_items[c2].item) == r2) { - counterexample_report_reduce_reduce (c1, c2, lookahead_tokens, out, prefix); + counterexample_report_reduce_reduce (c1, c2, lookaheads, out, prefix); break; } } } - bitset_free (lookahead_tokens); + bitset_free (lookaheads); } diff --git a/src/getargs.c b/src/getargs.c index f6c4d1823..a15c07b5a 100644 --- a/src/getargs.c +++ b/src/getargs.c @@ -221,7 +221,7 @@ static const argmatch_report_arg argmatch_report_args[] = { "none", report_none }, { "states", report_states }, { "itemsets", report_states | report_itemsets }, - { "lookaheads", report_states | report_lookahead_tokens }, + { "lookaheads", report_states | report_lookaheads }, { "solved", report_states | report_solved_conflicts }, { "counterexamples", report_cex }, { "cex", report_cex }, diff --git a/src/getargs.h b/src/getargs.h index 8c47fa581..538266878 100644 --- a/src/getargs.h +++ b/src/getargs.h @@ -77,7 +77,7 @@ enum report report_none = 0, report_states = 1 << 0, report_itemsets = 1 << 1, - report_lookahead_tokens = 1 << 2, + report_lookaheads = 1 << 2, report_solved_conflicts = 1 << 3, report_cex = 1 << 4, report_all = ~0 diff --git a/src/graphviz.c b/src/graphviz.c index 34d80b032..e75bbb193 100644 --- a/src/graphviz.c +++ b/src/graphviz.c @@ -184,9 +184,9 @@ output_red (state const *s, reductions const *reds, FILE *fout) bool firste = true; rule_number ruleno = reds->rules[j]->number; - if (reds->lookahead_tokens) + if (reds->lookaheads) for (int i = 0; i < ntokens; i++) - if (bitset_test (reds->lookahead_tokens[j], i)) + if (bitset_test (reds->lookaheads[j], i)) { if (bitset_test (no_reduce_set, i)) firstd = print_token (&dout, firstd, symbols[i]->tag); diff --git a/src/ielr.c b/src/ielr.c index 89e37fe47..11e4375a7 100644 --- a/src/ielr.c +++ b/src/ielr.c @@ -1025,7 +1025,7 @@ ielr_split_states (bitsetv follow_kernel_items, bitsetv always_follows, { rule *this_rule = node->state->reductions->rules[r]; bitset lookahead_set = - node->state->reductions->lookahead_tokens[r]; + node->state->reductions->lookaheads[r]; if (item_number_is_rule_number (*this_rule->rhs)) ielr_compute_goto_follow_set (follow_kernel_items, always_follows, node, diff --git a/src/lalr.c b/src/lalr.c index c6e096c8b..0f5d7147a 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -256,9 +256,9 @@ lookback_find_state (int lookback_index) state *res = NULL; for (int j = 0; j < nstates; ++j) if (states[j]->reductions - && states[j]->reductions->lookahead_tokens) + && states[j]->reductions->lookaheads) { - if (states[j]->reductions->lookahead_tokens - LA > lookback_index) + if (states[j]->reductions->lookaheads - LA > lookback_index) /* Went too far. */ break; else @@ -280,7 +280,7 @@ lookback_print (FILE *out) { fprintf (out, " %3d = ", i); const state *s = lookback_find_state (i); - int rnum = i - (s->reductions->lookahead_tokens - LA); + int rnum = i - (s->reductions->lookaheads - LA); const rule *r = s->reductions->rules[rnum]; fprintf (out, "(%3d, ", s->number); rule_print (r, NULL, out); @@ -305,7 +305,7 @@ static void add_lookback_edge (state *s, rule const *r, goto_number gotono) { int ri = state_reduction_find (s, r); - int idx = (s->reductions->lookahead_tokens - LA) + ri; + int idx = (s->reductions->lookaheads - LA) + ri; lookback[idx] = goto_list_new (gotono, lookback[idx]); } @@ -421,7 +421,7 @@ compute_follows (void) static void -compute_lookahead_tokens (void) +compute_lookaheads (void) { if (trace_flag & trace_automaton) lookback_print (stderr); @@ -437,13 +437,12 @@ compute_lookahead_tokens (void) } -/*----------------------------------------------------. -| Count the number of lookahead tokens required for S | -| (N_LOOKAHEAD_TOKENS member). | -`----------------------------------------------------*/ +/*------------------------------------------------------. +| Count the number of lookahead tokens required for S. | +`------------------------------------------------------*/ static int -state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept) +state_lookaheads_count (state *s, bool default_reduction_only_for_accept) { const reductions *reds = s->reductions; const transitions *trans = s->transitions; @@ -473,9 +472,9 @@ state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept) } -/*----------------------------------------------------. -| Compute LA, NLA, and the lookahead_tokens members. | -`----------------------------------------------------*/ +/*----------------------------------------------. +| Compute LA, NLA, and the lookaheads members. | +`----------------------------------------------*/ void initialize_LA (void) @@ -491,25 +490,23 @@ initialize_LA (void) /* Compute the total number of reductions requiring a lookahead. */ nLA = 0; for (state_number i = 0; i < nstates; ++i) - nLA += - state_lookahead_tokens_count (states[i], - default_reduction_only_for_accept); + nLA += state_lookaheads_count (states[i], + default_reduction_only_for_accept); /* Avoid having to special case 0. */ if (!nLA) nLA = 1; bitsetv pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED); - /* Initialize the members LOOKAHEAD_TOKENS for each state whose reductions + /* Initialize the members LOOKAHEADS for each state whose reductions require lookahead tokens. */ for (state_number i = 0; i < nstates; ++i) { - int count = - state_lookahead_tokens_count (states[i], - default_reduction_only_for_accept); + int count = state_lookaheads_count (states[i], + default_reduction_only_for_accept); if (count) { - states[i]->reductions->lookahead_tokens = pLA; + states[i]->reductions->lookaheads = pLA; pLA += count; } } @@ -521,7 +518,7 @@ initialize_LA (void) `---------------------------------------------*/ static void -lookahead_tokens_print (FILE *out) +lookaheads_print (FILE *out) { fputs ("Lookaheads:\n", out); for (state_number i = 0; i < nstates; ++i) @@ -533,11 +530,11 @@ lookahead_tokens_print (FILE *out) for (int j = 0; j < reds->num; ++j) { fprintf (out, " rule %d:", reds->rules[j]->number); - if (reds->lookahead_tokens) + if (reds->lookaheads) { bitset_iterator iter; int k; - BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0) + BITSET_FOR_EACH (iter, reds->lookaheads[j], k, 0) fprintf (out, " %s", symbols[k]->tag); } fputc ('\n', out); @@ -564,10 +561,10 @@ lalr (void) lookback = xcalloc (nLA, sizeof *lookback); build_relations (); compute_follows (); - compute_lookahead_tokens (); + compute_lookaheads (); if (trace_flag & trace_sets) - lookahead_tokens_print (stderr); + lookaheads_print (stderr); if (trace_flag & trace_automaton) { begin_use_class ("trace0", stderr); @@ -614,6 +611,6 @@ void lalr_free (void) { for (state_number s = 0; s < nstates; ++s) - states[s]->reductions->lookahead_tokens = NULL; + states[s]->reductions->lookaheads = NULL; bitsetv_free (LA); } diff --git a/src/print-graph.c b/src/print-graph.c index f99555aa5..48836f266 100644 --- a/src/print-graph.c +++ b/src/print-graph.c @@ -96,7 +96,7 @@ print_core (struct obstack *oout, state *s) obstack_sgrow (oout, " %empty"); /* Experimental feature: display the lookahead tokens. */ - if (report_flag & report_lookahead_tokens + if (report_flag & report_lookaheads && item_number_is_rule_number (*sp1)) { /* Find the reduction we are handling. */ @@ -104,13 +104,13 @@ print_core (struct obstack *oout, state *s) int redno = state_reduction_find (s, r); /* Print them if there are. */ - if (reds->lookahead_tokens && redno != -1) + if (reds->lookaheads && redno != -1) { bitset_iterator biter; int k; char const *sep = ""; obstack_sgrow (oout, " ["); - BITSET_FOR_EACH (biter, reds->lookahead_tokens[redno], k, 0) + BITSET_FOR_EACH (biter, reds->lookaheads[redno], k, 0) { obstack_sgrow (oout, sep); obstack_backslash (oout, symbols[k]->tag); diff --git a/src/print-xml.c b/src/print-xml.c index bd2310456..2f1ad5b1a 100644 --- a/src/print-xml.c +++ b/src/print-xml.c @@ -86,12 +86,12 @@ print_core (FILE *out, int level, state *s) reductions *reds = s->reductions; int red = state_reduction_find (s, r); /* Print item with lookaheads if there are. */ - if (reds->lookahead_tokens && red != -1) + if (reds->lookaheads && red != -1) { xml_printf (out, level + 1, "", r->number, sp1 - sp); - state_rule_lookahead_tokens_print_xml (s, r, + state_rule_lookaheads_print_xml (s, r, out, level + 2); xml_puts (out, level + 1, ""); printed = true; @@ -203,25 +203,25 @@ print_errs (FILE *out, int level, state *s) /*-------------------------------------------------------------------------. -| Report a reduction of RULE on LOOKAHEAD_TOKEN (which can be 'default'). | +| Report a reduction of RULE on LOOKAHEAD (which can be 'default'). | | If not ENABLED, the rule is masked by a shift or a reduce (S/R and | | R/R conflicts). | `-------------------------------------------------------------------------*/ static void -print_reduction (FILE *out, int level, char const *lookahead_token, +print_reduction (FILE *out, int level, char const *lookahead, rule *r, bool enabled) { if (r->number) xml_printf (out, level, "", - xml_escape (lookahead_token), + xml_escape (lookahead), r->number, enabled ? "true" : "false"); else xml_printf (out, level, "", - xml_escape (lookahead_token), + xml_escape (lookahead), enabled ? "true" : "false"); } @@ -258,13 +258,13 @@ print_reductions (FILE *out, int level, state *s) if (default_reduction) report = true; - if (reds->lookahead_tokens) + if (reds->lookaheads) for (i = 0; i < ntokens; i++) { bool count = bitset_test (no_reduce_set, i); for (j = 0; j < reds->num; ++j) - if (bitset_test (reds->lookahead_tokens[j], i)) + if (bitset_test (reds->lookaheads[j], i)) { if (! count) { @@ -289,14 +289,14 @@ print_reductions (FILE *out, int level, state *s) xml_puts (out, level, ""); /* Report lookahead tokens (or $default) and reductions. */ - if (reds->lookahead_tokens) + if (reds->lookaheads) for (i = 0; i < ntokens; i++) { bool defaulted = false; bool count = bitset_test (no_reduce_set, i); for (j = 0; j < reds->num; ++j) - if (bitset_test (reds->lookahead_tokens[j], i)) + if (bitset_test (reds->lookaheads[j], i)) { if (! count) { diff --git a/src/print.c b/src/print.c index 257eef253..7aba21892 100644 --- a/src/print.c +++ b/src/print.c @@ -90,9 +90,9 @@ print_core (FILE *out, const state *s) previous_rule = r; /* Display the lookahead tokens? */ - if (report_flag & report_lookahead_tokens + if (report_flag & report_lookaheads && item_number_is_rule_number (*sp1)) - state_rule_lookahead_tokens_print (s, r, out); + state_rule_lookaheads_print (s, r, out); fputc ('\n', out); } } @@ -181,18 +181,18 @@ print_errs (FILE *out, const state *s) /*-------------------------------------------------------------------------. -| Report a reduction of RULE on LOOKAHEAD_TOKEN (which can be 'default'). | +| Report a reduction of RULE on LOOKAHEAD (which can be 'default'). | | If not ENABLED, the rule is masked by a shift or a reduce (S/R and | | R/R conflicts). | `-------------------------------------------------------------------------*/ static void print_reduction (FILE *out, size_t width, - const char *lookahead_token, + const char *lookahead, rule *r, bool enabled) { - fprintf (out, " %s", lookahead_token); - for (int j = width - mbswidth (lookahead_token, 0); j > 0; --j) + fprintf (out, " %s", lookahead); + for (int j = width - mbswidth (lookahead, 0); j > 0; --j) fputc (' ', out); if (!enabled) fputc ('[', out); @@ -239,13 +239,13 @@ print_reductions (FILE *out, const state *s) if (default_reduction) width = mbswidth (_("$default"), 0); - if (reds->lookahead_tokens) + if (reds->lookaheads) for (int i = 0; i < ntokens; i++) { bool count = bitset_test (no_reduce_set, i); for (int j = 0; j < reds->num; ++j) - if (bitset_test (reds->lookahead_tokens[j], i)) + if (bitset_test (reds->lookaheads[j], i)) { if (! count) { @@ -268,7 +268,7 @@ print_reductions (FILE *out, const state *s) bool default_reduction_only = true; /* Report lookahead tokens (or $default) and reductions. */ - if (reds->lookahead_tokens) + if (reds->lookaheads) for (int i = 0; i < ntokens; i++) { bool defaulted = false; @@ -277,7 +277,7 @@ print_reductions (FILE *out, const state *s) default_reduction_only = false; for (int j = 0; j < reds->num; ++j) - if (bitset_test (reds->lookahead_tokens[j], i)) + if (bitset_test (reds->lookaheads[j], i)) { if (! count) { diff --git a/src/state-item.c b/src/state-item.c index ed67ad973..d7d1ff8ab 100644 --- a/src/state-item.c +++ b/src/state-item.c @@ -150,7 +150,7 @@ init_state_items (void) ++rule_search_idx; if (rule_search_idx < red->num && r == red->rules[rule_search_idx]) { - bitsetv lookahead = red->lookahead_tokens; + bitsetv lookahead = red->lookaheads; if (lookahead) si->lookahead = lookahead[rule_search_idx]; } @@ -163,7 +163,7 @@ init_state_items (void) state_item_set (sidx, s, off); if (item_number_is_rule_number (ritem[off])) { - bitsetv lookahead = red->lookahead_tokens; + bitsetv lookahead = red->lookaheads; if (lookahead) state_items[sidx].lookahead = lookahead[rule_search_idx]; ++rule_search_idx; diff --git a/src/state.c b/src/state.c index bc45460d7..4a3d78aab 100644 --- a/src/state.c +++ b/src/state.c @@ -101,7 +101,7 @@ reductions_new (int num, rule **reds) size_t rules_size = num * sizeof *reds; reductions *res = xmalloc (offsetof (reductions, rules) + rules_size); res->num = num; - res->lookahead_tokens = NULL; + res->lookaheads = NULL; memcpy (res->rules, reds, rules_size); return res; } @@ -260,20 +260,20 @@ state_errs_set (state *s, int num, symbol **tokens) `--------------------------------------------------*/ void -state_rule_lookahead_tokens_print (state const *s, rule const *r, FILE *out) +state_rule_lookaheads_print (state const *s, rule const *r, FILE *out) { /* Find the reduction we are handling. */ reductions *reds = s->reductions; int red = state_reduction_find (s, r); /* Print them if there are. */ - if (reds->lookahead_tokens && red != -1) + if (reds->lookaheads && red != -1) { bitset_iterator biter; int k; char const *sep = ""; fprintf (out, " ["); - BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0) + BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0) { fprintf (out, "%s%s", sep, symbols[k]->tag); sep = ", "; @@ -283,7 +283,7 @@ state_rule_lookahead_tokens_print (state const *s, rule const *r, FILE *out) } void -state_rule_lookahead_tokens_print_xml (state const *s, rule const *r, +state_rule_lookaheads_print_xml (state const *s, rule const *r, FILE *out, int level) { /* Find the reduction we are handling. */ @@ -291,12 +291,12 @@ state_rule_lookahead_tokens_print_xml (state const *s, rule const *r, int red = state_reduction_find (s, r); /* Print them if there are. */ - if (reds->lookahead_tokens && red != -1) + if (reds->lookaheads && red != -1) { bitset_iterator biter; int k; xml_puts (out, level, ""); - BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0) + BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0) { xml_printf (out, level + 1, "%s", xml_escape (symbols[k]->tag)); diff --git a/src/state.h b/src/state.h index a274e611d..6a2fd1c38 100644 --- a/src/state.h +++ b/src/state.h @@ -62,7 +62,7 @@ Each reductions structure describes the possible reductions at the state whose number is in the number field. rules is an array of - num rules. lookahead_tokens is an array of bitsets, one per rule. + num rules. lookaheads is an array of bitsets, one per rule. Conflict resolution can decide that certain tokens in certain states should explicitly be errors (for implementing %nonassoc). @@ -187,7 +187,7 @@ errs *errs_new (int num, symbol **tokens); typedef struct { int num; - bitset *lookahead_tokens; + bitset *lookaheads; /* Sorted ascendingly on rule number. */ rule *rules[1]; } reductions; @@ -254,9 +254,9 @@ void state_errs_set (state *s, int num, symbol **errors); /* Print on OUT all the lookahead tokens such that this STATE wants to reduce R. */ -void state_rule_lookahead_tokens_print (state const *s, rule const *r, FILE *out); -void state_rule_lookahead_tokens_print_xml (state const *s, rule const *r, - FILE *out, int level); +void state_rule_lookaheads_print (state const *s, rule const *r, FILE *out); +void state_rule_lookaheads_print_xml (state const *s, rule const *r, + FILE *out, int level); /* Create/destroy the states hash table. */ void state_hash_new (void); diff --git a/src/tables.c b/src/tables.c index 883d81e56..052e96e6f 100644 --- a/src/tables.c +++ b/src/tables.c @@ -200,7 +200,7 @@ conflict_row (state *s) /* Find all reductions for token J, and record all that do not match ACTROW[J]. */ for (int i = 0; i < reds->num; i += 1) - if (bitset_test (reds->lookahead_tokens[i], j) + if (bitset_test (reds->lookaheads[i], j) && (actrow[j] != rule_number_as_item_number (reds->rules[i]->number))) { @@ -247,7 +247,7 @@ action_row (state *s) reductions *reds = s->reductions; bool conflicted = false; - if (reds->lookahead_tokens) + if (reds->lookaheads) /* loop over all the rules available here which require lookahead (in reverse order to give precedence to the first rule) */ @@ -257,7 +257,7 @@ action_row (state *s) { bitset_iterator biter; int j; - BITSET_FOR_EACH (biter, reds->lookahead_tokens[i], j, 0) + BITSET_FOR_EACH (biter, reds->lookaheads[i], j, 0) { /* and record this rule as the rule to use if that token follows. */ @@ -308,7 +308,7 @@ action_row (state *s) } /* Turn off default reductions where requested by the user. See - state_lookahead_tokens_count in lalr.c to understand when states are + state_lookaheads_count in lalr.c to understand when states are labeled as consistent. */ { char *default_reductions = diff --git a/tests/torture.at b/tests/torture.at index 3dbbed5ec..f41b8487b 100644 --- a/tests/torture.at +++ b/tests/torture.at @@ -283,11 +283,11 @@ m4_popdef([AT_TEST]) ## Many lookahead tokens. ## ## ------------------------ ## -# AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR(FILE-NAME, SIZE) -# -------------------------------------------------- +# AT_DATA_LOOKAHEADS_GRAMMAR(FILE-NAME, SIZE) +# ------------------------------------------- # Create FILE-NAME, containing a self checking parser for a grammar # requiring SIZE lookahead tokens. -m4_define([AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR], +m4_define([AT_DATA_LOOKAHEADS_GRAMMAR], [AT_BISON_OPTION_PUSHDEFS AT_DATA([[gengram.pl]], [[#! /usr/bin/perl -w @@ -384,7 +384,7 @@ AT_BISON_OPTION_POPDEFS AT_SETUP([Many lookahead tokens]) -AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR([input.y], [1000]) +AT_DATA_LOOKAHEADS_GRAMMAR([input.y], [1000]) # GNU m4 requires about 70 MiB for this test on a 32-bit host. # Ask for 200 MiB, which should be plenty even on a 64-bit host.