#ifndef NORCSID
static char rcsid[] = "$Id$";
#endif

#include <stdlib.h>
#include <stdio.h>
#include "assert.h"
#include "param.h"
#include "tables.h"
#include "types.h"
#include <cgg_cg.h>
#include "data.h"
#include "result.h"
#include "state.h"
#include "equiv.h"
#include "extern.h"

/*
 * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
 * See the copyright notice in the ACK home directory, in the file "Copyright".
 *
 * Author: Hans van Staveren
 */

#define ALLOW_NEXTEM	/* code generator is allowed new try of NEXTEM
			   in exceptional cases */

byte startupcode[] = { DO_NEXTEM };

byte *nextem();
unsigned costcalc();
unsigned docoerc();
unsigned stackupto();
string tostring();
string ad2str();

#ifdef NDEBUG
#define DEBUG(string)
#else
#include <stdio.h>
#define DEBUG(string) {if(Debug) fprintf(stderr,"%-*d%s\n",4*level,level,string);}
#endif

#define BROKE() {assert(origcp!=startupcode || !paniced);DEBUG("BROKE");totalcost=INFINITY;goto doreturn;}
#define CHKCOST() {if (totalcost>=costlimit) BROKE();}

#ifdef TABLEDEBUG
int tablelines[MAXTDBUG];
int ntableline;
int set_fd,set_size;
short *set_val;
char *set_flag;
#endif

