Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-17 00:03: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

93
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,54 +64,52 @@ 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;
{
rule_list *p = relts;
for (rule_number ruleno = 0; ruleno < nrules; ++ruleno)
if (rules[ruleno].useful)
{
const rule *r = &rules[ruleno];
if (r->rhs[0] >= 0)
{
/* This rule has a non empty RHS. */
bool any_tokens = false;
for (item_number *rp = r->rhs; *rp >= 0; ++rp)
if (ISTOKEN (*rp))
any_tokens = true;
s1 = s2 = squeue; /* This rule has only nonterminals: schedule it for the second
p = relts; pass. */
if (!any_tokens)
for (ruleno = 0; ruleno < nrules; ++ruleno) for (item_number *rp = r->rhs; *rp >= 0; ++rp)
if (rules[ruleno].useful) {
{ rcount[ruleno]++;
rule *rules_ruleno = &rules[ruleno]; p->next = rsets[*rp - ntokens];
if (rules_ruleno->rhs[0] >= 0) p->value = r;
{ rsets[*rp - ntokens] = p;
/* This rule has a non empty RHS. */ p++;
item_number *rp = NULL; }
bool any_tokens = false; }
for (rp = rules_ruleno->rhs; *rp >= 0; ++rp) else
if (ISTOKEN (*rp)) {
any_tokens = true; /* This rule has an empty RHS. */
if (r->useful
/* This rule has only nonterminals: schedule it for the second && ! nullable[r->lhs->number - ntokens])
pass. */
if (!any_tokens)
for (rp = rules_ruleno->rhs; *rp >= 0; ++rp)
{ {
rcount[ruleno]++; nullable[r->lhs->number - ntokens] = true;
p->next = rsets[*rp - ntokens]; *s2++ = r->lhs->number;
p->value = rules_ruleno;
rsets[*rp - ntokens] = p;
p++;
} }
} }
else }
{ }
/* This rule has an empty RHS. */
aver (item_number_as_rule_number (rules_ruleno->rhs[0])
== ruleno);
if (rules_ruleno->useful
&& ! nullable[rules_ruleno->lhs->number - ntokens])
{
nullable[rules_ruleno->lhs->number - ntokens] = true;
*s2++ = rules_ruleno->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])
{ {