[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
style: clean up src/AnnotationList.c
From: |
Akim Demaille |
Subject: |
style: clean up src/AnnotationList.c |
Date: |
Sun, 28 Oct 2018 20:40:18 +0100 |
commit 96f503e19748bf9abea1eb6d00a350a00f923985
Author: Akim Demaille <address@hidden>
Date: Sun Oct 28 17:56:22 2018 +0100
style: clean up src/AnnotationList.c
* src/AnnotationList.c: Reduce scopes.
diff --git a/src/AnnotationList.c b/src/AnnotationList.c
index a78deb8a..34b92310 100644
--- a/src/AnnotationList.c
+++ b/src/AnnotationList.c
@@ -168,10 +168,9 @@ AnnotationList__compute_conflicted_tokens (bitset
shift_tokens,
bitset conflicted_tokens = bitset_create (ntokens, BITSET_FIXED);
bitset conflicted_tokens_rule = bitset_create (ntokens, BITSET_FIXED);
bitset tokens = bitset_create (ntokens, BITSET_FIXED);
- int i;
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_or (conflicted_tokens,
@@ -215,20 +214,17 @@ AnnotationList__compute_lhs_contributions (state *s, rule
*the_rule,
}
static void
-AnnotationList__computePredecessorAnnotations (AnnotationList *self, state *s,
- bitsetv follow_kernel_items,
- bitsetv always_follows,
- state ***predecessors,
- bitset **item_lookahead_sets,
- AnnotationList
- **annotation_lists,
- AnnotationIndex
- *annotation_counts,
- struct obstack
- *annotations_obstackp)
+AnnotationList__computePredecessorAnnotations (
+ AnnotationList *self, state *s,
+ bitsetv follow_kernel_items,
+ bitsetv always_follows,
+ state ***predecessors,
+ bitset **item_lookahead_sets,
+ AnnotationList **annotation_lists,
+ AnnotationIndex *annotation_counts,
+ struct obstack *annotations_obstackp)
{
- state **predecessor;
- for (predecessor = predecessors[s->number]; *predecessor; ++predecessor)
+ for (state **predecessor = predecessors[s->number]; *predecessor;
++predecessor)
{
AnnotationList *annotation_node =
AnnotationList__alloc_on_obstack (
@@ -237,8 +233,7 @@ AnnotationList__computePredecessorAnnotations
(AnnotationList *self, state *s,
bool potential_contribution = false;
bitset *lookaheads = NULL;
{
- ContributionIndex ci;
- for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci)
+ for (ContributionIndex ci = 0; ci <
self->inadequacyNode->contributionCount; ++ci)
{
symbol_number contribution_token =
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]
- 2]))
{
- Sbitset items;
unsigned 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])],
@@ -334,10 +329,9 @@ AnnotationList__computePredecessorAnnotations
(AnnotationList *self, state *s,
potential_contribution = true;
if (!lookaheads)
{
- size_t j;
lookaheads = xnmalloc ((*predecessor)->nitems,
sizeof *lookaheads);
- for (j = 0; j < (*predecessor)->nitems; ++j)
+ for (size_t j = 0; j < (*predecessor)->nitems; ++j)
lookaheads[j] = NULL;
}
if (!lookaheads[i])
@@ -377,8 +371,7 @@ AnnotationList__computePredecessorAnnotations
(AnnotationList *self, state *s,
annotation_node = NULL;
}
{
- size_t i;
- for (i = 0; i < (*predecessor)->nitems; ++i)
+ for (size_t i = 0; i < (*predecessor)->nitems; ++i)
if (lookaheads[i])
bitset_free (lookaheads[i]);
free (lookaheads);
@@ -416,23 +409,19 @@ AnnotationList__compute_from_inadequacies (
struct obstack *annotations_obstackp,
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. */
if (s->consistent)
return;
- all_lookaheads = bitsetv_create (s->nitems, ntokens, BITSET_FIXED);
+ bitsetv all_lookaheads = bitsetv_create (s->nitems, ntokens, BITSET_FIXED);
bitsetv_ones (all_lookaheads);
- shift_tokens = AnnotationList__compute_shift_tokens (s->transitions);
- conflicted_tokens =
+ bitset shift_tokens = AnnotationList__compute_shift_tokens (s->transitions);
+ bitset conflicted_tokens =
AnnotationList__compute_conflicted_tokens (shift_tokens, s->reductions);
/* 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)
{
AnnotationList *annotation_node;
@@ -444,8 +433,7 @@ AnnotationList__compute_from_inadequacies (
/* Allocate the annotation node. */
{
- int rule_i;
- for (rule_i = 0; rule_i < s->reductions->num; ++rule_i)
+ for (int rule_i = 0; rule_i < s->reductions->num; ++rule_i)
if (bitset_test (s->reductions->lookahead_tokens[rule_i],
conflicted_token))
++contribution_count;
@@ -461,8 +449,7 @@ AnnotationList__compute_from_inadequacies (
{
ContributionIndex ci = 0;
int item_i = 0;
- int rule_i;
- for (rule_i = 0; rule_i < s->reductions->num; ++rule_i)
+ 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],
@@ -584,27 +571,20 @@ AnnotationList__debug (AnnotationList const *self, size_t
nitems, int spaces)
AnnotationIndex ai;
for (a = self, ai = 0; a; a = a->next, ++ai)
{
- {
- int j;
- for (j = 0; j < spaces; ++j)
- putc (' ', stderr);
- }
+ for (int j = 0; j < spaces; ++j)
+ putc (' ', stderr);
fprintf (stderr, "Annotation %d (manifesting state %d):\n",
ai, a->inadequacyNode->manifestingState->number);
{
- ContributionIndex ci;
- bitset_bindex rulei = 0; /* init suppresses compiler warning */
- rulei = bitset_first (a->inadequacyNode->inadequacy.conflict.actions);
- for (ci = 0; ci < a->inadequacyNode->contributionCount; ++ci)
+ bitset_bindex rulei
+ = bitset_first (a->inadequacyNode->inadequacy.conflict.actions);
+ for (ContributionIndex ci = 0; ci <
a->inadequacyNode->contributionCount; ++ci)
{
symbol_number token =
InadequacyList__getContributionToken (a->inadequacyNode, ci)
->content->number;
- {
- int j;
- for (j = 0; j < spaces+2; ++j)
- putc (' ', stderr);
- }
+ for (int j = 0; j < spaces+2; ++j)
+ putc (' ', stderr);
if (ci == InadequacyList__getShiftContributionIndex (
a->inadequacyNode))
fprintf (stderr, "Contributes shift of token %d.\n", token);
@@ -639,20 +619,17 @@ AnnotationList__computeLookaheadFilter (AnnotationList
const *self,
{
bitsetv_zero (lookahead_filter);
for (; self; self = self->next)
- {
- ContributionIndex ci;
- for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci)
- if (!AnnotationList__isContributionAlways (self, ci))
- {
- Sbitset__Index item;
- Sbitset biter;
- symbol_number token =
- InadequacyList__getContributionToken (self->inadequacyNode, ci)
- ->content->number;
- SBITSET__FOR_EACH (self->contributions[ci], nitems, biter, item)
- bitset_set (lookahead_filter[item], token);
- }
- }
+ for (ContributionIndex ci = 0; ci <
self->inadequacyNode->contributionCount; ++ci)
+ if (!AnnotationList__isContributionAlways (self, ci))
+ {
+ symbol_number token =
+ InadequacyList__getContributionToken (self->inadequacyNode, ci)
+ ->content->number;
+ Sbitset__Index item;
+ Sbitset biter;
+ 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,
bool require_split_stable)
{
- symbol *token;
ContributionIndex const ci_shift =
InadequacyList__getShiftContributionIndex (self->inadequacyNode);
- token = self->inadequacyNode->inadequacy.conflict.token;
+ symbol *token = self->inadequacyNode->inadequacy.conflict.token;
/* S/R conflict. */
if (ci_shift != ContributionIndex__none)
@@ -711,9 +687,6 @@ AnnotationList__computeDominantContribution (AnnotationList
const *self,
bool find_stable_domination_over_shift = false;
bool find_stable_error_action_domination = false;
{
- ContributionIndex ci;
- int actioni;
- ContributionIndex ci_rr_dominator = ContributionIndex__none;
int shift_precedence = token->content->prec;
/* 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
dominate in a R/R comparison, and whether any reduction dominates
the shift so that the R/R comparison is actually needed. */
- for (ci = 0, actioni = bitset_first (self->inadequacyNode->inadequacy
- .conflict.actions);
+ ContributionIndex ci_rr_dominator = ContributionIndex__none;
+ int actioni;
+ ContributionIndex ci;
+ for (ci = 0,
+ actioni = bitset_first (self->inadequacyNode->inadequacy
+ .conflict.actions);
ci < self->inadequacyNode->contributionCount;
- ++ci, actioni = bitset_next (self->inadequacyNode->inadequacy
- .conflict.actions, actioni+1))
+ ++ci,
+ actioni = bitset_next (self->inadequacyNode->inadequacy
+ .conflict.actions, actioni+1))
{
int reduce_precedence = 0;
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.
Fortunately, contributions are sorted by rule number. */
- {
- ContributionIndex ci;
- for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci)
- if (AnnotationList__stateMakesContribution (self, nitems, ci,
- lookaheads))
- {
- if (require_split_stable
- && !AnnotationList__isContributionAlways (self, ci))
- return ContributionIndex__none;
- return ci;
- }
- }
+ for (ContributionIndex ci = 0; ci < self->inadequacyNode->contributionCount;
++ci)
+ if (AnnotationList__stateMakesContribution (self, nitems, ci,
+ lookaheads))
+ {
+ if (require_split_stable
+ && !AnnotationList__isContributionAlways (self, ci))
+ return ContributionIndex__none;
+ return ci;
+ }
return ContributionIndex__none;
}
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- style: clean up src/AnnotationList.c,
Akim Demaille <=