unsigned codegen(codep,ply,toplevel,costlimit,forced) byte *codep; unsigned costlimit; {
#ifndef NDEBUG
	byte *origcp=codep;
	static int level=0;
#endif
	unsigned totalcost = 0;
	int inscoerc=0;
	int procarg[MAXPROCARG+1];
#ifdef ALLOW_NEXTEM
	static int paniced;
	char *savebp = 0;
#endif
	state_t state;
#define SAVEST	savestatus(&state)
#define RESTST	restorestatus(&state)
#define FREEST	/* nothing */
#ifdef TABLEDEBUG
	extern char *tablename;
#endif

#ifndef NDEBUG
	assert(costlimit <= INFINITY);
	level++;
	DEBUG("Entering codegen");
	if (Debug > 1) fprintf(stderr, "toplevel = %d\n", toplevel);
#endif
	for (;;) {
	switch( (*codep++)&037 ) {
    default:
	assert(FALSE);
	/* NOTREACHED */
#ifdef TABLEDEBUG
    case DO_DLINE: {
	int n;

	getint(n,codep);
	tablelines[ntableline++] = n;
	if (ntableline>=MAXTDBUG)
		ntableline -= MAXTDBUG;
	if (set_fd)
		set_val[n>>4] &= ~(1<<(n&017));
#ifndef NDEBUG
	if (Debug)
		fprintf(stderr,"code from \"%s\", line %d\n",tablename,n);
#endif
	break;
    }
#endif
    case DO_NEXTEM: {
	byte *bp;
	int n;
	unsigned mindistance,dist;
	register i;
	int cindex;
	int npos,pos[MAXRULE];
	unsigned mincost,t;

	DEBUG("NEXTEM");
	tokpatlen = 0;
	nallreg=0;
	if (toplevel) {
		garbage_collect();
		totalcost=0;
	} else {
		if (--ply <= 0)
			goto doreturn;
	}
	if (stackheight>MAXFSTACK-7) {
#ifndef NDEBUG
		if (Debug)
			fprintf(stderr,"Fakestack overflow threatens(%d), action ...\n",stackheight);
#endif
		totalcost += stackupto(&fakestack[6],ply,toplevel);
	}
#ifndef ALLOW_NEXTEM
	bp = nextem(toplevel);
#else
	if (toplevel) paniced=0;
	savebp = nextem(toplevel);
    panic:
	if (toplevel) totalcost = 0;
	bp = savebp;
#endif
	if (bp == 0) {
		/*
		 * No pattern found, can be pseudo or error
		 * in table.
		 */
		if (toplevel) {
			codep--;
			DEBUG("pseudo");
			dopseudo();
		} else
			goto doreturn;
	} else {
#ifndef NDEBUG
		chkregs();
#endif
		if (! toplevel) {
			ply -= emp-saveemp+1;
			if (ply <= 0) ply = 1;
		}
		n = *bp++;
		if (n==0) {	/* "procedure" */
			int j, nargs;
			getint(i,bp);
			getint(nargs,bp);
			assert(nargs <= MAXPROCARG);
			for (j = 0; j < nargs; j++) {
				getint(procarg[j],bp);
			}
			bp= &pattern[i];
			n = *bp++;
			DEBUG("PROC_CALL");
		}
		assert(n>0 && n<=MAXRULE);
		if (n>1) {
			mindistance = MAXINT; npos=0;
			for(i=0;i<n;i++) {
				getint(cindex,bp);
				dist=distance(cindex);
#ifndef NDEBUG
if (Debug)
	fprintf(stderr,"distance of pos %d is %u\n",i,dist);
#endif
				if (dist<=mindistance
#ifdef ALLOW_NEXTEM
				    || paniced
#endif
				   ) {
					if (dist<mindistance) {
						if(dist==0)
							goto gotit;
						npos=0;
						mindistance = dist;
					}
#ifdef ALLOW_NEXTEM
					if (dist < MAXINT)
#endif
					pos[npos++] = cindex;
				}
			}
			assert(mindistance<MAXINT);
			if (npos>1) {
				/*
				 * More than 1 tokenpattern is a candidate.
				 * Decision has to be made by lookahead.
				 */
				SAVEST;
				mincost = costlimit-totalcost+1;
				assert(mincost <= INFINITY);
				for(i=0;i<npos;i++) {
					t=codegen(&coderules[pos[i]],ply,FALSE,
					    costlimit<MAXINT?mincost:MAXINT,0);
#ifndef NDEBUG
if (Debug)
	fprintf(stderr,"mincost %u,cost %u,pos %d\n",mincost,t,i);
#endif
					if (t<mincost) {
						mincost = t;
						cindex = pos[i];
					}
					RESTST;
				}
				FREEST;
				if (totalcost+mincost>costlimit) {
					BROKE();
				}
			} else {
				cindex = pos[0];
			}
		} else {
			getint(cindex,bp);
		}

	gotit:
		/*
		 * Now cindex contains the code-index of the best candidate
		 * so proceed to use it.
		 */
		codep = &coderules[cindex];
	}
	break;
    }
    case DO_COERC: {
	DEBUG("COERC");
	tokpatlen=1;
	inscoerc=1;
	break;
    }
    case DO_XXMATCH:
	DEBUG("XXMATCH");
    case DO_XMATCH: {
	register i;
	int temp;

	DEBUG("XMATCH");
	tokpatlen=(codep[-1]>>5)&07;
	for (i=0;i<tokpatlen;i++)
		getint(temp,codep);
	break;	/* match already checked by distance() */
    }
    case DO_MATCH: {
	register i;
	int j;
	unsigned mincost,t;
	token_p tp;
	int size,lsize;
	int tokexp[MAXPATLEN];
	int nregneeded;
	token_p regtp[MAXCREG];
	c3_p regcp[MAXCREG];
	rl_p regls[MAXCREG];
	c3_p cp,findcoerc();
#ifdef MAXSPLIT
	int sret;
#endif
	int stackpad = 0;
	struct perm *tup,*ntup,*besttup,*tuples();

	DEBUG("MATCH");
	tokpatlen=(codep[-1]>>5)&07;
	for(i=0;i<tokpatlen;i++)
		getint(tokexp[i],codep);
	tokexp[i] = 0;
	tp = &fakestack[stackheight-1];
	i=0;
	while (i<tokpatlen && tp>=fakestack) {
		size=tsize(tp);
		while (i<tokpatlen && (lsize=ssize(tokexp[i]))<=size) {
			size -= lsize;
			i++;
		}
		if (i<tokpatlen && size!=0) {
			totalcost += stackupto(tp,ply,toplevel);
			CHKCOST();
			break;
		}
		tp--;
	}
	tp = &fakestack[stackheight-1];
	i=0;
	while (i<tokpatlen && tp >= fakestack) {
		size = tsize(tp);
		lsize= ssize(tokexp[i]);
		if (size != lsize) {    /* find coercion */
#ifdef MAXSPLIT
			sret = split(tp,&tokexp[i],ply,toplevel);
			if (sret==0) {
#endif /* MAXSPLIT */
				totalcost += stackupto(tp,ply,toplevel);
				CHKCOST();
				break;
#ifdef MAXSPLIT
			}
			i += sret;
#endif /* MAXSPLIT */
		} else
			i += 1;
		tp--;
	}
    nextmatch:
	tp = &fakestack[stackheight-1];
	i=0; nregneeded = 0;
	while (i<tokpatlen && tp>=fakestack) {
		if (!match(tp,&machsets[tokexp[i]],0)) {
			cp = findcoerc(tp, &machsets[tokexp[i]]);
#ifndef NDEBUG
if (Debug>1) fprintf(stderr,"findcoerc returns 0x%x at position %d\n",(unsigned)cp,i);
#endif
			if (cp==0) {
				for (j=0;j<nregneeded;j++)
					regtp[j] -= (tp-fakestack+1);
				totalcost += stackupto(tp,ply,toplevel);
				CHKCOST();
				break;
			} else {
				if (cp->c3_prop<0) {
					totalcost+=docoerc(tp,cp,ply,toplevel,0);
					CHKCOST();
				} else {
#ifndef NDEBUG
if(Debug>1) fprintf(stderr,"Register of type %d needed, remembering...\n",cp->c3_prop);
#endif
					assert(nregneeded<MAXCREG);
					regtp[nregneeded] = tp;
					regcp[nregneeded] = cp;
					regls[nregneeded] = curreglist;
					nregneeded++;
				}
			}
		}
		i++; tp--;
	}
	if (tokpatlen>stackheight) {
#ifndef NDEBUG
if(Debug>1) fprintf(stderr,"Pattern too long, %d with only %d items on stack\n",
		tokpatlen,stackheight);
#endif
		stackpad = tokpatlen-stackheight;
		for (j=stackheight-1;j>=0;j--)
			fakestack[j+stackpad] = fakestack[j];
		for (j=0;j<stackpad;j++)
			fakestack[j].t_token=0;
		stackheight += stackpad;
		for (j=0;j<nregneeded;j++)
			regtp[j] += stackpad;
		for (tp = &fakestack[stackpad-1];i<tokpatlen && tp>=fakestack;i++,tp--) {
			cp = findcoerc((token_p) 0, &machsets[tokexp[i]]);
			if (cp==0) {
				for (j=0;j<nregneeded;j++)
					myfree((string) (regls[j]));
#ifndef ALLOW_NEXTEM
				assert(!toplevel);
				BROKE();
#else
				assert(!(toplevel&&paniced));
				if (paniced) goto normalfailed;
				totalcost = INFINITY;
				for (i=0;i<stackheight-stackpad;i++)
					fakestack[i] = fakestack[i+stackpad];
				stackheight -= stackpad;
				goto doreturn;
#endif
			}
			if (cp->c3_prop<0) {
				totalcost+=docoerc(tp,cp,ply,toplevel,0);
				CHKCOST();
			} else {
				assert(nregneeded<MAXCREG);
				regtp[nregneeded] = tp;
				regcp[nregneeded] = cp;
				regls[nregneeded] = curreglist;
				nregneeded++;
			}
		}
	} else
		stackpad=0;
	assert(i==tokpatlen);
	if (nregneeded==0)
		break;
	SAVEST;
	mincost=costlimit-totalcost+1;
	tup = tuples(regls,nregneeded);
	besttup=0;
	for (; tup != 0; tup = ntup) {
#ifndef NDEBUG
if(Debug>1) { fprintf(stderr,"Next tuple %d,%d,%d,%d\n",
			tup->p_rar[0],
			tup->p_rar[1],
			tup->p_rar[2],
			tup->p_rar[3]);
		fprintf(stderr, "totalcost = %u, costlimit = %u, mincost = %u\n",
			totalcost, costlimit, mincost);
	}
#endif
		ntup = tup->p_next;
		for (i=0,t=0;i<nregneeded && t<mincost; i++)
			t += docoerc(regtp[i],regcp[i],ply,FALSE,tup->p_rar[i]);
#ifndef NDEBUG
if (Debug > 1) fprintf(stderr, "cost after coercions: %u\n", t);
#endif
		if ( t<mincost && tokpatlen<=stackheight ) {
#ifndef NDEBUG
			if (Debug>2)
				fprintf(stderr,"Continuing match after coercions\n");
#endif
			t += codegen(codep,ply,FALSE,mincost<MAXINT?mincost-t:MAXINT,0);
		}
		if ( t<mincost && tokpatlen<=stackheight ) {
			mincost = t;
			besttup = tup;
		} else
			myfree((string) tup);
		RESTST;
	}
	FREEST;
	for (i=0;i<nregneeded;i++)
		myfree((string)(regls[i]));
	if (totalcost+mincost>costlimit) {
		if (besttup)
			myfree((string)besttup);
normalfailed:	if (stackpad!=tokpatlen) {
			if (stackpad) {
				for (i=0;i<stackheight-stackpad;i++)
					fakestack[i] = fakestack[i+stackpad];
				stackheight -= stackpad;
				if (costlimit<MAXINT)
					BROKE();
				totalcost += stackupto(&fakestack[stackheight-1],ply,toplevel);
			} else
				totalcost += stackupto(fakestack,ply,toplevel);
			CHKCOST();
			goto nextmatch;
		}
		totalcost += mincost;
		for (i=0;i<stackheight-stackpad;i++)
			fakestack[i] = fakestack[i+stackpad];
		stackheight -= stackpad;
                BROKE();
	}
	for (i=0;i<nregneeded;i++)
		totalcost += docoerc(regtp[i],regcp[i],ply,toplevel,besttup->p_rar[i]);
	assert(totalcost <= costlimit);
	myfree((string)besttup);
	break;
    }
    case DO_TOSTACK:
    case DO_REMOVE: {
	int texpno,nodeno;
	token_p tp;
	struct reginfo *rp;
	int doremove = (codep[-1] & 037) == DO_REMOVE;
	extern int allsetno;

	DEBUG(doremove ? "REMOVE" : "TOSTACK");
	if (codep[-1]&32) {
		getint(texpno,codep);
		getint(nodeno,codep);
	} else {
		getint(texpno,codep);
		nodeno=0;
	}
	if (texpno == allsetno) {
		totalcost += stackupto(&fakestack[stackheight-tokpatlen-1],ply,toplevel);
		CHKCOST();
		if (doremove) for (rp=machregs;rp<machregs+NREGS;rp++)
			rp->r_contents.t_token=0;
		break;
	}
	for (tp= &fakestack[stackheight-tokpatlen-1];tp>=&fakestack[0];tp--)
		if (match(tp,&machsets[texpno],nodeno)) {
			/* investigate possible coercion to register */
			totalcost += stackupto(tp,ply,toplevel);
			CHKCOST();
			break;
		}
	if (doremove) for (rp=machregs;rp<machregs+NREGS;rp++) {
		if (rp->r_contents.t_token != 0 &&
		    match(&rp->r_contents,&machsets[texpno],nodeno)) {
#ifndef NDEBUG
			if (Debug > 1) fprintf(stderr, "killing reg %ld (%s)\n", (long)(rp-machregs), rp->r_repr ? codestrings[rp->r_repr] : "cc");
#endif
			rp->r_contents.t_token=0;
		}
	}
	break;
    }
    case DO_KILLREG:
    case DO_RREMOVE: {	/* register remove */
	register i;
	int nodeno;
	token_p tp;
	tkdef_p tdp;
	result_t result;
	int dokill = (codep[-1] & 037) == DO_KILLREG;

	DEBUG(dokill ? "KILLREG" : "RREMOVE");
	getint(nodeno,codep);
	compute(&enodes[nodeno], &result);
	if (result.e_typ!=EV_REG)
		break;
	if ( in_stack(result.e_v.e_reg) ) BROKE() ; /* Check aside-stack */
	if (dokill) {
		/* kill register, and kill condition codes if they are set to
		   this register
		*/
		machregs[result.e_v.e_reg].r_contents.t_token = 0;
		if (machregs[0].r_contents.t_token == -1 &&
		    machregs[0].r_contents.t_att[0].ar == result.e_v.e_reg) {
			machregs[0].r_contents.t_token = 0;	
		}
	}
	for (tp= &fakestack[stackheight-tokpatlen-1];tp>=&fakestack[0];tp--)
		if (tp->t_token==-1) {
			if(tp->t_att[0].ar==result.e_v.e_reg)
				goto gotone;
		} else {
			tdp = &tokens[tp->t_token];
			for(i=0;i<TOKENSIZE;i++)
				if (tdp->t_type[i]==EV_REG &&
				    tp->t_att[i].ar==result.e_v.e_reg)
					goto gotone;
		}
	break;
    gotone:
	/* investigate possible coercion to register */
	totalcost += stackupto(tp,ply,toplevel);
	CHKCOST();
	break;
    }
    case DO_DEALLOCATE: {
	register i;
	tkdef_p tdp;
	int tinstno;
	token_t token;

	DEBUG("DEALLOCATE");
	getint(tinstno,codep);
	instance(tinstno,&token);
	if (token.t_token==-1)
		chrefcount(token.t_att[0].ar,-1,TRUE);
	else {
		tdp= &tokens[token.t_token];
		for (i=0;i<TOKENSIZE;i++)
			if (tdp->t_type[i]==EV_REG)
				chrefcount(token.t_att[i].ar,-1,TRUE);
	}
	break;
    }
    case DO_REALLOCATE: {
	struct reginfo *rp;

	DEBUG("REALLOCATE");
	for(rp=machregs+1;rp<machregs+NREGS;rp++)
		if(rp->r_tcount) {
			rp->r_refcount -= rp->r_tcount;
			rp->r_tcount = 0;
		}
	break;
    }
    case DO_ALLOCATE: {
	register i;
	int j;
	int tinstno;
	int npos,npos2,pos[NREGS],pos2[NREGS];
	unsigned mincost,t;
	struct reginfo *rp,**rpp;
	token_t token,token2;
	int propno;
	int exactmatch;
	int decision;

	if (codep[-1]&32) {
		getint(propno,codep);
		getint(tinstno,codep);
		DEBUG("ALLOCATE,INIT");
	} else {
		getint(propno,codep);
		tinstno=0;
		DEBUG("ALLOCATE,EMPTY");
	}
	instance(tinstno,&token);
	if (!forced) {
		do {
			npos=exactmatch=0;
			for(rpp=reglist[propno];rp= *rpp; rpp++)
				if (getrefcount((int)(rp-machregs), FALSE)==0) {
					pos[npos++] = rp-machregs;
					if (eqtoken(&rp->r_contents,&token))
						pos2[exactmatch++] = rp-machregs;
				}
			/*
			 * Now pos[] contains all free registers with desired
			 * property. If none then some stacking has to take place.
			 */
			if (npos==0) {
  				if (stackheight<=tokpatlen) {
  					if (!toplevel) {
  						BROKE();
 					} else {
 						if (paniced)
 							fatal("No regs available");
 						totalcost += stackupto( &fakestack[0],ply,toplevel);
 						goto panic;
 					}
  				}
  				totalcost += stackupto( &fakestack[0],ply,toplevel);
  				CHKCOST();
			}
		} while (npos==0);

		if (!exactmatch && tinstno!=0) {
			/*
			 * No exact match, but we were looking for a particular
			 * token. Now try to find registers of which no
			 * known contents is available (the others might still
			 * be useful).
			 */
			for (i=0;i<npos;i++)
				if (machregs[pos[i]].r_contents.t_token == 0) {
					pos2[exactmatch++] = pos[i];
				}
		}

		if (!exactmatch) {
			npos2=npos;
			for(i=0;i<npos;i++)
				pos2[i]=pos[i];
		} else {
			/*
			 * Now we are reducing the number of possible registers.
			 * We take only one equally likely register out of every
			 * equivalence class as given by set of properties.
			 */
			npos2=0;
			for(i=0;i<exactmatch;i++) {
				pos2[npos2++] = pos2[i];
				for(j=0;j<npos2-1;j++)
					if (eqregclass(pos2[j],pos2[i])) {
						npos2--;
						break;
					}
			}
		}
		/*
		 * Now pos2[] contains all possibilities to try, if more than
		 * one, lookahead is necessary.
		 */
		token2.t_token= -1;
		for (i=1;i<TOKENSIZE;i++)
			token2.t_att[i].aw=0;
		decision=pos2[0];
		if (npos2!=1) {
			SAVEST;
			mincost=costlimit-totalcost+1;
			for(j=0;j<npos2;j++) {
				chrefcount(pos2[j],1,FALSE);
				token2.t_att[0].ar=pos2[j];
				allreg[nallreg++] = pos2[j];
				if (token.t_token != 0)
					t=move(&token,&token2,ply,FALSE,mincost);
				else {
					t = 0;
					erasereg(pos2[j]);
				}
				if (t<mincost)
					t += codegen(codep,ply,FALSE,mincost<MAXINT?mincost-t:MAXINT,0);
				if (t<mincost) {
					mincost=t;
					decision=pos2[j];
				}
				RESTST;
			}
			FREEST;
			if (totalcost+mincost>costlimit)
				BROKE();
		}
	} else {
		decision = forced;
		if (getrefcount(decision, FALSE)!=0)
			BROKE();
		token2.t_token = -1;
	}
	chrefcount(decision,1,FALSE);
	token2.t_att[0].ar=decision;
	if (token.t_token != 0) {
		totalcost+=move(&token,&token2,ply,toplevel,MAXINT);
		CHKCOST();
	} else
		erasereg(decision);
	allreg[nallreg++]=decision;
	break;
    }
    case DO_INSTR: {
	register i;
	int n;
	int tinstno;
	token_t token;
	int stringno;

    	DEBUG("INSTR");
	n=((codep[-1]>>5)&07);
	getint(stringno,codep);
	if (toplevel) {
		swtxt();
		if (stringno>10000) {
			assert(stringno < 100001 + MAXPROCARG);
			genstr(procarg[stringno-10001]);
		} else
			genstr(stringno);
	}
	for(i=0;i<n;i++) {
		getint(tinstno,codep);
		instance(tinstno,&token);
		if (toplevel)
			prtoken(&token,i==0 ? ' ' : ',');
		if (token.t_token>0)
			totalcost += tokens[token.t_token].t_cost.ct_space;
	}
	if (toplevel)
		gennl();
	CHKCOST();
	break;		
    }
    case DO_MOVE: {
	int tinstno;
	token_t token,token2;

	DEBUG("MOVE");
	getint(tinstno,codep);
	instance(tinstno,&token);
	getint(tinstno,codep);
	instance(tinstno,&token2);
	totalcost += move(&token,&token2,ply,toplevel,costlimit-totalcost+1);
	CHKCOST();
	break;
    }
    case DO_TEST: {
	int tinstno;
	token_t token;

	DEBUG("TEST");
	getint(tinstno,codep);
	instance(tinstno,&token);
	totalcost += test(&token,ply,toplevel,costlimit-totalcost+1);
	CHKCOST();
	break;
    }
    case DO_SETCC: {
	int tinstno;
	token_t token;

    	DEBUG("SETCC");
	getint(tinstno,codep);
	instance(tinstno,&token);
	setcc(&token);
	break;
    }
    case DO_ERASE: {
	int nodeno;
	result_t result;

	DEBUG("ERASE");
	getint(nodeno,codep);
	compute(&enodes[nodeno], &result);
	assert(result.e_typ!=EV_INT && result.e_typ!=EV_ADDR);
	if (result.e_typ==EV_REG)
	{
		int regno = result.e_v.e_reg;
		erasereg(regno);
	}
	break;
    }
    case DO_TOKREPLACE: {
	register i;
	int tinstno;
	int repllen;
	token_t reptoken[MAXREPLLEN];

	DEBUG("TOKREPLACE");
	assert(stackheight>=tokpatlen);
	repllen=(codep[-1]>>5)&07;
#ifndef NDEBUG
	if (Debug>2)
		fprintf(stderr,"Stackheight=%d, tokpatlen=%d, repllen=%d %s\n",
			stackheight,tokpatlen,repllen,inscoerc ? "(inscoerc)":"");
#endif
	for(i=0;i<repllen;i++) {
		getint(tinstno,codep);
		instance(tinstno,&reptoken[i]);
		tref(&reptoken[i],1);
	}
	for(i=0;i<tokpatlen;i++) {
		if (!inscoerc)
			tref(&fakestack[stackheight-1],-1);
		stackheight--;
	}
	for (i=0;i<repllen;i++) {
		assert(stackheight<MAXFSTACK);
		fakestack[stackheight++] = reptoken[i];
	}
	for(i=0;i<nallreg;i++)
		chrefcount(allreg[i],-1,FALSE);
	break;
    }
    case DO_EMREPLACE: {
	register i;
	int j;
	int nodeno;
	result_t result[MAXEMREPLLEN];
	int emrepllen,eminstr;

	DEBUG("EMREPLACE");
	emrepllen=(codep[-1]>>5)&07;
	j=emp-emlines;
	if (emrepllen>j) {
		assert(nemlines+emrepllen-j<MAXEMLINES);
		for (i=nemlines;i>=0;i--)
			emlines[i+emrepllen-j] = emlines[i];
		nemlines += emrepllen-j;
		emp += emrepllen-j;
	}
	emp -= emrepllen;
	for (i=0;i<emrepllen;i++) {
		getint(eminstr,codep);
		getint(nodeno,codep);
		emp[i].em_instr = eminstr;
		compute(&enodes[nodeno], &result[i]);
	}
	for (i=0;i<emrepllen;i++) {
		switch(result[i].e_typ) {
		default:
			assert(FALSE);
		case 0:
			emp[i].em_optyp = OPNO;
			emp[i].em_soper = 0;
			break;
		case EV_INT:
			emp[i].em_optyp = OPINT;
			emp[i].em_soper = tostring(result[i].e_v.e_con);
			emp[i].em_u.em_ioper = result[i].e_v.e_con;
			break;
		case EV_ADDR:
			emp[i].em_optyp = OPSYMBOL;
			emp[i].em_soper = ad2str(result[i].e_v.e_addr);
			break;
		}
	}
	if (!toplevel) {
		ply += emrepllen;
#ifndef NDEBUG
		if (Debug > 4) 
			fprintf(stderr, "ply becomes %d\n", ply);
#endif
	}
	break;
    }
    case DO_COST: {
	cost_t cost;

	DEBUG("COST");
	getint(cost.ct_space,codep);
	getint(cost.ct_time,codep);
	totalcost += costcalc(cost);
	CHKCOST();
	break;
    }
#ifdef REGVARS
    case DO_PRETURN: {
	if (toplevel) {
		swtxt();
		regreturn();	/* in mach.c */
	}
	break;
    }
#endif
    case DO_RETURN:
	DEBUG("RETURN");
	assert(origcp!=startupcode);
#ifndef NDEBUG
	level--;
#endif
	return(totalcost);
#ifdef USE_TES
    case DO_LABDEF: {
	int index;

	DEBUG("LABDEF");
	getint(index,codep);
	if (toplevel) {
		swtxt();
		printlabel(index);
	}

	break;
    }
#endif
#ifdef USE_NOFRAMEPOINTER
	case DO_STACKADJUST: {
	result_t result;
	int nodeno;
	
	DEBUG("STACKADJUST");
	/* The offset is an expression, which we need to evaluate. */
	
	getint(nodeno,codep);
	compute(&enodes[nodeno], &result);
	assert(result.e_typ==EV_INT);
	
	if (toplevel)
		stackoffset += result.e_v.e_con;
	break;
	}
#endif
	}
	}
    doreturn:
#ifdef ALLOW_NEXTEM
	if (toplevel && totalcost == INFINITY && ! paniced) {
		DEBUG("PANIC!");
		totalcost += stackupto(&fakestack[stackheight-1], ply, toplevel);
#ifndef NDEBUG
		if (Debug > 2)
			fprintf(stderr, "Stackheight = %d\n", stackheight);
#endif
		paniced = 1;
		tokpatlen = 0;
		goto panic;
	}
#endif
#ifndef NDEBUG
	level--;
#endif
	return(totalcost);
}

readcodebytes() {
#ifndef CODEINC
	register fd;
	extern int ncodebytes;

	if ((fd=open("code",0))<0) {
		error("Can't open code");
	}
	if (read(fd,coderules,ncodebytes)!=ncodebytes) {
		error("Short read from code");
	}
	close(fd);
#endif
}

#ifdef TABLEDEBUG
initlset(f) char *f; {
	extern char *myalloc();

	set_flag = f;
	if ((set_fd=open(f+1,2))<0)
		error("Can't open %s rw",f+1);
	read(set_fd,&set_size,sizeof(int));
	set_val=( short *) myalloc(set_size);
	read(set_fd,set_val,set_size);
}

termlset() {

	if (set_fd) {
		lseek(set_fd,(long) sizeof(int),0);
		write(set_fd,set_val,set_size);
		close(set_fd);
		if (set_flag[0]=='u') {
			register i;
			
			fprintf(stderr,"Unused code rules:\n\n");
			for(i=0;i<8*set_size;i++)
				if(set_val[i>>4]&(1<<(i&017)))
					fprintf(stderr,"\"%s\", line %d\n",tablename,i);
		}
	}
}
#endif