From a0b76449c7ebb01064f6e091715819f7519c90b2 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Wed, 11 Dec 2002 06:38:17 +0000 Subject: [PATCH] (struct rule_list): Renamed from struct rule_list_s. (rule_list): Renamed from rule_list_t. --- src/derives.c | 42 ++++++++++++++++++++----------------- src/nullable.c | 57 +++++++++++++++++++++++++------------------------- 2 files changed, 52 insertions(+), 47 deletions(-) diff --git a/src/derives.c b/src/derives.c index 74692975..10d3adbf 100644 --- a/src/derives.c +++ b/src/derives.c @@ -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) { diff --git a/src/nullable.c b/src/nullable.c index c4b9944d..1a96bef2 100644 --- a/src/nullable.c +++ b/src/nullable.c @@ -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; } } -- 2.45.2