Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-15 07:13:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

style: clean up src/AnnotationList.c

Browse Source 
* src/AnnotationList.c: Reduce scopes.
This commit is contained in:
Akim Demaille
2018-10-28 17:56:22 +01:00
parent 9912dd28ca
commit 96f503e197
1 changed files with 60 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
src/AnnotationList.c
View File

@@ -168,10 +168,9 @@ AnnotationList__compute_conflicted_tokens (bitset shift_tokens,
bitset conflicted_tokens = bitset_create (ntokens, BITSET_FIXED); bitset conflicted_tokens = bitset_create (ntokens, BITSET_FIXED);
bitset conflicted_tokens_rule = bitset_create (ntokens, BITSET_FIXED); bitset conflicted_tokens_rule = bitset_create (ntokens, BITSET_FIXED);
bitset tokens = bitset_create (ntokens, BITSET_FIXED); bitset tokens = bitset_create (ntokens, BITSET_FIXED);
int i;
bitset_copy (tokens, shift_tokens); bitset_copy (tokens, shift_tokens);
for (i = 0; i < reds->num; ++i) 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->lookahead_tokens[i]);
bitset_or (conflicted_tokens, bitset_or (conflicted_tokens,
@@ -215,20 +214,17 @@ AnnotationList__compute_lhs_contributions (state *s, rule *the_rule,
} }
static void static void
AnnotationList__computePredecessorAnnotations (AnnotationList *self, state *s, AnnotationList__computePredecessorAnnotations (
bitsetv follow_kernel_items, AnnotationList *self, state *s,
bitsetv always_follows, bitsetv follow_kernel_items,
state ***predecessors, bitsetv always_follows,
bitset **item_lookahead_sets, state ***predecessors,
AnnotationList bitset **item_lookahead_sets,
**annotation_lists, AnnotationList **annotation_lists,
AnnotationIndex AnnotationIndex *annotation_counts,
*annotation_counts, struct obstack *annotations_obstackp)
struct obstack
*annotations_obstackp)
{ {
state **predecessor; for (state **predecessor = predecessors[s->number]; *predecessor; ++predecessor)
for (predecessor = predecessors[s->number]; *predecessor; ++predecessor)
{ {
AnnotationList *annotation_node = AnnotationList *annotation_node =
AnnotationList__alloc_on_obstack ( AnnotationList__alloc_on_obstack (
@@ -237,8 +233,7 @@ AnnotationList__computePredecessorAnnotations (AnnotationList *self, state *s,
bool potential_contribution = false; bool potential_contribution = false;
bitset *lookaheads = NULL; bitset *lookaheads = NULL;
{ {
ContributionIndex ci; for (ContributionIndex ci = 0; ci < self->inadequacyNode->contributionCount; ++ci)
for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci)
{ {
symbol_number contribution_token = symbol_number contribution_token =
InadequacyList__getContributionToken (self->inadequacyNode, ci) InadequacyList__getContributionToken (self->inadequacyNode, ci)
@@ -274,12 +269,12 @@ AnnotationList__computePredecessorAnnotations (AnnotationList *self, state *s,
if (item_number_is_rule_number (ritem[s->items[self_item] if (item_number_is_rule_number (ritem[s->items[self_item]
- 2])) - 2]))
{ {
Sbitset items;
unsigned rulei; unsigned rulei;
for (rulei = s->items[self_item]; for (rulei = s->items[self_item];
!item_number_is_rule_number (ritem[rulei]); !item_number_is_rule_number (ritem[rulei]);
++rulei) ++rulei)
; continue;
Sbitset items;
if (AnnotationList__compute_lhs_contributions ( if (AnnotationList__compute_lhs_contributions (
*predecessor, *predecessor,
&rules[item_number_as_rule_number (ritem[rulei])], &rules[item_number_as_rule_number (ritem[rulei])],
@@ -334,10 +329,9 @@ AnnotationList__computePredecessorAnnotations (AnnotationList *self, state *s,
potential_contribution = true; potential_contribution = true;
if (!lookaheads) if (!lookaheads)
{ {
size_t j;
lookaheads = xnmalloc ((*predecessor)->nitems, lookaheads = xnmalloc ((*predecessor)->nitems,
sizeof *lookaheads); sizeof *lookaheads);
for (j = 0; j < (*predecessor)->nitems; ++j) for (size_t j = 0; j < (*predecessor)->nitems; ++j)
lookaheads[j] = NULL; lookaheads[j] = NULL;
} }
if (!lookaheads[i]) if (!lookaheads[i])
@@ -377,8 +371,7 @@ AnnotationList__computePredecessorAnnotations (AnnotationList *self, state *s,
annotation_node = NULL; annotation_node = NULL;
} }
{ {
size_t i; for (size_t i = 0; i < (*predecessor)->nitems; ++i)
for (i = 0; i < (*predecessor)->nitems; ++i)
if (lookaheads[i]) if (lookaheads[i])
bitset_free (lookaheads[i]); bitset_free (lookaheads[i]);
free (lookaheads); free (lookaheads);
@@ -416,23 +409,19 @@ AnnotationList__compute_from_inadequacies (
struct obstack *annotations_obstackp, struct obstack *annotations_obstackp,
InadequacyListNodeCount *inadequacy_list_node_count) InadequacyListNodeCount *inadequacy_list_node_count)
{ {
bitsetv all_lookaheads;
bitset shift_tokens;
bitset conflicted_tokens;
bitset_iterator biter_conflict;
bitset_bindex conflicted_token;
/* Return an empty list if s->lookahead_tokens = NULL. */ /* Return an empty list if s->lookahead_tokens = NULL. */
if (s->consistent) if (s->consistent)
return; return;
all_lookaheads = bitsetv_create (s->nitems, ntokens, BITSET_FIXED); bitsetv all_lookaheads = bitsetv_create (s->nitems, ntokens, BITSET_FIXED);
bitsetv_ones (all_lookaheads); bitsetv_ones (all_lookaheads);
shift_tokens = AnnotationList__compute_shift_tokens (s->transitions); bitset shift_tokens = AnnotationList__compute_shift_tokens (s->transitions);
conflicted_tokens = bitset conflicted_tokens =
AnnotationList__compute_conflicted_tokens (shift_tokens, s->reductions); AnnotationList__compute_conflicted_tokens (shift_tokens, s->reductions);
/* Add an inadequacy annotation for each conflicted_token. */ /* Add an inadequacy annotation for each conflicted_token. */
bitset_iterator biter_conflict;
bitset_bindex conflicted_token;
BITSET_FOR_EACH (biter_conflict, conflicted_tokens, conflicted_token, 0) BITSET_FOR_EACH (biter_conflict, conflicted_tokens, conflicted_token, 0)
{ {
AnnotationList *annotation_node; AnnotationList *annotation_node;
@@ -444,8 +433,7 @@ AnnotationList__compute_from_inadequacies (
/* Allocate the annotation node. */ /* Allocate the annotation node. */
{ {
int rule_i; for (int rule_i = 0; rule_i < s->reductions->num; ++rule_i)
for (rule_i = 0; rule_i < s->reductions->num; ++rule_i)
if (bitset_test (s->reductions->lookahead_tokens[rule_i], if (bitset_test (s->reductions->lookahead_tokens[rule_i],
conflicted_token)) conflicted_token))
++contribution_count; ++contribution_count;
@@ -461,8 +449,7 @@ AnnotationList__compute_from_inadequacies (
{ {
ContributionIndex ci = 0; ContributionIndex ci = 0;
int item_i = 0; int item_i = 0;
int rule_i; for (int rule_i = 0; rule_i < s->reductions->num; ++rule_i)
for (rule_i = 0; rule_i < s->reductions->num; ++rule_i)
{ {
rule *the_rule = s->reductions->rules[rule_i]; rule *the_rule = s->reductions->rules[rule_i];
if (bitset_test (s->reductions->lookahead_tokens[rule_i], if (bitset_test (s->reductions->lookahead_tokens[rule_i],
@@ -584,27 +571,20 @@ AnnotationList__debug (AnnotationList const *self, size_t nitems, int spaces)
AnnotationIndex ai; AnnotationIndex ai;
for (a = self, ai = 0; a; a = a->next, ++ai) for (a = self, ai = 0; a; a = a->next, ++ai)
{ {
{ for (int j = 0; j < spaces; ++j)
int j; putc (' ', stderr);
for (j = 0; j < spaces; ++j)
putc (' ', stderr);
}
fprintf (stderr, "Annotation %d (manifesting state %d):\n", fprintf (stderr, "Annotation %d (manifesting state %d):\n",
ai, a->inadequacyNode->manifestingState->number); ai, a->inadequacyNode->manifestingState->number);
{ {
ContributionIndex ci; bitset_bindex rulei
bitset_bindex rulei = 0; /* init suppresses compiler warning */ = bitset_first (a->inadequacyNode->inadequacy.conflict.actions);
rulei = bitset_first (a->inadequacyNode->inadequacy.conflict.actions); for (ContributionIndex ci = 0; ci < a->inadequacyNode->contributionCount; ++ci)
for (ci = 0; ci < a->inadequacyNode->contributionCount; ++ci)
{ {
symbol_number token = symbol_number token =
InadequacyList__getContributionToken (a->inadequacyNode, ci) InadequacyList__getContributionToken (a->inadequacyNode, ci)
->content->number; ->content->number;
{ for (int j = 0; j < spaces+2; ++j)
int j; putc (' ', stderr);
for (j = 0; j < spaces+2; ++j)
putc (' ', stderr);
}
if (ci == InadequacyList__getShiftContributionIndex ( if (ci == InadequacyList__getShiftContributionIndex (
a->inadequacyNode)) a->inadequacyNode))
fprintf (stderr, "Contributes shift of token %d.\n", token); fprintf (stderr, "Contributes shift of token %d.\n", token);
@@ -639,20 +619,17 @@ AnnotationList__computeLookaheadFilter (AnnotationList const *self,
{ {
bitsetv_zero (lookahead_filter); bitsetv_zero (lookahead_filter);
for (; self; self = self->next) for (; self; self = self->next)
{ for (ContributionIndex ci = 0; ci < self->inadequacyNode->contributionCount; ++ci)
ContributionIndex ci; if (!AnnotationList__isContributionAlways (self, ci))
for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci) {
if (!AnnotationList__isContributionAlways (self, ci)) symbol_number token =
{ InadequacyList__getContributionToken (self->inadequacyNode, ci)
Sbitset__Index item; ->content->number;
Sbitset biter; Sbitset__Index item;
symbol_number token = Sbitset biter;
InadequacyList__getContributionToken (self->inadequacyNode, ci) SBITSET__FOR_EACH (self->contributions[ci], nitems, biter, item)
->content->number; bitset_set (lookahead_filter[item], token);
SBITSET__FOR_EACH (self->contributions[ci], nitems, biter, item) }
bitset_set (lookahead_filter[item], token);
}
}
} }
/** /**
@@ -699,11 +676,10 @@ AnnotationList__computeDominantContribution (AnnotationList const *self,
size_t nitems, bitset *lookaheads, size_t nitems, bitset *lookaheads,
bool require_split_stable) bool require_split_stable)
{ {
symbol *token;
ContributionIndex const ci_shift = ContributionIndex const ci_shift =
InadequacyList__getShiftContributionIndex (self->inadequacyNode); InadequacyList__getShiftContributionIndex (self->inadequacyNode);
token = self->inadequacyNode->inadequacy.conflict.token; symbol *token = self->inadequacyNode->inadequacy.conflict.token;
/* S/R conflict. */ /* S/R conflict. */
if (ci_shift != ContributionIndex__none) if (ci_shift != ContributionIndex__none)
@@ -711,9 +687,6 @@ AnnotationList__computeDominantContribution (AnnotationList const *self,
bool find_stable_domination_over_shift = false; bool find_stable_domination_over_shift = false;
bool find_stable_error_action_domination = false; bool find_stable_error_action_domination = false;
{ {
ContributionIndex ci;
int actioni;
ContributionIndex ci_rr_dominator = ContributionIndex__none;
int shift_precedence = token->content->prec; int shift_precedence = token->content->prec;
/* If the token has no precedence set, shift is always chosen. */ /* If the token has no precedence set, shift is always chosen. */
@@ -723,11 +696,16 @@ AnnotationList__computeDominantContribution (AnnotationList const *self,
/* Figure out which reductions contribute, which of those would /* Figure out which reductions contribute, which of those would
dominate in a R/R comparison, and whether any reduction dominates dominate in a R/R comparison, and whether any reduction dominates
the shift so that the R/R comparison is actually needed. */ the shift so that the R/R comparison is actually needed. */
for (ci = 0, actioni = bitset_first (self->inadequacyNode->inadequacy ContributionIndex ci_rr_dominator = ContributionIndex__none;
.conflict.actions); int actioni;
ContributionIndex ci;
for (ci = 0,
actioni = bitset_first (self->inadequacyNode->inadequacy
.conflict.actions);
ci < self->inadequacyNode->contributionCount; ci < self->inadequacyNode->contributionCount;
++ci, actioni = bitset_next (self->inadequacyNode->inadequacy ++ci,
.conflict.actions, actioni+1)) actioni = bitset_next (self->inadequacyNode->inadequacy
.conflict.actions, actioni+1))
{ {
int reduce_precedence = 0; int reduce_precedence = 0;
if (ci == ci_shift) if (ci == ci_shift)
@@ -796,17 +774,14 @@ AnnotationList__computeDominantContribution (AnnotationList const *self,
/* R/R conflict, so the reduction with the lowest rule number dominates. /* R/R conflict, so the reduction with the lowest rule number dominates.
Fortunately, contributions are sorted by rule number. */ Fortunately, contributions are sorted by rule number. */
{ for (ContributionIndex ci = 0; ci < self->inadequacyNode->contributionCount; ++ci)
ContributionIndex ci; if (AnnotationList__stateMakesContribution (self, nitems, ci,
for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci) lookaheads))
if (AnnotationList__stateMakesContribution (self, nitems, ci, {
lookaheads)) if (require_split_stable
{ && !AnnotationList__isContributionAlways (self, ci))
if (require_split_stable return ContributionIndex__none;
&& !AnnotationList__isContributionAlways (self, ci)) return ci;
return ContributionIndex__none; }
return ci;
}
}
return ContributionIndex__none; return ContributionIndex__none;
} }