236 |
closure (short *core, int n) |
closure (short *core, int n) |
237 |
{ |
{ |
238 |
int ruleno; |
int ruleno; |
239 |
short *csp; |
/* Index over CORE. */ |
240 |
|
int c; |
241 |
|
|
242 |
|
/* Index over RULESET. */ |
243 |
|
int r; |
244 |
|
|
245 |
int itemno; |
int itemno; |
|
int i; |
|
246 |
|
|
247 |
if (trace_flag) |
if (trace_flag) |
248 |
{ |
{ |
249 |
fprintf (stderr, "Entering closure (items = {"); |
fprintf (stderr, "Entering closure (items = {"); |
250 |
for (i = 0; i < n; ++i) |
for (c = 0; c < n; ++c) |
251 |
fprintf (stderr, " %d ", core[i]); |
fprintf (stderr, " %d ", core[c]); |
252 |
fprintf (stderr, "}, nitems = %d)\n", n); |
fprintf (stderr, "})\n"); |
253 |
} |
} |
254 |
|
|
255 |
if (n == 0) |
if (n == 0) |
256 |
{ |
{ |
257 |
for (i = 0; i < rulesetsize; ++i) |
for (r = 0; r < rulesetsize; ++r) |
258 |
ruleset[i] = FDERIVES (start_symbol)[i]; |
ruleset[r] = FDERIVES (start_symbol)[r]; |
259 |
} |
} |
260 |
else |
else |
261 |
{ |
{ |
262 |
for (i = 0; i < rulesetsize; ++i) |
for (r = 0; r < rulesetsize; ++r) |
263 |
ruleset[i] = 0; |
ruleset[r] = 0; |
264 |
|
|
265 |
for (i = 0; i < n; ++i) |
for (c = 0; c < n; ++c) |
266 |
{ |
if (ISVAR (ritem[core[c]])) |
267 |
int symbol = ritem[core[i]]; |
for (r = 0; r < rulesetsize; ++r) |
268 |
if (ISVAR (symbol)) |
ruleset[r] |= FDERIVES (ritem[core[c]])[r]; |
|
{ |
|
|
int j; |
|
|
for (j = 0; j < rulesetsize; ++j) |
|
|
ruleset[j] |= FDERIVES (symbol)[j]; |
|
|
} |
|
|
} |
|
269 |
} |
} |
270 |
|
|
271 |
ruleno = 0; |
ruleno = 0; |
272 |
itemsetsize = 0; |
itemsetsize = 0; |
273 |
csp = core; |
c = 0; |
274 |
for (i = 0; i < rulesetsize; ++i) |
for (r = 0; r < rulesetsize; ++r) |
275 |
{ |
{ |
276 |
int word = ruleset[i]; |
if (ruleset[r] == 0) |
|
if (word == 0) |
|
277 |
{ |
{ |
278 |
ruleno += BITS_PER_WORD; |
ruleno += BITS_PER_WORD; |
279 |
} |
} |
283 |
|
|
284 |
for (b = 0; b < BITS_PER_WORD; b++) |
for (b = 0; b < BITS_PER_WORD; b++) |
285 |
{ |
{ |
286 |
if (word & (1 << b)) |
if (ruleset[r] & (1 << b)) |
287 |
{ |
{ |
288 |
itemno = rule_table[ruleno].rhs; |
itemno = rule_table[ruleno].rhs; |
289 |
while (csp < (core + n) && *csp < itemno) |
while (c < n && core[c] < itemno) |
290 |
itemset[itemsetsize++] = *csp++; |
{ |
291 |
itemset[itemsetsize++] = itemno; |
itemset[itemsetsize] = core[c]; |
292 |
|
itemsetsize++; |
293 |
|
c++; |
294 |
|
} |
295 |
|
itemset[itemsetsize] = itemno; |
296 |
|
itemsetsize++; |
297 |
} |
} |
298 |
|
|
299 |
ruleno++; |
ruleno++; |
301 |
} |
} |
302 |
} |
} |
303 |
|
|
304 |
while (csp < (core + n)) |
while (c < n) |
305 |
itemset[itemsetsize++] = *csp++; |
{ |
306 |
|
itemset[itemsetsize] = core[c]; |
307 |
|
itemsetsize++; |
308 |
|
c++; |
309 |
|
} |
310 |
|
|
311 |
if (trace_flag) |
if (trace_flag) |
312 |
print_closure (n); |
print_closure (n); |