From 8f44164443e8cc04f7931cd5fdb39a0cc48b39a4 Mon Sep 17 00:00:00 2001 From: Akim Demaille Date: Thu, 25 Jun 2020 18:35:27 +0200 Subject: [PATCH] style: factor the access to a rule from its items * src/counterexample.c (item_rule): Move to... * src/counterexample.h: here. * src/AnnotationList.c, src/counterexample.c, src/ielr.c: Use it. --- src/AnnotationList.c | 12 +++--------- src/counterexample.c | 4 ++-- src/gram.c | 11 ----------- src/gram.h | 10 +++++++++- src/ielr.c | 24 +++++------------------- 5 files changed, 19 insertions(+), 42 deletions(-) diff --git a/src/AnnotationList.c b/src/AnnotationList.c index fae1ac08..a95a67be 100644 --- a/src/AnnotationList.c +++ b/src/AnnotationList.c @@ -185,7 +185,7 @@ AnnotationList__compute_conflicted_tokens (bitset shift_tokens, } static bool -AnnotationList__compute_lhs_contributions (state *s, rule *the_rule, +AnnotationList__compute_lhs_contributions (state *s, const rule *the_rule, symbol_number conflicted_token, bitsetv follow_kernel_items, bitsetv always_follows, @@ -263,18 +263,12 @@ AnnotationList__computePredecessorAnnotations ( /* If this kernel item is next to the beginning of the RHS, then check all of the predecessor's goto follows for the LHS. */ - if (item_number_is_rule_number (ritem[s->items[self_item] - - 2])) + if (item_number_is_rule_number (ritem[s->items[self_item] - 2])) { - int rulei; - for (rulei = s->items[self_item]; - !item_number_is_rule_number (ritem[rulei]); - ++rulei) - continue; Sbitset items; if (AnnotationList__compute_lhs_contributions ( *predecessor, - &rules[item_number_as_rule_number (ritem[rulei])], + item_rule (&ritem[s->items[self_item]]), contribution_token, follow_kernel_items, always_follows, predecessors, item_lookahead_sets, &items, annotations_obstackp)) diff --git a/src/counterexample.c b/src/counterexample.c index a60456b5..7cc05796 100644 --- a/src/counterexample.c +++ b/src/counterexample.c @@ -364,7 +364,7 @@ complete_diverging_example (symbol_number conflict_sym, lookahead_required = false; } } - rule_number r = item_number_as_rule_number (*i); + const rule *r = &rules[item_number_as_rule_number (*i)]; // add derivations for symbols before dot for (i = item - 1; !item_number_is_rule_number (*i) && i >= ritem; i--) { @@ -381,7 +381,7 @@ complete_diverging_example (symbol_number conflict_sym, derivation_list_prepend (result, derivation_new_leaf (*i)); } // completing the derivation - derivation *new_deriv = derivation_new (rules[r].lhs->number, result); + derivation *new_deriv = derivation_new (r->lhs->number, result); result = derivation_list_new (); derivation_list_append (result, new_deriv); } diff --git a/src/gram.c b/src/gram.c index 125eb035..06113b78 100644 --- a/src/gram.c +++ b/src/gram.c @@ -48,17 +48,6 @@ int max_code = 256; int required_version = 0; -rule const * -item_rule (item_number const *item) -{ - item_number const *sp = item; - while (0 <= *sp) - ++sp; - rule_number r = item_number_as_rule_number (*sp); - return &rules[r]; -} - - void item_print (item_number *item, rule const *previous_rule, FILE *out) { diff --git a/src/gram.h b/src/gram.h index 02b2dd3e..356066f1 100644 --- a/src/gram.h +++ b/src/gram.h @@ -237,7 +237,15 @@ print_dot (FILE *out) } /* Get the rule associated to this item. ITEM points inside RITEM. */ -rule const *item_rule (item_number const *item); +static inline rule const * +item_rule (item_number const *item) +{ + item_number const *sp = item; + while (!item_number_is_rule_number (*sp)) + ++sp; + rule_number r = item_number_as_rule_number (*sp); + return &rules[r]; +} /* Pretty-print this ITEM (as in the report). ITEM points inside RITEM. PREVIOUS_RULE is used to see if the lhs is common, in which diff --git a/src/ielr.c b/src/ielr.c index 9fa4b787..89e37fe4 100644 --- a/src/ielr.c +++ b/src/ielr.c @@ -418,14 +418,7 @@ ielr_item_has_lookahead (state *s, symbol_number lhs, size_t item, /* If the LHS symbol of this item isn't known (because this is a top-level invocation), go get it. */ if (!lhs) - { - int i; - for (i = s->items[item]; - !item_number_is_rule_number (ritem[i]); - ++i) - continue; - lhs = rules[item_number_as_rule_number (ritem[i])].lhs->number; - } + lhs = item_rule (&ritem[s->items[item]])->lhs->number; /* If this kernel item is next to the beginning of the RHS, then check all predecessors' goto follows for the LHS. */ if (item_number_is_rule_number (ritem[s->items[item] - 2])) @@ -633,17 +626,10 @@ ielr_compute_lookaheads (bitsetv follow_kernel_items, bitsetv always_follows, && !bitset_empty_p (lookahead_filter[t_item])) { if (item_number_is_rule_number (ritem[t->items[t_item] - 2])) - { - int rule_item; - for (rule_item = t->items[t_item]; - !item_number_is_rule_number (ritem[rule_item]); - ++rule_item) - ; - ielr_compute_goto_follow_set ( - follow_kernel_items, always_follows, s, - rules[item_number_as_rule_number (ritem[rule_item])].lhs, - lookaheads[t_item]); - } + ielr_compute_goto_follow_set ( + follow_kernel_items, always_follows, s, + item_rule (&ritem[t->items[t_item]])->lhs, + lookaheads[t_item]); else if (s->lookaheads) { /* We don't have to start the s item search at the beginning