mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 03:33:20 +01:00
134 lines
2.1 KiB
C
134 lines
2.1 KiB
C
char rcsid_item[] = "$Id$";
|
|
|
|
#include "b.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "fe.h"
|
|
|
|
static Item_Set fptr;
|
|
|
|
ItemArray
|
|
newItemArray()
|
|
{
|
|
ItemArray ia;
|
|
ia = (ItemArray) zalloc(max_nonterminal *sizeof(*ia));
|
|
return ia;
|
|
}
|
|
|
|
ItemArray
|
|
itemArrayCopy(src) ItemArray src;
|
|
{
|
|
ItemArray dst;
|
|
|
|
dst = newItemArray();
|
|
memcpy(dst, src, max_nonterminal * sizeof(*dst));
|
|
return dst;
|
|
}
|
|
|
|
Item_Set
|
|
newItem_Set(relevant) Relevant relevant;
|
|
{
|
|
Item_Set ts;
|
|
|
|
if (fptr) {
|
|
ts = fptr;
|
|
fptr = 0;
|
|
memset(ts->virgin, 0, max_nonterminal * sizeof(struct item));
|
|
if (ts->closed) {
|
|
zfree(ts->closed);
|
|
ts->closed = 0;
|
|
}
|
|
ts->num = 0;
|
|
ts->op = 0;
|
|
} else {
|
|
ts = (Item_Set) zalloc(sizeof(struct item_set));
|
|
ts->virgin = newItemArray();
|
|
}
|
|
ts->relevant = relevant;
|
|
return ts;
|
|
}
|
|
|
|
void
|
|
freeItem_Set(ts) Item_Set ts;
|
|
{
|
|
assert(!fptr);
|
|
fptr = ts;
|
|
}
|
|
|
|
int
|
|
equivSet(a, b) Item_Set a; Item_Set b;
|
|
{
|
|
register Relevant r;
|
|
register int nt;
|
|
register Item *aa = a->virgin;
|
|
register Item *ba = b->virgin;
|
|
|
|
/*
|
|
return !bcmp(a->virgin, b->virgin, max_nonterminal * sizeof(Item));
|
|
*/
|
|
|
|
r = a->relevant ? a->relevant : b->relevant;
|
|
assert(r);
|
|
|
|
if (a->op && b->op && a->op != b->op) {
|
|
return 0;
|
|
}
|
|
for (; (nt = *r) != 0; r++) {
|
|
if (aa[nt].rule != ba[nt].rule || !EQUALCOST(aa[nt].delta, ba[nt].delta)) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
printRepresentative(f, s) FILE *f; Item_Set s;
|
|
{
|
|
if (!s) {
|
|
return;
|
|
}
|
|
fprintf(f, "%s", s->op->name);
|
|
switch (s->op->arity) {
|
|
case 1:
|
|
fprintf(f, "(");
|
|
printRepresentative(f, s->kids[0]);
|
|
fprintf(f, ")");
|
|
break;
|
|
case 2:
|
|
fprintf(f, "(");
|
|
printRepresentative(f, s->kids[0]);
|
|
fprintf(f, ", ");
|
|
printRepresentative(f, s->kids[1]);
|
|
fprintf(f, ")");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
dumpItem(t) Item *t;
|
|
{
|
|
printf("[%s #%d]", t->rule->lhs->name, t->rule->num);
|
|
dumpCost(t->delta);
|
|
}
|
|
|
|
void
|
|
dumpItem_Set(ts) Item_Set ts;
|
|
{
|
|
int i;
|
|
|
|
printf("Item_Set #%d: [", ts->num);
|
|
for (i = 1; i < max_nonterminal; i++) {
|
|
if (ts->virgin[i].rule) {
|
|
printf(" %d", i);
|
|
dumpCost(ts->virgin[i].delta);
|
|
}
|
|
}
|
|
printf(" ]\n");
|
|
}
|
|
|
|
void
|
|
dumpCost(dc) DeltaCost dc;
|
|
{
|
|
printf("(%ld)", (long) dc);
|
|
}
|