oxccb.c

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

							case BX:
								PERROR(pName ":ERROR: Line:%d invalid integer size\n", iv->lastline);
							default:
								PERROR(pName ":ERROR: Line:%d invalid immediate input\n",iv->lastline);
						}
					case B4:
						switch(mosize)
						{
							case B1:
								*((long*)obuf) = *((char*)ibuf);
								return 4;
							case B2:
								*((long*)obuf) = *((short*)ibuf);
								return 4;
							case B8:
								*((long*)obuf) = *((long*)ibuf);
								return 4;
							case BX:
								PERROR(pName ":ERROR: Line:%d invalid integer size\n", iv->lastline);
							default:
								PERROR(pName ":ERROR: Line:%d invalid immediate input\n", iv->lastline);
						}
					case B8:
					{
					long l[2];
						l[0] = 0;
						l[1] = 0;
						if(mosize == B4)
							l[0] = *((long*)ibuf);
						else if(mosize == B2)
							l[0] = *((short*)ibuf);
						else if(mosize == B1)
							l[0] = *((char*)ibuf);
						else
							PERROR(pName ":ERROR: Line:%d invalid integer size\n", iv->lastline);
						if(l[0] < 0)
							l[1] = -1;
						memcpy(obuf, l, 8);
						return 8;
					}
					default:
					  PERROR(pName ":ERROR: Line:%d invalid integer size=%d\n",
					  	iv->lastline, osize);
				}
			}/* END: signed integer */
		}/* END: osize != mosize */
		/* NOT REACHED */
		PERROR(pName ":ERROR: Line:%d LOAD IMMED SYSERR1 osize=%d mosize=%d\n", iv->lastline, osize, mosize);
		return 0; /* suppress compiler warning */
	}
	else
	{/* generate the shortest possible immediate value */
	int thesize = 0;
		if(dtype == D_FLOAT)
		{
			switch(mosize)
			{
				case	B4:
					*((float*)obuf) = *((float*)ibuf);
					thesize = 4;
					break;
				case	B8:
					*((double*)obuf) = *((double*)ibuf);
					thesize = 8;
					break;
				case	BX:
#if SUPPORT_LONG_DOUBLE
					*((long double*)obuf) = *((long double*)ibuf);
#else
					memcpy(obuf, ibuf, XSZ);
#endif
					thesize = XSZ;
					break;
				default:
					PERROR(pName ":ERROR: Line:%d wrong sized floating immediate\n", iv->lastline);
			}
		}
		else /* dtype not D_FLOAT */
		{
		int negative;
		int sgned;
		unsigned long ul[2];
		long *sl;

			ul[1] = 0;		
			negative = 0;
			sl = ul;
			if(dtype == D_UNSIGNED || dtype == D_POINTER)
			{
				sgned = 0;
				if(mosize == B8)
				{
					ul[0] = *((unsigned long*)ibuf);
					ul[1] = *((unsigned long*)(((char*)ibuf)+4));
				}
				else
				{
					if(mosize == B4)
						ul[0] = *((unsigned long*)ibuf);
					else if(mosize == B2)
						ul[0] = *((unsigned short*)ibuf);
					else if(mosize == B1)
						ul[0] = *((unsigned char*)ibuf);
					else
						PERROR(pName ":ERROR: Line:%d invalid integer immediate\n", iv->lastline);
				}
			}
			else /* sgned */
			{
				sgned = 1;
				if(mosize == B8)
				{
					sl[0] = *((long*)ibuf);
					sl[1] = *((long*)(((char*)ibuf)+4));
					if(sl[1] < 0)
					{
						negative = 1;
						ul[1] = ~ul[1];
						ul[0] = ~ul[0];
						if(ul[0] == 0xffffffff)
						{
							ul[0] = 0;
							ul[1] += 1;
						}
						else ul[0] += 1;
					}
				}
				else
				{
					if(mosize == B4)
						sl[0] = *((long*)ibuf);
					else if(mosize == B2)
						sl[0] = *((short*)ibuf);
					else if(mosize == B1)
						sl[0] = *((char*)ibuf);
					else
						PERROR(pName ":ERROR: Line:%d invalid integer immediate\n",iv->lastline);
					if(sl[0] < 0)
					{
						negative = 1;
						sl[0] = -sl[0];
					}
				}
			} /* END: sgned */
			if(negative)
			{
				if(ul[1])
					mosize = B8;
				else if(ul[0] & 0xffff8000)
					mosize = B4;
				else if(ul[0] & 0xffffff80)
					mosize = B2;
				else
					mosize = B1;
			}
			else
			{
				if(sgned)
				{
					if(ul[1])
						mosize = B8;
					else if(ul[0] & 0xffff8000)
					{
						if(!(ul[0] & 0xffff0000))
						{
							*poc = LUI;
							mosize = B2;
						}
						else
							mosize = B4;
					}
					else if(ul[0] & 0xffffff80)
					{
						if(!(ul[0] & 0xffffff00))
						{
							*poc = LUI;
							mosize = B1;
						}
						else
							mosize = B2;
					}
					else
						mosize = B1;
				}
				else /* unsigned */
				{
					if(ul[1])
						mosize = B8;
					else if(ul[0] & 0xffff0000)
						mosize = B4;
					else if(ul[0] & 0xffffff00)
						mosize = B2;
					else
						mosize = B1;
				}
			}
			if(negative)
			{
				ul[1] = ~ul[1];
				ul[0] = ~ul[0];
				if(ul[0] == 0xffffffff)
				{
					ul[0] = 0;
					ul[1] += 1;
				}
				else ul[0] += 1;
			}
			switch(mosize)
			{
				case B1:
					*((char*)obuf) = *((char*)sl);
					thesize = 1;
					break;
				case B2:
					*((short*)obuf) = *((short*)sl);
					thesize = 2;
					break;
				case B4:
					*((long*)obuf) = *((long*)sl);
					thesize = 4;
					break;
				case B8:
					*((double*)obuf) = *((double*)sl);
					thesize = 8;
					break;
			}
		}/* END: not D_FLOAT */
		*poc |= mosize;
		return thesize;
	}
}
static void
addr_toevalstack(Piv iv, PND pnd)
{
unsigned char obuf[20];
int atype = pnd->atype;

	if(atype & (A_AUTO|A_PARAM|A_DATA))
	{
	int l;
		obuf[0] = LAI;
		l = 1;
		l += load_addr(iv, &obuf[0], &obuf[1], pnd, 0);

		write_obuf(iv, obuf, l);
		if(atype & (A_AUTO|A_PARAM))
		{
			obuf[0] = ABSSTK;
			write_obuf(iv, obuf, 1);
		}
		else if(l < 5)
		{
			obuf[0] = ABSMEM;
			write_obuf(iv, obuf, 1);
		}
		++iv->stackdepth;
	}
}
static void
data_toevalstack(Piv iv, PND pnd, PND dst)
{
unsigned char obuf[20];
int xtra, oc;
unsigned short dtype, atype;
unsigned char osize;

		atype = pnd->atype;
		dtype = pnd->dtype;
		if(atype & A_IMMED)
		{
			if(dtype == D_UNSIGNED)
				obuf[0] = LUI;
			else
				obuf[0] = LI;
			xtra = load_immed(iv, &obuf[0], &obuf[1], pnd, -1);
			write_obuf(iv, obuf, 1+xtra);
			++iv->stackdepth;
			return;
		}
		xtra = oc = 0;
		osize = pnd->opsize;
		if(osize == BX)
		{
			obuf[0] = XTD;
			osize = 0;
			oc = 1;
			xtra = 1;
		}
		if(atype & (A_TEMP|A_RET))
		{
			if(atype & A_MEMADDR)
			{
			unsigned char xsize = get_datasize(0, pnd);
				if(osize == B8 && dtype < D_FLOAT)
					obuf[xtra++] = XTD;

				if(		dst	
					&&	(pnd->TMPNUM == dst->TMPNUM)
					&&	((dst->atype & (A_ABSOLUTE|A_MEMADDR))
							== (A_ABSOLUTE|A_MEMADDR))
				  )
				{/* generally used for a += b etc. */
					obuf[xtra++] = IMMED;
					obuf[xtra] = DEREF1|xsize;
					write_obuf(iv, obuf, 1+xtra);
					++iv->stackdepth;
				}
				else
				{
					obuf[xtra++] = IMMED;
					obuf[xtra] = DEREF|get_datasize(0, pnd);
					write_obuf(iv, obuf, 1+xtra);
				}
				pnd->atype &= ~A_MEMADDR;
				pnd->atype |= A_VALUE;
			}
			return;
		}

		if(atype & (A_AUTO|A_PARAM))
		{
			if(atype & (A_POINTER|A_VALUE) == (A_POINTER|A_VALUE))
			{/* Put address on eval stack */
				addr_toevalstack(iv, pnd);
				pnd->atype |= A_ABSOLUTE;
				return;
			}
			else
			{
				obuf[oc] = LS|osize;
				xtra += load_addr(iv, &obuf[oc], &obuf[oc+1], pnd, 2);
				++iv->stackdepth;
			}
		}
		else if(atype & A_DATA)
		{
			if(atype & (A_POINTER|A_VALUE) == (A_POINTER|A_VALUE))
			{/* Put address on eval stack */
				addr_toevalstack(iv, pnd);
				pnd->atype |= A_ABSOLUTE;
				return;
			}
			else
			{
				obuf[oc] = LM|osize;
				xtra += load_addr(iv,&obuf[oc], &obuf[oc+1], pnd, 2);
				++iv->stackdepth;
			}
		}
		write_obuf(iv, obuf, 1+xtra);
}
static void
promote_arg(Piv iv, PND pnd, long argsize)
{
long dsize = pnd->size;
struct _nd dst;

	if(dsize != argsize)
	{
		dst.size = argsize;
		dst.dtype = pnd->dtype;
		dst.atype = 0;
		do_conversion(iv, &dst, pnd);
	}
}
static unsigned char
arg_toevalstack(Piv iv, PND pnd, long argsize)
{
unsigned char dtype;

	if(pnd->atype & A_IMMED)
	{
		data_toevalstack(iv, pnd, 0);
		return ARG;
	}
	dtype = pnd->dtype;
	if(dtype == D_STRUCT)
	{
		addr_toevalstack(iv, pnd);
		return ARGA;
	}
	else if(dtype == D_FUNCTION)
	{
		addr_toevalstack(iv, pnd);
		return ARGF;
	}
	else if(dtype == D_FUNCPTR)
	{
		data_toevalstack(iv, pnd, 0);
		return ARGF;
	}
	else if(dtype == D_ARRAY)
	{
		addr_toevalstack(iv, pnd);
	}
	else
	{
		data_toevalstack(iv, pnd, 0);
		promote_arg(iv, pnd, argsize);
	}
	return ARG;
}
static void
mov_esdata(Piv iv, unsigned short atype, int size)
{
unsigned char obuf[2];

	if(atype & A_MEMADDR)
	{
		if(size == B1)
			obuf[0] = MOVAA1;
		else if(size == B2)
			obuf[0] = MOVAA2;
		else if(size == B4)
			obuf[0] = MOVAA4;
		else if(size == B8)
			obuf[0] = MOVAA8;
#if SUPPORT_LONG_DOUBLE
		else if(size == BX)
			obuf[0] = MOVAAX;
#endif
		else {obuf[0] = MOVAAC; size = XSZ;}
	}
	else
	{
		if(size == B1)
			obuf[0] = MOVDA1;
		else if(size == B2)
			obuf[0] = MOVDA2;
		else if(size == B4)
			obuf[0] = MOVDA4;
		else if(size == B8)
			obuf[0] = MOVDA8;
#if SUPPORT_LONG_DOUBLE
		else if(size == BX)
			obuf[0] = MOVDAX;
#endif
		else
			PERROR(pName ":ERROR: Line:%d illegal mov data size=%d\n", iv->lastline, size);
	}
	if(obuf[0] == MOVAAC)
	{
		load_val(iv, size);
		--iv->stackdepth;
	}
	write_obuf(iv, obuf, 1);	
	iv->stackdepth -= 2;
}
static void
from_evalstack(Piv iv, PND d, PND s)
{
unsigned char obuf[20];
int xtra, oc;
unsigned short datype = d->atype;
unsigned char osize = d->opsize;

	xtra = oc = 0;

	if(datype & (A_TEMP|A_RET))
	{
		if(datype & A_MEMADDR)
		{
			mov_esdata(iv, s->atype, osize);
		}
		return;
	}

	if(osize == BX)
	{
		obuf[0] = XTD;
		oc = 1;
		osize = 0;
		xtra = 1;
	}
	if(datype & (A_AUTO|A_PARAM))
	{
		obuf[oc] = SS|osize;
		xtra += load_addr(iv, &obuf[oc], &obuf[oc+1], d, 2);
		--iv->stackdepth;
	}
	else if(datype & OPDATA)
	{
		obuf[oc] = SM|osize;
		xtra += load_addr(iv, &obuf[oc], &obuf[oc+1], d, 2);
		--iv->stackdepth;
	}
	write_obuf(iv, obuf, 1+xtra);
}
static unsigned char
get_datasize(unsigned char opcode, PND pnd)
{
unsigned char dtype = pnd->dtype;
long dsize = pnd->size;

	switch(dtype)
	{
		case	D_ARRAY:
		case	D_FUNCTION:
		case	D_STRUCT:
			return LONG;
	}

	if(		opcode == orop
		||	opcode == andop
		||	opcode == notop
		||	opcode == lshop
		||	opcode == complop
		||	opcode == xorop
		)
	{
		if(dsize == 1)
			return B1;
		else if(dsize == 2)
			return B2;
		else if(dsize == 4)
			return B4;
		else if(dsize == 8)
			return B8;		
		else
			return BX;
	}
	else
	{
		if(dtype == D_UNSIGNED)
		{
			if(dsize == 1)
				return UBYTE;
			else if(dsize == 2)
				return USHORT;
			else if(dsize == 4)
				return ULONG;
			else
			{
				if(opcode == rshop)
					return SULONGLONG;
				return ULONGLONG;
			}
		}
		else if(dtype == D_FLOAT)
		{
			if(dsize == 4)
				return FLOAT;
			else if(dsize == 8)
				return DOUBLE;
			else
				return LONGDOUBLE;
		}
		else
		{
			if(dsize == 1)
				return BYTE;
			else if(dsize == 2)
				return SHORT;
			else if(dsize == 4)
				return LONG;
			else
			{
				if(opcode == rshop)
					return SLONGLONG;
				return LONGLONG;
			}
		}
	}
	return 0;
}
static void *
new_nodeO(Piv iv)
{
PNODEO p;

	if(iv->ob_bufcnt < sizeof(NODEO))
	{/* Allocate a new chunk of linked list space */
	  iv->ob_bufcnt = 4080;
	  iv->ob_buf = Ccalloc(FUNCDATA, 1, iv->ob_bufcnt);
	}
	p = (PNODEO)iv->ob_buf;
	iv->ob_buf += sizeof(NODEO);
	iv->ob_bufcnt -= sizeof(NODEO);
	return p;	
}
static void
link_ob(Piv iv)
{/* Attach to the used list */

	if(!iv->ob_usedhead)
	{
		iv->ob_usedhead = iv->ob;
		iv->ob_usedtail = iv->ob;
	}
	else
	{
		iv->ob_usedtail->next = iv->ob;
		iv->ob_usedtail = iv->ob;
	}
	iv->ob = new_nodeO(iv);
}
static void *
new_nodeC(Piv iv)
{
PNODEC p;

	if(iv->cod_bufcnt < sizeof(NODEC))
	{/* Allocate a new chunk of linked list space */
	  iv->cod_bufcnt = 4080;
	  iv-