llvm/utils/Burg/trim.c

char rcsid_trim[] = "$Id$";

#include <stdio.h>
#include "b.h"
#include "fe.h"

Relation *allpairs;

int trimflag = 0;
int debugTrim = 0;

static void siblings ARGS((int, int));
static void findAllNexts ARGS((void));
static Relation *newAllPairs ARGS((void));

static void
siblings(i, j) int i; int j;
{
	int k;
	List pl;
	DeltaCost Max;
	int foundmax;

	allpairs[i][j].sibComputed = 1;

	if (i == 1) {
		return; /* never trim start symbol */
	}
	if (i==j) {
		return;
	}

	ZEROCOST(Max);
	foundmax = 0;

	for (k = 1; k < max_nonterminal; k++) {
		DeltaCost tmp;

		if (k==i || k==j) {
			continue;
		}
		if (!allpairs[k][i].rule) {
			continue;
		}
		if (!allpairs[k][j].rule) {
			return;
		}
		ASSIGNCOST(tmp, allpairs[k][j].chain);
		MINUSCOST(tmp, allpairs[k][i].chain);
		if (foundmax) {
			if (LESSCOST(Max, tmp)) {
				ASSIGNCOST(Max, tmp);
			}
		} else {
			foundmax = 1;
			ASSIGNCOST(Max, tmp);
		}
	}

	for (pl = rules; pl; pl = pl->next) {
		Rule p = (Rule) pl->x;
		Operator op = p->pat->op;
		List oprule;
		DeltaCost Min;
		int foundmin;
		
		if (!op) {
			continue;
		}
		switch (op->arity) {
		case 0:
			continue;
		case 1:
			if (!allpairs[p->pat->children[0]->num ][ i].rule) {
				continue;
			}
			foundmin = 0;
			for (oprule = op->table->rules; oprule; oprule = oprule->next) {
				Rule s = (Rule) oprule->x;
				DeltaPtr Cx;
				DeltaPtr Csj;
				DeltaPtr Cpi;
				DeltaCost tmp;

				if (!allpairs[p->lhs->num ][ s->lhs->num].rule
				 || !allpairs[s->pat->children[0]->num ][ j].rule) {
					continue;
				}
				Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
				Csj= allpairs[s->pat->children[0]->num ][ j].chain;
				Cpi= allpairs[p->pat->children[0]->num ][ i].chain;
				ASSIGNCOST(tmp, Cx);
				ADDCOST(tmp, s->delta);
				ADDCOST(tmp, Csj);
				MINUSCOST(tmp, Cpi);
				MINUSCOST(tmp, p->delta);
				if (foundmin) {
					if (LESSCOST(tmp, Min)) {
						ASSIGNCOST(Min, tmp);
					}
				} else {
					foundmin = 1;
					ASSIGNCOST(Min, tmp);
				}
			}
			if (!foundmin) {
				return;
			}
			if (foundmax) {
				if (LESSCOST(Max, Min)) {
					ASSIGNCOST(Max, Min);
				}
			} else {
				foundmax = 1;
				ASSIGNCOST(Max, Min);
			}
			break;
		case 2:
		/* do first dimension */
		if (allpairs[p->pat->children[0]->num ][ i].rule) {
			foundmin = 0;
			for (oprule = op->table->rules; oprule; oprule = oprule->next) {
				Rule s = (Rule) oprule->x;
				DeltaPtr Cx;
				DeltaPtr Cb;
				DeltaPtr Csj;
				DeltaPtr Cpi;
				DeltaCost tmp;

				if (allpairs[p->lhs->num ][ s->lhs->num].rule
				 && allpairs[s->pat->children[0]->num ][ j].rule
				 && allpairs[s->pat->children[1]->num ][ p->pat->children[1]->num].rule) {
					Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
					Csj= allpairs[s->pat->children[0]->num ][ j].chain;
					Cpi= allpairs[p->pat->children[0]->num ][ i].chain;
					Cb = allpairs[s->pat->children[1]->num ][ p->pat->children[1]->num].chain;
					ASSIGNCOST(tmp, Cx);
					ADDCOST(tmp, s->delta);
					ADDCOST(tmp, Csj);
					ADDCOST(tmp, Cb);
					MINUSCOST(tmp, Cpi);
					MINUSCOST(tmp, p->delta);
					if (foundmin) {
						if (LESSCOST(tmp, Min)) {
							ASSIGNCOST(Min, tmp);
						}
					} else {
						foundmin = 1;
						ASSIGNCOST(Min, tmp);
					}
				}
			}
			if (!foundmin) {
				return;
			}
			if (foundmax) {
				if (LESSCOST(Max, Min)) {
					ASSIGNCOST(Max, Min);
				}
			} else {
				foundmax = 1;
				ASSIGNCOST(Max, Min);
			}
		}
		/* do second dimension */
		if (allpairs[p->pat->children[1]->num ][ i].rule) {
			foundmin = 0;
			for (oprule = op->table->rules; oprule; oprule = oprule->next) {
				Rule s = (Rule) oprule->x;
				DeltaPtr Cx;
				DeltaPtr Cb;
				DeltaPtr Csj;
				DeltaPtr Cpi;
				DeltaCost tmp;

				if (allpairs[p->lhs->num ][ s->lhs->num].rule
				 && allpairs[s->pat->children[1]->num ][ j].rule
				 && allpairs[s->pat->children[0]->num ][ p->pat->children[0]->num].rule) {
					Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
					Csj= allpairs[s->pat->children[1]->num ][ j].chain;
					Cpi= allpairs[p->pat->children[1]->num ][ i].chain;
					Cb = allpairs[s->pat->children[0]->num ][ p->pat->children[0]->num].chain;
					ASSIGNCOST(tmp, Cx);
					ADDCOST(tmp, s->delta);
					ADDCOST(tmp, Csj);
					ADDCOST(tmp, Cb);
					MINUSCOST(tmp, Cpi);
					MINUSCOST(tmp, p->delta);
					if (foundmin) {
						if (LESSCOST(tmp, Min)) {
							ASSIGNCOST(Min, tmp);
						}
					} else {
						foundmin = 1;
						ASSIGNCOST(Min, tmp);
					}
				}
			}
			if (!foundmin) {
				return;
			}
			if (foundmax) {
				if (LESSCOST(Max, Min)) {
					ASSIGNCOST(Max, Min);
				}
			} else {
				foundmax = 1;
				ASSIGNCOST(Max, Min);
			}
		}
		break;
		default:
			assert(0);
		}
	}
	allpairs[i ][ j].sibFlag = foundmax;
	ASSIGNCOST(allpairs[i ][ j].sibling, Max);
}

