oxccai.c

OXCC is a multipass, interpreting C compiler with several language extensions. It generates an Archi

	return ((Pop)q)->next;
}
static void *
do_compound(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_unop(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_expr(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	if(iv->debug >= '2')
		cfeprintf("EXPR inst(%u) `%s'\n", *p, oxgenops[*p]);

	while(p < q)
	{
		switch(*p)
		{
			case	arrayelemop:
				p = do_arrayelem(iv, p);
				break;
			case	funcallop:
				p = do_funcall(iv, p);
				break;
			case	condop:
				p = do_cond(iv, p);
				break;
			case	twopathop:
				p = do_twopath(iv, p);
				break;
			case	logicalop:
				p = do_logical(iv, p);
				break;
			case	binopop:
				p = do_binop(iv, p);
				break;
			case	strelemop:
				p = do_strelem(iv, p);
				break;
			case	ptrelemop:
				p = do_ptrelem(iv, p);
				break;
			case	argloadop:
				p = do_argload(iv, p);
				break;
			case	preincrdecop:
				p = do_preincr(iv, p);
				break;
			case	postincrdecop:
				p = do_postincr(iv, p);
				break;
			case	compoundop:
				p = do_compound(iv, p);
				break;
			case	unopop:
				p = do_unop(iv, p);
				break;
				p = POP->next;
				break;
			default:
				p = do_something(iv, p);
				break;
		}
	}
	return ((Pop)q)->next;
}
static void *
do_expstmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return q;
}
static void *
do_ifstmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_ifelsestmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_switchstmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_whilestmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_dostmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_forstmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_asmstmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_initstmt(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_anfblock(Piv iv, unsigned char *p)
{
unsigned char *q = skip_bracket(p);

	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
	return ((Pop)q)->next;
}
static void *
do_stmt(Piv iv, unsigned char *p)
{
void *q;

	if(iv->debug >= '2')
		cfeprintf("STMT inst(%u) `%s'\n", *p, oxgenops[*p]);

	q = POP->next;
	switch(*p)
	{
		case labelop:
			ENCODE(LABEL, dat: GL(POP->data));
			break;
		case gfuncdefop:
		case sfuncdefop:
		case funcexitop:
			PERROR(pName ":ERROR: Malformed input file1=%u=%p",*p, p);
			break;
		case nestedfuncdefop:
		{
#if 0
			if(iv->listing_wanted)
			{
				obuf[0] = NFUNC;
				*((char**)&obuf[1]) = iv->symaddr[GS(POPI->funcdef.symnum)];
				link_ob(iv);
			}
#endif
			iv->numnested += 1;
			break;
		}
		case nestedfuncexitop:
		{
			break;		
		}
		case anfblockop:
			q = do_anfblock(iv, p);
			break;
		case expstmtop:
			q = do_expstmt(iv, p);
			break;
		case ifstmtop:
			q = do_ifstmt(iv, p);
			break;
		case ifelsestmtop:
			q = do_ifelsestmt(iv, p);
			break;
		case switchstmtop:
			q = do_switchstmt(iv, p);
			break;
		case whilestmtop:
			q = do_whilestmt(iv, p);
			break;
		case dostmtop:
			q = do_dostmt(iv, p);
			break;
		case forstmtop:
			q = do_forstmt(iv, p);
			break;
		case asmstmtop:
			q = do_asmstmt(iv, p);
			break;
		case initstmtop:
			q = do_initstmt(iv, p);
			break;
		case lineop:
			iv->lastline = GL(POP->data);
			ENCODE(LINE, dat: iv->lastline);
			break;
		default:
			break;
	}
	return q;
}
static void *
do_something(Piv iv, unsigned char *p)
{

	if(*p < labelop)
		return decode_anf(iv, p);
	else if(*p >= condop && *p <= unopop)
		return do_expr(iv, p);
	else
		return do_stmt(iv, p);
}
static void
do_bracket(Piv iv, unsigned char *p, unsigned char *q)
{
	p = POP->next;
	while(p < q)
	{
	  p = do_something(iv, p);
	}
}
static void
dump_unix_codes(Piv iv)
{
PNODEC pcod = iv->cod_usedhead;

	while((pcod = pcod->next))
	{
	PNODEE p = &pcod->ee;
	  if(p->inst)
	  {
		if(p->inst > ENDCODES)
		{
			switch(p->inst)
			{
				case	ALIGN:
				{
					DUMP("\t.align %d", p->size);
					if(p->dat)
						DUMP(",0x%lx", p->dat);
					QDUMPC('\n');
					break;
				}
				case	PUSHREGS:
				{
				int bits = p->dat;
				int which = 31;
					while(bits)
					{
						if(bits & 0x80000000)
							DUMP("\tpushl\t%s\n", udatnames[which]);
						bits <<= 1;
						--which;
					}
					break;
				}
				case	POPREGS:
				{
				int bits = p->dat;
				int which = 0;
					while(bits)
					{
						if(bits & 1)
							DUMP("\tpopl\t%s\n", udatnames[which]);
						bits >>= 1;
						++which;
					}
					break;
				}
				case	LABEL:
				{
					DUMP("L%lu:\n", p->dat);
					break;
				}
				case	LINE:
				{
					DUMP("//LINE:%lu\n", p->dat);
					break;
				}
				case	FUNCNAME:
				{
					DUMP("_%s:\n", (char*)p->ptr);
					break;
				}
				case LINEFEED:
				{
					QDUMPC('\n');
					break;
				}
				default:
					break;
			}
		}
		else
		{
			QDUMPC('\t');
			QDUMP(opnames[p->inst]);
			QDUMPC(uwordsize[p->size]);
			if(p->s1)
			{
				QDUMPC('\t');
				if(p->s1 == CONST)
				{
					DUMP("$%ld",p->dat);
				}
				else if(p->s1 == VARNAME)
				{
					QDUMPC('_');
					QDUMP(p->ptr);
				}
				else if(p->s1 == LOCATION)
				{
					DUMP("L%lu", p->dat);
				}
				else
				{
					if(p->s1m & INDIRECT)
						QDUMPC('*');
					if(p->s1m & INDEXED)
					{
						if(p->dat)
							DUMP("%ld(", p->dat);
						else
							QDUMPC('(');
					}
					QDUMP(udatnames[p->s1]);
					if(p->s1m & INDEXED)
						QDUMPC(')');
				}
			}
			if(p->d1)
			{
				if(p->s1)
					QDUMPC(',');
				else
					QDUMPC('\t');
				if(p->d1 == CONST)
				{
					DUMP("$%ld",p->dat);
				}
				else if(p->d1 == VARNAME)
				{
					QDUMPC('_');
					QDUMP(p->ptr);
				}
				else
				{
					if(p->d1m & INDIRECT)
						QDUMPC('*');
					if(p->d1m & INDEXED)
					{
						if(p->dat)
							DUMP("%ld(", p->dat);
						else
							QDUMPC('(');
					}
					QDUMP(udatnames[p->d1]);
					if(p->d1m & INDEXED)
						QDUMPC(')');
				}
			}	
			QDUMPC('\n');
		} /* END: < ENDCODES */
	  }/* END: if(p->inst) */
	}/* END: while(pcod->next) */
}
static void
start_unix_func(Piv iv, unsigned char *p)
{
char *funcname = iv->symaddr[GS(POPI->funcdef.symnum)];
int autosize = GL(POPI->funcdef.hidden_offset);
int tempmax = GS(POPI->funcdef.tempmax);
int stksiz = autosize + (tempmax*8);

	iv->regsave = 0;
	iv->botlabel = ++iv->lastlabel;
	iv->stksiz = stksiz;

	ENCODE(ALIGN, 2);
	ENCODE(FUNCNAME, ptr: funcname);
	ENCODE(push, LWORD, s1: ESP);
	ENCODE(mov, LWORD, s1: ESP, d1: EBP);
	ENCODE(PUSHREGS, LWORD);
	iv->regcode = iv->cod_usedtail;
	if(stksiz > 0)
		ENCODE(sub, LWORD, s1: CONST, d1: ESP, dat: stksiz);
}
static int
count_bits(int bits)
{
int cnt = 0;
	if(bits)
	{
		while(bits)
		{
			if(bits & 1)
				++cnt;
			bits >>= 1;
		}
	}
	return cnt;
}
static void
end_unix_func(Piv iv, unsigned char *p)
{
	ENCODE(LABEL, dat: iv->botlabel);
	if(iv->regsave)
	{
	int savcnt = count_bits(iv->regsave);

		iv->regcode->ee.dat = iv->regsave;
		if(iv->stksiz)
		  ENCODE(lea, LWORD, s1: EBP, s1m: INDEXED, d1: ESP, dat: -(4*savcnt));
		ENCODE(POPREGS, LWORD, dat: iv->regsave);
	}
	ENCODE(leave);
	ENCODE(ret);
	ENCODE(LINEFEED);

	dump_unix_codes(iv);
}
static void
reset_funcdata(Piv iv)
{
#if 0
	iv->obuf = (char*)&iv->obufstart;
	iv->obufstart = 0;
	iv->obufcnt = 0;
	iv->func_offset = 0;
	iv->jbuf = (PJL)&iv->jbufstart;
	iv->jmpcnt = 0;
	iv->jbufcnt = 0;
	iv->jbufstart = 0;
	iv->extbuf = (PEL)&iv->extbufstart;
	iv->extcnt = 0;
	iv->extbufcnt = 0;
	iv->extbufstart = 0;
	iv->stackdepth = 0;
	iv->maxdepth = 0;
	iv->mindepth = 0;
#endif
	iv->numnested = 0;
	iv->cod_bufcnt = 0;
	iv->ob_bufcnt = 0;
	iv->cod_usedhead = 0;
	iv->ob_usedhead = 0;
	iv->first_cod = 0;
	iv->first_ob = 0;
	Cfreecat(FUNCDATA);
}
static void *
dumpa_unix_func(Piv iv, unsigned char *p)
{
	iv->ob = new_nodeO(iv);		/* setup first intermediate output node */
	link_ob(iv);				/* null node never unlinked */
	iv->first_ob = iv->ob_usedtail;

	iv->cod = new_nodeC(iv);	/* setup first code node */
	link_cod(iv);				/* null node never unlinked */
	iv->first_cod = iv->cod_usedtail;

	start_unix_func(iv, p);
	if((p = POP->next))
	{
		for(;;)
		{
			if(*p == funcexitop)
			{
				end_unix_func(iv, p);
				break;
			}
			else
				p = do_something(iv, p);
		}
	}
	reset_funcdata(iv);
	return p;
}
static int
isa_reloc_loc(Piv iv, long offset, char **psymb, int *poffs)
{
long key[2];
struct _rval *vp;
struct _dval *dp;
unsigned char *p;
Pafile pf;

	key[0] = offset;
	key[1] = 0;
	if(SymFind(iv->newreloctbl, &key, &vp))
	{
		p = vp->p;
		pf = iv->files[vp->fileno];
		*poffs = vp->offset;
		if(*p == extlocop)
		{
			if(vp->rsym <= 0)
				return 0;
			*psymb = pf->symaddr[vp->rsym];
			return 1;
		}
		else
		{
			key[0] = vp->base;
			if(SymFind(iv->datatbl, &key, &dp))
			{
				p = dp->p;
				switch(*p)
				{
					case	datablockop:
					case	bssblockop:
					case	thunkblockop:
						*psymb = pf->symaddr[GS(POPI->s.symnum)];
						return 1;
					case	mallocblockop:
					case	stringblockop:
						*psymb = (void*)vp->base; /* must concoct a symbol */
						return 2;
				}
			}
			return 0;
		}
	}
	return 0;
}
static void
dump_unix_header(Piv iv)
{
	DUMP("\t.file\t\"%s\"\n_oxcc_compiled:\n\n",
		filenameof(iv->symaddr[1]));
}
static void
dump_unix_globals(Piv iv)
{
	if(SymHead(iv->gbltbl))
	{
		while(SymNext(iv->gbltbl))
		{
		struct _gloval *valp;
		unsigned char opcode;

			SymValue(iv->gbltbl, &valp);
			if((opcode = *(valp->p)))
			{
				if(opcode == glodatop || opcode == glofuncop)
				{
					DUMP(".globl _%s\n", valp->symname);
				}			
			}
		}
	}
}
static void
dump_unix_bss(Piv iv)
{