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

(struct rule_list): Renamed from struct rule_list_s.

Browse Source 
(rule_list): Renamed from rule_list_t.
This commit is contained in:
Paul Eggert
2002-12-11 06:38:17 +00:00
parent 2b5ff972bf
commit a0b76449c7
2 changed files with 52 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/derives.c
View File

@@ -1,5 +1,7 @@
/* Match rules with nonterminals for bison,
Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc.
Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software
Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
@@ -20,20 +22,22 @@
#include "system.h"
#include "getargs.h"
#include "symtab.h"
#include "reader.h"
#include "gram.h"
#include "derives.h"
#include "gram.h"
#include "reader.h"
#include "symtab.h"
/* Linked list of rule numbers. */
typedef struct rule_list_s
typedef struct rule_list
{
struct rule_list_s *next;
rule_t *value;
} rule_list_t;
struct rule_list *next;
rule *value;
} rule_list;
rule_t ***derives = NULL;
rule ***derives = NULL;
static void
print_derives (void)
@@ -44,7 +48,7 @@ print_derives (void)
for (i = ntokens; i < nsyms; i++)
{
rule_t **rp;
rule **rp;
fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
for (rp = derives[i]; *rp; ++rp)
{
@@ -60,23 +64,23 @@ print_derives (void)
void
derives_compute (void)
{
symbol_number_t i;
symbol_number i;
int r;
rule_t **q;
rule **q;
/* DSET[NTERM] -- A linked list of the numbers of the rules whose
LHS is NTERM. */
rule_list_t **dset = XCALLOC (rule_list_t *, nvars) - ntokens;
rule_list **dset = XCALLOC (rule_list *, nvars) - ntokens;
/* DELTS[RULE] -- There are NRULES rule number to attach to nterms.
Instead of performing NRULES allocations for each, have an array
indexed by rule numbers. */
rule_list_t *delts = XCALLOC (rule_list_t, nrules);
rule_list *delts = XCALLOC (rule_list, nrules);
for (r = nrules - 1; r >= 0; --r)
{
symbol_number_t lhs = rules[r].lhs->number;
rule_list_t *p = &delts[r];
symbol_number lhs = rules[r].lhs->number;
rule_list *p = &delts[r];
/* A new LHS is found. */
p->next = dset[lhs];
p->value = &rules[r];
@@ -86,12 +90,12 @@ derives_compute (void)
/* DSET contains what we need under the form of a linked list. Make
it a single array. */
derives = XCALLOC (rule_t **, nvars) - ntokens;
q = XCALLOC (rule_t *, nvars + int_of_rule_number (nrules));
derives = XCALLOC (rule **, nvars) - ntokens;
q = XCALLOC (rule *, nvars + int_of_rule_number (nrules));
for (i = ntokens; i < nsyms; i++)
{
rule_list_t *p = dset[i];
rule_list *p = dset[i];
derives[i] = q;
while (p)
{

57
src/nullable.c
View File

@@ -24,18 +24,19 @@
do so. */
#include "system.h"
#include "getargs.h"
#include "symtab.h"
#include "gram.h"
#include "reduce.h"
#include "nullable.h"
#include "reduce.h"
#include "symtab.h"
/* Linked list of rules. */
typedef struct rule_list_s
typedef struct rule_list
{
struct rule_list_s *next;
rule_t *value;
} rule_list_t;
struct rule_list *next;
rule *value;
} rule_list;
bool *nullable = NULL;
@@ -52,19 +53,19 @@ nullable_print (FILE *out)
void
nullable_compute (void)
{
rule_number_t ruleno;
symbol_number_t *s1;
symbol_number_t *s2;
rule_list_t *p;
rule_number ruleno;
symbol_number *s1;
symbol_number *s2;
rule_list *p;
symbol_number_t *squeue = XCALLOC (symbol_number_t, nvars);
symbol_number *squeue = XCALLOC (symbol_number, nvars);
short *rcount = XCALLOC (short, nrules);
/* RITEM contains all the rules, including useless productions.
Hence we must allocate room for useless nonterminals too. */
rule_list_t **rsets = XCALLOC (rule_list_t *, nvars) - ntokens;
rule_list **rsets = XCALLOC (rule_list *, nvars) - ntokens;
/* This is said to be more elements than we actually use.
Supposedly NRITEMS - NRULES is enough. But why take the risk? */
rule_list_t *relts = XCALLOC (rule_list_t, nritems + nvars + 1);
rule_list *relts = XCALLOC (rule_list, nritems + nvars + 1);
nullable = XCALLOC (bool, nvars) - ntokens;
@@ -74,24 +75,24 @@ nullable_compute (void)
for (ruleno = 0; ruleno < nrules; ++ruleno)
if (rules[ruleno].useful)
{
rule_t *rule = &rules[ruleno];
if (rule->rhs[0] >= 0)
rule *rules_ruleno = &rules[ruleno];
if (rules_ruleno->rhs[0] >= 0)
{
/* This rule has a non empty RHS. */
item_number_t *r = NULL;
item_number *r = NULL;
int any_tokens = 0;
for (r = rule->rhs; *r >= 0; ++r)
for (r = rules_ruleno->rhs; *r >= 0; ++r)
if (ISTOKEN (*r))
any_tokens = 1;
/* This rule has only nonterminals: schedule it for the second
pass. */
if (!any_tokens)
for (r = rule->rhs; *r >= 0; ++r)
for (r = rules_ruleno->rhs; *r >= 0; ++r)
{
rcount[ruleno]++;
p->next = rsets[*r];
p->value = rule;
p->value = rules_ruleno;
rsets[*r] = p;
p++;
}
@@ -99,12 +100,12 @@ nullable_compute (void)
else
{
/* This rule has an empty RHS. */
if (item_number_as_rule_number (rule->rhs[0]) != ruleno)
if (item_number_as_rule_number (rules_ruleno->rhs[0]) != ruleno)
abort ();
if (rule->useful && !nullable[rule->lhs->number])
if (rules_ruleno->useful && !nullable[rules_ruleno->lhs->number])
{
nullable[rule->lhs->number] = 1;
*s2++ = rule->lhs->number;
nullable[rules_ruleno->lhs->number] = 1;
*s2++ = rules_ruleno->lhs->number;
}
}
}
@@ -112,12 +113,12 @@ nullable_compute (void)
while (s1 < s2)
for (p = rsets[*s1++]; p; p = p->next)
{
rule_t *rule = p->value;
if (--rcount[rule->number] == 0)
if (rule->useful && !nullable[rule->lhs->number])
rule *r = p->value;
if (--rcount[r->number] == 0)
if (r->useful && !nullable[r->lhs->number])
{
nullable[rule->lhs->number] = 1;
*s2++ = rule->lhs->number;
nullable[r->lhs->number] = 1;
*s2++ = r->lhs->number;
}
}