static void
findAllNexts()
{
	int i,j;
	int last;

	for (i = 1; i < max_nonterminal; i++) {
		last = 0;
		for (j = 1; j < max_nonterminal; j++) {
			if (allpairs[i ][j].rule) {
				allpairs[i ][ last].nextchain = j;
				last = j;
			}
		}
	}
	/*
	for (i = 1; i < max_nonterminal; i++) {
		last = 0;
		for (j = 1; j < max_nonterminal; j++) {
			if (allpairs[i ][j].sibFlag) {
				allpairs[i ][ last].nextsibling = j;
				last = j;
			}
		}
	}
	*/
}

static Relation *
newAllPairs()
{
	int i;
	Relation *rv;

	rv = (Relation*) zalloc(max_nonterminal * sizeof(Relation));
	for (i = 0; i < max_nonterminal; i++) {
		rv[i] = (Relation) zalloc(max_nonterminal * sizeof(struct relation));
	}
	return rv;
}

void
findAllPairs()
{
	List pl;
	int changes;
	int j;

	allpairs = newAllPairs();
	for (pl = chainrules; pl; pl = pl->next) {
		Rule p = (Rule) pl->x;
		NonTerminalNum rhs = p->pat->children[0]->num;
		NonTerminalNum lhs = p->lhs->num;
		Relation r = &allpairs[lhs ][ rhs];

		if (LESSCOST(p->delta, r->chain)) {
			ASSIGNCOST(r->chain, p->delta);
			r->rule = p;
		}
	}
	for (j = 1; j < max_nonterminal; j++) {
		Relation r = &allpairs[j ][ j];
		ZEROCOST(r->chain);
		r->rule = &stub_rule;
	}
	changes = 1;
	while (changes) {
		changes = 0;
		for (pl = chainrules; pl; pl = pl->next) {
			Rule p = (Rule) pl->x;
			NonTerminalNum rhs = p->pat->children[0]->num;
			NonTerminalNum lhs = p->lhs->num;
			int i;

			for (i = 1; i < max_nonterminal; i++) {
				Relation r = &allpairs[rhs ][ i];
				Relation s = &allpairs[lhs ][ i];
				DeltaCost dc;
				if (!r->rule) {
					continue;
				}
				ASSIGNCOST(dc, p->delta);
				ADDCOST(dc, r->chain);
				if (!s->rule || LESSCOST(dc, s->chain)) {
					s->rule = p;
					ASSIGNCOST(s->chain, dc);
					changes = 1;
				}
			}
		}
	}
	findAllNexts();
}

