1 |
/* Subroutines for bison |
/* Closures for Bison |
2 |
|
|
3 |
Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc. |
Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc. |
4 |
|
|
5 |
This file is part of Bison, the GNU Compiler Compiler. |
This file is part of Bison, the GNU Compiler Compiler. |
20 |
02111-1307, USA. */ |
02111-1307, USA. */ |
21 |
|
|
22 |
#include "system.h" |
#include "system.h" |
23 |
#include "quotearg.h" |
|
24 |
#include "bitset.h" |
#include <bitset.h> |
25 |
#include "bitsetv.h" |
#include <bitsetv-print.h> |
26 |
#include "bitsetv-print.h" |
#include <bitsetv.h> |
27 |
|
#include <quotearg.h> |
28 |
|
|
29 |
|
#include "closure.h" |
30 |
|
#include "derives.h" |
31 |
#include "getargs.h" |
#include "getargs.h" |
|
#include "symtab.h" |
|
32 |
#include "gram.h" |
#include "gram.h" |
33 |
#include "reader.h" |
#include "reader.h" |
34 |
#include "closure.h" |
#include "symtab.h" |
|
#include "derives.h" |
|
35 |
|
|
36 |
/* NITEMSET is the size of the array ITEMSET. */ |
/* NITEMSET is the size of the array ITEMSET. */ |
37 |
item_number_t *itemset; |
item_number *itemset; |
38 |
int nritemset; |
int nritemset; |
39 |
|
|
40 |
static bitset ruleset; |
static bitset ruleset; |
53 |
`-----------------*/ |
`-----------------*/ |
54 |
|
|
55 |
static void |
static void |
56 |
print_closure (const char *title, item_number_t *array, size_t size) |
print_closure (char const *title, item_number *array, size_t size) |
57 |
{ |
{ |
58 |
size_t i; |
size_t i; |
59 |
fprintf (stderr, "Closure: %s\n", title); |
fprintf (stderr, "Closure: %s\n", title); |
60 |
for (i = 0; i < size; ++i) |
for (i = 0; i < size; ++i) |
61 |
{ |
{ |
62 |
item_number_t *rp; |
item_number *rp; |
63 |
fprintf (stderr, " %2d: .", array[i]); |
fprintf (stderr, " %2d: .", array[i]); |
64 |
for (rp = &ritem[array[i]]; *rp >= 0; ++rp) |
for (rp = &ritem[array[i]]; *rp >= 0; ++rp) |
65 |
fprintf (stderr, " %s", symbols[*rp]->tag); |
fprintf (stderr, " %s", symbols[*rp]->tag); |
72 |
static void |
static void |
73 |
print_firsts (void) |
print_firsts (void) |
74 |
{ |
{ |
75 |
symbol_number_t i, j; |
symbol_number i, j; |
76 |
|
|
77 |
fprintf (stderr, "FIRSTS\n"); |
fprintf (stderr, "FIRSTS\n"); |
78 |
for (i = ntokens; i < nsyms; i++) |
for (i = ntokens; i < nsyms; i++) |
93 |
print_fderives (void) |
print_fderives (void) |
94 |
{ |
{ |
95 |
int i; |
int i; |
96 |
rule_number_t r; |
rule_number r; |
97 |
|
|
98 |
fprintf (stderr, "FDERIVES\n"); |
fprintf (stderr, "FDERIVES\n"); |
99 |
for (i = ntokens; i < nsyms; i++) |
for (i = ntokens; i < nsyms; i++) |
123 |
static void |
static void |
124 |
set_firsts (void) |
set_firsts (void) |
125 |
{ |
{ |
126 |
symbol_number_t i, j; |
symbol_number i, j; |
127 |
|
|
128 |
firsts = bitsetv_create (nvars, nvars, BITSET_FIXED); |
firsts = bitsetv_create (nvars, nvars, BITSET_FIXED); |
129 |
|
|
130 |
for (i = ntokens; i < nsyms; i++) |
for (i = ntokens; i < nsyms; i++) |
131 |
for (j = 0; derives[i][j]; ++j) |
for (j = 0; derives[i][j]; ++j) |
132 |
{ |
{ |
133 |
int symbol = derives[i][j]->rhs[0]; |
item_number sym = derives[i][j]->rhs[0]; |
134 |
if (ISVAR (symbol)) |
if (ISVAR (sym)) |
135 |
bitset_set (FIRSTS (i), symbol - ntokens); |
bitset_set (FIRSTS (i), sym - ntokens); |
136 |
} |
} |
137 |
|
|
138 |
if (trace_flag & trace_sets) |
if (trace_flag & trace_sets) |
158 |
static void |
static void |
159 |
set_fderives (void) |
set_fderives (void) |
160 |
{ |
{ |
161 |
symbol_number_t i, j; |
symbol_number i, j; |
162 |
rule_number_t k; |
rule_number k; |
163 |
|
|
164 |
fderives = bitsetv_create (nvars, nrules, BITSET_FIXED); |
fderives = bitsetv_create (nvars, nrules, BITSET_FIXED); |
165 |
|
|
182 |
void |
void |
183 |
new_closure (int n) |
new_closure (int n) |
184 |
{ |
{ |
185 |
itemset = XCALLOC (item_number_t, n); |
itemset = XCALLOC (item_number, n); |
186 |
|
|
187 |
ruleset = bitset_create (nrules, BITSET_FIXED); |
ruleset = bitset_create (nrules, BITSET_FIXED); |
188 |
|
|
192 |
|
|
193 |
|
|
194 |
void |
void |
195 |
closure (item_number_t *core, int n) |
closure (item_number *core, int n) |
196 |
{ |
{ |
197 |
/* Index over CORE. */ |
/* Index over CORE. */ |
198 |
int c; |
int c; |
199 |
|
|
200 |
/* A bit index over RULESET. */ |
/* A bit index over RULESET. */ |
201 |
rule_number_t ruleno; |
rule_number ruleno; |
202 |
|
|
203 |
bitset_iterator iter; |
bitset_iterator iter; |
204 |
|
|
215 |
c = 0; |
c = 0; |
216 |
BITSET_FOR_EACH (iter, ruleset, ruleno, 0) |
BITSET_FOR_EACH (iter, ruleset, ruleno, 0) |
217 |
{ |
{ |
218 |
item_number_t itemno = rules[ruleno].rhs - ritem; |
item_number itemno = rules[ruleno].rhs - ritem; |
219 |
while (c < n && core[c] < itemno) |
while (c < n && core[c] < itemno) |
220 |
{ |
{ |
221 |
itemset[nritemset] = core[c]; |
itemset[nritemset] = core[c]; |