static void set_derives(void) { int i, k; int lhs; short *rules; derives = NEW2(nsyms, short *); rules = NEW2(nvars + nrules, short); k = 0; for (lhs = start_symbol; lhs < nsyms; lhs++) { derives[lhs] = rules + k; for (i = 0; i < nrules; i++) { if (rlhs[i] == lhs) { rules[k] = i; k++; } } rules[k] = -1; k++; } #ifdef DEBUG print_derives(); #endif }
void derives_compute (void) { symbol_number i; rule_number r; rule **q; /* DSET[NTERM - NTOKENS] -- A linked list of the numbers of the rules whose LHS is NTERM. */ rule_list **dset = xcalloc (nvars, sizeof *dset); /* 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 *delts = xnmalloc (nrules, sizeof *delts); for (r = nrules - 1; r >= 0; --r) { symbol_number lhs = rules[r].lhs->number; rule_list *p = &delts[r]; /* A new LHS is found. */ p->next = dset[lhs - ntokens]; p->value = &rules[r]; dset[lhs - ntokens] = p; } /* DSET contains what we need under the form of a linked list. Make it a single array. */ derives = xnmalloc (nvars, sizeof *derives); q = xnmalloc (nvars + nrules, sizeof *q); for (i = ntokens; i < nsyms; i++) { rule_list *p = dset[i - ntokens]; derives[i - ntokens] = q; while (p) { *q++ = p->value; p = p->next; } *q++ = NULL; } if (trace_flag & trace_sets) print_derives (); free (dset); free (delts); }
void set_derives() { register int i; register int lhs; register shorts *p; register short *q; register shorts **dset; register shorts *delts; dset = NEW2(nvars, shorts *) - ntokens; delts = NEW2(nrules + 1, shorts); p = delts; for (i = nrules; i > 0; i--) { lhs = rlhs[i]; if (lhs >= 0) { p->next = dset[lhs]; p->value = i; dset[lhs] = p; p++; } } derives = NEW2(nvars, short *) - ntokens; q = NEW2(nvars + nrules, short); for (i = ntokens; i < nsyms; i++) { derives[i] = q; p = dset[i]; while (p) { *q++ = p->value; p = p->next; } *q++ = -1; } #ifdef DEBUG print_derives(); #endif FREE(dset + ntokens); FREE(delts); }