oxccb.c

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

 				case GT|ULONGLONG:
				case GT|LONGDOUBLE:
					pbuf[bufcnt++] = "gt|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case LE|LONGLONG:
				case LE|ULONGLONG:
				case LE|LONGDOUBLE:
					pbuf[bufcnt++] = "le|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case GE|LONGLONG:
				case GE|ULONGLONG:
				case GE|LONGDOUBLE:
					pbuf[bufcnt++] = "ge|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case NE|LONGLONG:
				case NE|ULONGLONG:
				case NE|LONGDOUBLE:
					pbuf[bufcnt++] = "ne|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case EQ|LONGLONG:
				case EQ|ULONGLONG:
				case EQ|LONGDOUBLE:
					pbuf[bufcnt++] = "eq|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case NEG|LONGLONG:
				case NEG|ULONGLONG:
				case NEG|LONGDOUBLE:
					pbuf[bufcnt++] = "neg|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case NOT|BX:
					pbuf[bufcnt++] = "not|BX";
					break;
				case COMP|LONGLONG:
				case COMP|ULONGLONG:
					pbuf[bufcnt++] = "comp|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case RSH|SLONGLONG:
				case RSH|SULONGLONG:
					pbuf[bufcnt++] = "rsh|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;

				case MOD|LONGLONG:
				case MOD|ULONGLONG:
					pbuf[bufcnt++] = "mod|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x03];
					break;
				case RSHI|SLONGLONG:
				case RSHI|SULONGLONG:
					pbuf[bufcnt++] = "rshi|";
					pbuf[bufcnt++] = XTbuf[*pc & 0x07];
					++pc;
					break;
				case TRUTHOF|BX:
					pbuf[bufcnt++] = "truthof|BX";
					break;

				case LS|A1:
				case LS|A2:
				case LS|A3:
					pbuf[bufcnt++] = "xtd ls|";
					pbuf[bufcnt++] = Abuf[(*pc>>2) & 0x03];
					pc += Acnt[(*pc>>2) & 0x03];
					break;

				case LM|A1:
				case LM|A2:
				case LM|A3:
				case LM|A4:
					pbuf[bufcnt++] = "xtd lm|";
					pbuf[bufcnt++] = Abuf[(*pc>>2) & 0x03];
					pc += Acnt[(*pc>>2) & 0x03];
					break;

				case SS|A1:
				case SS|A2:
				case SS|A3:
					pbuf[bufcnt++] = "xtd ss|";
					pbuf[bufcnt++] = Abuf[(*pc>>2) & 0x03];
					pc += Acnt[(*pc>>2) & 0x03];
					break;

				case SM|A1:
				case SM|A2:
				case SM|A3:
				case SM|A4:
					pbuf[bufcnt++] = "xtd sm|";
					pbuf[bufcnt++] = Abuf[(*pc>>2) & 0x03];
					pc += Acnt[(*pc>>2) & 0x03];
					break;

				case MOVSS:
					pbuf[bufcnt++] = "xtd movss";
					++pc;
					pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
					pc += SDcnt[*pc & 0x0f];
					break;
				case MOVSM:
					pbuf[bufcnt++] = "xtd movsm";
					++pc;
					pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
					pc += SDcnt[*pc & 0x0f];
					break;
				case MOVMS:
					pbuf[bufcnt++] = "xtd movms";
					++pc;
					pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
					pc += SDcnt[*pc & 0x0f];
					break;
				case MOVMM:
					pbuf[bufcnt++] = "xtd movmm";
					++pc;
					pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
					pc += SDcnt[*pc & 0x0f];
					break;
			}
			break;
		}/* END: XTD */

		case XOR|B1:
		case XOR|B2:
		case XOR|B4:
		case XOR|B8:
			pbuf[bufcnt++] = "xor|";
			pbuf[bufcnt++] = Bbuf[*pc & 0x03];
			break;

		case GT|BYTE:
		case GT|SHORT:
		case GT|LONG:
		case GT|UBYTE:
		case GT|USHORT:
		case GT|ULONG:
		case GT|FLOAT:
		case GT|DOUBLE:
			pbuf[bufcnt++] = "gt|";
			pbuf[bufcnt++] = Tbuf[*pc & 0x07];
			break;

		case LT|BYTE:
		case LT|SHORT:
		case LT|LONG:
		case LT|UBYTE:
		case LT|USHORT:
		case LT|ULONG:
		case LT|FLOAT:
		case LT|DOUBLE:
			pbuf[bufcnt++] = "lt|";
			pbuf[bufcnt++] = Tbuf[*pc & 0x07];
			break;

		case GE|BYTE:
		case GE|SHORT:
		case GE|LONG:
		case GE|UBYTE:
		case GE|USHORT:
		case GE|ULONG:
		case GE|FLOAT:
		case GE|DOUBLE:
			pbuf[bufcnt++] = "ge|";
			pbuf[bufcnt++] = Tbuf[*pc & 0x07];
			break;

		case LE|BYTE:
		case LE|SHORT:
		case LE|LONG:
		case LE|UBYTE:
		case LE|USHORT:
		case LE|ULONG:
		case LE|FLOAT:
		case LE|DOUBLE:
			pbuf[bufcnt++] = "le|";
			pbuf[bufcnt++] = Tbuf[*pc & 0x07];
			break;

		case NE|BYTE:
		case NE|SHORT:
		case NE|LONG:
		case NE|UBYTE:
		case NE|USHORT:
		case NE|ULONG:
		case NE|FLOAT:
		case NE|DOUBLE:
			pbuf[bufcnt++] = "ne|";
			pbuf[bufcnt++] = Tbuf[*pc & 0x07];
			break;

		case EQ|BYTE:
		case EQ|SHORT:
		case EQ|LONG:
		case EQ|UBYTE:
		case EQ|USHORT:
		case EQ|ULONG:
		case EQ|FLOAT:
		case EQ|DOUBLE:
			pbuf[bufcnt++] = "eq|";
			pbuf[bufcnt++] = Tbuf[*pc & 0x07];
			break;

		case ARG:
			pbuf[bufcnt++] = "arg";
			break;
		case ARGA:
			pbuf[bufcnt++] = "arga";
			break;
		case ARGF:
			pbuf[bufcnt++] = "argf";
			break;

		case MOVSS|B1:
		case MOVSS|B2:
		case MOVSS|B4:
		case MOVSS|B8:
			pbuf[bufcnt++] = "movss|";
			pbuf[bufcnt++] = Bbuf[*pc & 0x03];
			++pc;
			pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
			pc += SDcnt[*pc & 0x0f];
			break;

		case MOVSM|B1:
		case MOVSM|B2:
		case MOVSM|B4:
		case MOVSM|B8:
			pbuf[bufcnt++] = "movsm|";
			pbuf[bufcnt++] = Bbuf[*pc & 0x03];
			++pc;
			pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
			pc += SDcnt[*pc & 0x0f];
			break;

		case MOVMS|B1:
		case MOVMS|B2:
		case MOVMS|B4:
		case MOVMS|B8:
			pbuf[bufcnt++] = "movms|";
			pbuf[bufcnt++] = Bbuf[*pc & 0x03];
			++pc;
			pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
			pc += SDcnt[*pc & 0x0f];
			break;

		case MOVMM|B1:
		case MOVMM|B2:
		case MOVMM|B4:
		case MOVMM|B8:
			pbuf[bufcnt++] = "movmm|";
			pbuf[bufcnt++] = Bbuf[*pc & 0x03];
			++pc;
			pbuf[bufcnt++] = SDbuf[*pc & 0x0f];
			pc += SDcnt[*pc & 0x0f];
			break;

		case DUMP:
			pbuf[bufcnt++] = "dump ";
			break;
		case REGAIN:
			pbuf[bufcnt++] = "regain ";
			break;
		case CALL:
			pbuf[bufcnt++] = "call ";
			break;
		case RET:
			pbuf[bufcnt++] = "ret ";
			break;
		case SWAP:
			pbuf[bufcnt++] = "swap ";
			break;
		case SWAP4:
			pbuf[bufcnt++] = "swap4 ";
			break;
		case SWAP4DEEP:
			pbuf[bufcnt++] = "swap4deep ";
			break;
		case DUP:
			pbuf[bufcnt++] = "dup ";
			break;
		case DUP4:
			pbuf[bufcnt++] = "dup4 ";
			break;
		case ABSMEM:
			pbuf[bufcnt++] = "absmem ";
			break;
		case ABSSTK:
			pbuf[bufcnt++] = "absstk ";
			break;
		case MOVDA1:
			pbuf[bufcnt++] = "movda1 ";
			break;
		case MOVDA2:
			pbuf[bufcnt++] = "movda2 ";
			break;
		case MOVDA4:
			pbuf[bufcnt++] = "movda4 ";
			break;
		case MOVDA8:
			pbuf[bufcnt++] = "movda8 ";
			break;
		case MOVDAX:
			pbuf[bufcnt++] = "movdax ";
			break;
		case MOVAA1:
			pbuf[bufcnt++] = "movaa1 ";
			break;
		case MOVAA2:
			pbuf[bufcnt++] = "movaa2 ";
			break;
		case MOVAA4:
			pbuf[bufcnt++] = "movaa4 ";
			break;
		case MOVAA8:
			pbuf[bufcnt++] = "movaa8 ";
			break;
		case MOVAAX:
			pbuf[bufcnt++] = "movaax ";
			break;
		case MOVAAC:
			pbuf[bufcnt++] = "movaac ";
			break;
		case NOP:
			pbuf[bufcnt++] = "nop ";
			break;
	} /* END: switch(*pc) */
  }/* END: for() */
  for(i = 0; i < bufcnt; ++i)
		fwrite(pbuf[i], 1, strlen(pbuf[i]), iv->outfile);
  fwrite("\n", 1, 1, iv->outfile);
}/* END: printinst() */
static void
disassemble(Piv iv, void *ptr, long size)
{
int x;
long offset = iv->out_offset;

	x = print8(iv, ptr, size, offset, 0);
	printinst(iv, ptr, size);
	while((size -= x) > 0)
	{
		offset += x;
		((char*)ptr) += x;
		x = print8(iv, ptr, size, offset, 1);
	}
}
static void
reset_funcdata(Piv iv)
{
	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;
	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
write_funcdata(Piv iv, unsigned char *pdef)
{
long *p;
	if((p = (long*)iv->obufstart))
	{
		setup_jmps(iv, pdef);
		while(shorten_jmps(iv))
			;
		while(p)
		{
			if(iv->listing_wanted)
			{
				if(((unsigned char*)p)[8] == LINENO)
				{
					printline(iv, &((unsigned char*)p)[9]);
				}
				else if(((unsigned char*)p)[8] == NFUNC)
				{
				char *funcname = *((char**)&(((char*)p)[9]));
					fprintf(iv->outfile, "\n%8.8lx:    .nested .function _%s\n",
					iv->out_offset, funcname);
				}
				else
				{
					disassemble(iv, &p[2], p[1]);
					iv->out_offset += p[1];
				}
			}
			else
			{
				FILEWRITE(&p[2],p[1]);
				iv->out_offset += p[1];
			}
			p = (void*)p[0];
		}
	}
if(iv->debug >= '1')
cfeprintf("MAXDEPTH=%d MINDEPTH=%d func=%s\n",
iv->maxdepth, iv->mindepth, iv->symaddr[GL( ((Pop)pdef)->data )]);

	save_maxdepth(iv, GL( ((Pop)pdef)->data ));
}
static void *
write_obuf(Piv iv, unsigned char *buf, long cnt)
{/* Output first goes to a linked list */
void *next = iv->obuf;

	if(iv->obuf != (unsigned char*)&iv->obufstart)
	{/* Suppress duplicate RETs */
	  if(buf[0] == RET && (iv->obuf[8] == RET || iv->obuf[9] == RETSTRUCT) )
	  {
		return iv->obuf;
	  }
	}
	if(iv->obufcnt >= cnt+8)
	{/* There is sufficient room in the current chunk */
	long size = ((long*)iv->obuf)[1];
	  iv->obuf += size+8;
	}
	else
	{/* Allocate a new chunk of linked list space */
	  iv->obufcnt = 4080;
	  iv->obuf = Ccalloc(FUNCDATA, 1, iv->obufcnt);
	}

	*((void**)next) = iv->obuf;		/* link back to old entry */
	((long*)iv->obuf)[1] = cnt;		/* record the size of the data */
	iv->obufcnt -= cnt+8;			/* deduct data size plus overhead */
	memcpy(&((long*)iv->obuf)[2], buf, cnt);  /* copy the data to this area */
	if(buf[0] != LINENO && buf[0] != NFUNC)
	{/* A line number record is an anomoly */
		if(iv->extmark)
			addto_extlist(iv, buf);		/* reference to external variable here */
		iv->func_offset += cnt;			/* increase the program counter */
	}

	iv->cod->ee = (struct _nodeOBUF *)iv->obuf;	/* points to obuf chunks */
	link_cod(iv);

	return iv->obuf;	/* return the address of this sub chunk */
}
static void
do_conversion(Piv iv, PND dst, PND src)
{
unsigned char obuf[2];
int dsize = dst->size;
int ssize = src->size;
unsigned char ddtype = dst->dtype;
unsigned char sdtype = src->dtype;
#define SRC(a) (a<<4)

	if(src->atype & (A_ABSOLUTE|A_POINTER|A_VALUE) == (A_POINTER|A_VALUE))
	{
		if(src->atype & A_DATA)
			obuf[0] = ABSMEM;
		else if(src->atype & (A_AUTO|A_PARAM))
			obuf[0] = ABSSTK;
		else
			PERROR(pName ":ERROR: Line:%d bad conversion0\n", iv->lastline);
		write_obuf(iv, obuf, 1);
		return;
	}
	obuf[0] = CVT;
	switch(ddtype)
	{
		case	D_SIGNED:			/* dest is signed integer */
		{
			if(dsize == 1)
				obuf[1] = BYTE;
			else if(dsize == 2)
				obuf[1] = SHORT;
			else if(dsize == 4)
				obuf[1] = LONG;
			else if(dsize == 8)
				obuf[1] = CLONGLONG;
			switch(sdtype)
			{
				case D_SIGNED:
				{/* src is signed integer */
					if(dsize <= ssize)
						return;
					if(ssize == 1)
						obuf[1] |= SRC(BYTE);
					else if(ssize == 2)
						obuf[1] |= SRC(SHORT);
					else if(ssize == 4)
						obuf[1] |= SRC(LONG);
					else if(ssize == 8)
						obuf[1] |= SRC(CLONGLONG);
					break;
				}
				case D_UNSIGNED:
				case D_SEGMENT:
				{/* src is unsigned integer */
					if(dsize <= ssize)
						return;
					if(ssize == 1)
						obuf[1] |= SRC(UBYTE);
					else if(ssize == 2)
						obuf[1] |= SRC(USHORT);
					else if(ssize == 4)
						obuf[1] |= SRC(ULONG);
					else if(ssize == 8)
						obuf[1] |= SRC(CULONGLONG);
					break;
				}
				case D_FLOAT:
				{/* src is floating point */
					if(ssize == 4)
						obuf[1] |= SRC(FLOAT);
					else if(ssize == 8)
						obuf[1] |= SRC(DOUBLE);
					else
						obuf[1] |= SRC(CLONGDOUBLE);
					break;
				}
				case D_POINTER:
				case D_FUNCPTR:
				{/* src is unsigned int */
					if(dsize <= ssize)
						return;
					if(ssize == 1)
						obuf[1] |= SRC(UBYTE);
					else if(ssize == 2)
						obuf[1] |= SRC(USHORT);
					else if(ssize == 4)
						obuf[1] |= SRC(ULONG);
					else if(ssize == 8)
						obuf[1] |= SRC(CULONGLONG);
					break;
				}
				default:
					PERROR(pName ":ERROR: Line:%d bad conversion1\n", iv->lastline);
			}
			break;
		}
		case	D_UNSIGNED:	/* dest is unsigned integer */
		case	D_SEGMENT:
		{
			if(dsize == 1)
				obuf[1] = UBYTE;
			else if(dsize == 2)
				obuf[1] = USHORT;
			else if(dsize == 4)
				obuf[1] = ULONG;
			else if(dsize == 8)
				obuf[1] = CULONGLONG;
			switch(sdtype)
			{
				case D_SIGNED:
				{/* src is signed integer */
					if(dsize <= ssize)
						return;
					if(ssize == 1)
						obuf[1] |= SRC(BYTE);
					else if(ssize == 2)
						obuf[1] |= SRC(SHORT);
					else if(ssize == 4)
						obuf[1] |= SRC(LONG);
					else if(ssize == 8)
						obuf[1] |= SRC(CLONGLONG);
					break;
				}
				case D_UNSIGNED:
				case D_SEGMENT:
				{/* src is unsigned integer */
					if(dsize <= ssize)
						return;
					if(ssize == 1)
						obuf[1] |= SRC(UBYTE);
					else if(ssize == 2)
						obuf[1] |= SRC(USHORT);
					else if(ssize == 4)
						obuf[1] |= SRC(ULONG);
					else if(ssize == 8)
						obuf[1] |= SRC(CULONGLONG);
					break;
				}
				case D_FLOAT:
				{/* src is floating point */
					if(ssize == 4)
						obuf[1] |= SRC(FLOAT);
					else if(ssize == 8)
						obuf[1] |= SRC(DOUBLE);
					else
						obuf[1] |= SRC(CLONGDOUBLE);
					break;
				}
				case D_POINTER:
				case D_FUNCPTR:
				{/* src is unsigned integer */