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

style: clean up nullable

Browse Source 
* src/nullable.c: Reduce scopes.
Prefer `r` to `rules_ruleno`, which is truly an ugly name.
This commit is contained in:
Akim Demaille
2020-06-25 19:19:42 +02:00
parent 3be228f64c
commit 1001f48416
1 changed files with 43 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/nullable.c
View File

@@ -36,7 +36,7 @@
typedef struct rule_list typedef struct rule_list
{ {
struct rule_list *next; struct rule_list *next;
rule *value; const rule *value;
} rule_list; } rule_list;
bool *nullable = NULL; bool *nullable = NULL;
@@ -44,9 +44,8 @@ bool *nullable = NULL;
static void static void
nullable_print (FILE *out) nullable_print (FILE *out)
{ {
int i;
fputs ("NULLABLE\n", out); fputs ("NULLABLE\n", out);
for (i = ntokens; i < nsyms; i++) for (int i = ntokens; i < nsyms; i++)
fprintf (out, " %s: %s\n", symbols[i]->tag, fprintf (out, " %s: %s\n", symbols[i]->tag,
nullable[i - ntokens] ? "yes" : "no"); nullable[i - ntokens] ? "yes" : "no");
fputs ("\n\n", out); fputs ("\n\n", out);
@@ -55,12 +54,8 @@ nullable_print (FILE *out)
void void
nullable_compute (void) nullable_compute (void)
{ {
rule_number ruleno; nullable = xcalloc (nvars, sizeof *nullable);
symbol_number *s1;
symbol_number *s2;
rule_list *p;
symbol_number *squeue = xnmalloc (nvars, sizeof *squeue);
size_t *rcount = xcalloc (nrules, sizeof *rcount); size_t *rcount = xcalloc (nrules, sizeof *rcount);
/* RITEM contains all the rules, including useless productions. /* RITEM contains all the rules, including useless productions.
Hence we must allocate room for useless nonterminals too. */ Hence we must allocate room for useless nonterminals too. */
@@ -69,32 +64,30 @@ nullable_compute (void)
Supposedly NRITEMS - NRULES is enough. But why take the risk? */ Supposedly NRITEMS - NRULES is enough. But why take the risk? */
rule_list *relts = xnmalloc (nritems + nvars + 1, sizeof *relts); rule_list *relts = xnmalloc (nritems + nvars + 1, sizeof *relts);
nullable = xcalloc (nvars, sizeof *nullable); symbol_number *squeue = xnmalloc (nvars, sizeof *squeue);
symbol_number *s2 = squeue;
s1 = s2 = squeue; {
p = relts; rule_list *p = relts;
for (rule_number ruleno = 0; ruleno < nrules; ++ruleno)
for (ruleno = 0; ruleno < nrules; ++ruleno)
if (rules[ruleno].useful) if (rules[ruleno].useful)
{ {
rule *rules_ruleno = &rules[ruleno]; const rule *r = &rules[ruleno];
if (rules_ruleno->rhs[0] >= 0) if (r->rhs[0] >= 0)
{ {
/* This rule has a non empty RHS. */ /* This rule has a non empty RHS. */
item_number *rp = NULL;
bool any_tokens = false; bool any_tokens = false;
for (rp = rules_ruleno->rhs; *rp >= 0; ++rp) for (item_number *rp = r->rhs; *rp >= 0; ++rp)
if (ISTOKEN (*rp)) if (ISTOKEN (*rp))
any_tokens = true; any_tokens = true;
/* This rule has only nonterminals: schedule it for the second /* This rule has only nonterminals: schedule it for the second
pass. */ pass. */
if (!any_tokens) if (!any_tokens)
for (rp = rules_ruleno->rhs; *rp >= 0; ++rp) for (item_number *rp = r->rhs; *rp >= 0; ++rp)
{ {
rcount[ruleno]++; rcount[ruleno]++;
p->next = rsets[*rp - ntokens]; p->next = rsets[*rp - ntokens];
p->value = rules_ruleno; p->value = r;
rsets[*rp - ntokens] = p; rsets[*rp - ntokens] = p;
p++; p++;
} }
@@ -102,21 +95,21 @@ nullable_compute (void)
else else
{ {
/* This rule has an empty RHS. */ /* This rule has an empty RHS. */
aver (item_number_as_rule_number (rules_ruleno->rhs[0]) if (r->useful
== ruleno); && ! nullable[r->lhs->number - ntokens])
if (rules_ruleno->useful
&& ! nullable[rules_ruleno->lhs->number - ntokens])
{ {
nullable[rules_ruleno->lhs->number - ntokens] = true; nullable[r->lhs->number - ntokens] = true;
*s2++ = rules_ruleno->lhs->number; *s2++ = r->lhs->number;
}
} }
} }
} }
symbol_number *s1 = squeue;
while (s1 < s2) while (s1 < s2)
for (p = rsets[*s1++ - ntokens]; p; p = p->next) for (rule_list *p = rsets[*s1++ - ntokens]; p; p = p->next)
{ {
rule *r = p->value; const rule *r = p->value;
if (--rcount[r->number] == 0) if (--rcount[r->number] == 0)
if (r->useful && ! nullable[r->lhs->number - ntokens]) if (r->useful && ! nullable[r->lhs->number - ntokens])
{ {