void
trim(t) Item_Set t;
{
	int m,n;
	static short *vec = 0;
	int last;

	assert(!t->closed);
	debug(debugTrim, printf("Begin Trim\n"));
	debug(debugTrim, dumpItem_Set(t));

	last = 0;
	if (!vec) {
		vec = (short*) zalloc(max_nonterminal * sizeof(*vec));
	}
	for (m = 1; m < max_nonterminal; m++) {
		if (t->virgin[m].rule) {
			vec[last++] = m;
		}
	}
	for (m = 0; m < last; m++) {
		DeltaCost tmp;
		int j;
		int i;

		i = vec[m];

		for (j = allpairs[i ][ 0].nextchain; j; j = allpairs[i ][ j].nextchain) {

			if (i == j) {
				continue;
			}
			if (!t->virgin[j].rule) {
				continue;
			}
			ASSIGNCOST(tmp, t->virgin[j].delta);
			ADDCOST(tmp, allpairs[i ][ j].chain);
			if (!LESSCOST(t->virgin[i].delta, tmp)) {
				t->virgin[i].rule = 0;
				ZEROCOST(t->virgin[i].delta);
				debug(debugTrim, printf("Trimmed Chain (%d,%d)\n", i,j));
				goto outer;
			}
			
		}
		if (!trimflag) {
			continue;
		}
		for (n = 0; n < last; n++) {
			j = vec[n];
			if (i == j) {
				continue;
			}

			if (!t->virgin[j].rule) {
				continue;
			}

			if (!allpairs[i][j].sibComputed) {
				siblings(i,j);
			}
			if (!allpairs[i][j].sibFlag) {
				continue;
			}
			ASSIGNCOST(tmp, t->virgin[j].delta);
			ADDCOST(tmp, allpairs[i ][ j].sibling);
			if (!LESSCOST(t->virgin[i].delta, tmp)) {
				t->virgin[i].rule = 0;
				ZEROCOST(t->virgin[i].delta);
				goto outer;
			}
		}

		outer: ;
	}

	debug(debugTrim, dumpItem_Set(t));
	debug(debugTrim, printf("End Trim\n"));
}

void
dumpRelation(r) Relation r;
{
	printf("{ %d %ld %d %ld }", r->rule->erulenum, (long) r->chain, r->sibFlag, (long) r->sibling);
}

void
dumpAllPairs()
{
	int i,j;

	printf("Dumping AllPairs\n");
	for (i = 1; i < max_nonterminal; i++) {
		for (j = 1; j < max_nonterminal; j++) {
			dumpRelation(&allpairs[i ][j]);
		}
		printf("\n");
	}
}