bterp.c

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

			TRUTH_ES1;
#endif
		case CVT:
		{
			++pc;
			++np;
			switch(*pc)
			{
				case SRC(BYTE)|SHORT:
					*((short*)es) = *((char*)es);
					break;
				case SRC(BYTE)|LONG:
					*((long*)es) = *((char*)es);
					break;
				case SRC(BYTE)|USHORT:
					*((unsigned short*)es) = *((char*)es);
					break;
				case SRC(BYTE)|ULONG:
					*((unsigned long*)es) = *((char*)es);
					break;
				case SRC(BYTE)|FLOAT:
					*((float*)es) = *((char*)es);
					break;
				case SRC(BYTE)|DOUBLE:
					*((double*)es) = *((char*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(BYTE)|CLONGLONG:
					*((long long*)es) = *((char*)es);
					break;
				case SRC(BYTE)|CULONGLONG:
					*((unsigned long long*)es) = *((char*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(BYTE)|CLONGDOUBLE:
					*((long double*)es) = *((char*)es);
					break;
#endif
				case SRC(SHORT)|LONG:
					*((long*)es) = *((short*)es);
					break;
				case SRC(SHORT)|ULONG:
					*((unsigned long*)es) = *((short*)es);
					break;
				case SRC(SHORT)|FLOAT:
					*((float*)es) = *((short*)es);
					break;
				case SRC(SHORT)|DOUBLE:
					*((double*)es) = *((short*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(SHORT)|CLONGLONG:
					*((long long*)es) = *((short*)es);
					break;
				case SRC(SHORT)|CULONGLONG:
					*((unsigned long long*)es) = *((short*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(SHORT)|CLONGDOUBLE:
					*((long double*)es) = *((short*)es);
					break;
#endif
				case SRC(LONG)|FLOAT:
					*((float*)es) = *((long*)es);
					break;
				case SRC(LONG)|DOUBLE:
					*((double*)es) = *((long*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(LONG)|CLONGLONG:
					*((long long*)es) = *((long*)es);
					break;
				case SRC(LONG)|CULONGLONG:
					*((unsigned long long*)es) = *((long*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(LONG)|CLONGDOUBLE:
					*((long double*)es) = *((long*)es);
					break;
#endif
				case SRC(UBYTE)|SHORT:
					*((short*)es) = *((unsigned char*)es);
					break;
				case SRC(UBYTE)|LONG:
					*((long*)es) = *((unsigned char*)es);
					break;
				case SRC(UBYTE)|USHORT:
					*((unsigned short*)es) = *((unsigned char*)es);
					break;
				case SRC(UBYTE)|ULONG:
					*((unsigned long*)es) = *((unsigned char*)es);
					break;
				case SRC(UBYTE)|FLOAT:
					*((float*)es) = *((unsigned char*)es);
					break;
				case SRC(UBYTE)|DOUBLE:
					*((double*)es) = *((unsigned char*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(UBYTE)|CLONGLONG:
					*((long long*)es) = *((unsigned char*)es);
					break;
				case SRC(UBYTE)|CULONGLONG:
					*((unsigned long long*)es) = *((unsigned char*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(UBYTE)|CLONGDOUBLE:
					*((long double*)es) = *((unsigned char*)es);
					break;
#endif
				case SRC(USHORT)|LONG:
					*((long*)es) = *((unsigned short*)es);
					break;
				case SRC(USHORT)|ULONG:
					*((unsigned long*)es) = *((unsigned short*)es);
					break;
				case SRC(USHORT)|FLOAT:
					*((float*)es) = *((unsigned short*)es);
					break;
				case SRC(USHORT)|DOUBLE:
					*((double*)es) = *((unsigned short*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(USHORT)|CLONGLONG:
					*((long long*)es) = *((unsigned short*)es);
					break;
				case SRC(USHORT)|CULONGLONG:
					*((unsigned long long*)es) = *((unsigned short*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(USHORT)|CLONGDOUBLE:
					*((long double*)es) = *((unsigned short*)es);
					break;
#endif
				case SRC(ULONG)|FLOAT:
					*((float*)es) = *((unsigned long*)es);
					break;
				case SRC(ULONG)|DOUBLE:
					*((double*)es) = *((unsigned long*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(ULONG)|CLONGLONG:
					*((long long*)es) = *((unsigned long*)es);
					break;
				case SRC(ULONG)|CULONGLONG:
					*((unsigned long long*)es) = *((unsigned long*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(ULONG)|CLONGDOUBLE:
					*((long double*)es) = *((unsigned long*)es);
					break;
#endif
				case SRC(FLOAT)|BYTE:
					*((char*)es) = *((float*)es);
					break;
				case SRC(FLOAT)|SHORT:
					*((short*)es) = *((float*)es);
					break;
				case SRC(FLOAT)|LONG:
					*((long*)es) = *((float*)es);
					break;
				case SRC(FLOAT)|UBYTE:
					*((unsigned char*)es) = *((float*)es);
					break;
				case SRC(FLOAT)|USHORT:
					*((unsigned short*)es) = *((float*)es);
					break;
				case SRC(FLOAT)|ULONG:
					*((unsigned long*)es) = *((float*)es);
					break;
				case SRC(FLOAT)|DOUBLE:
					*((double*)es) = *((float*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(FLOAT)|CLONGLONG:
					*((long long*)es) = *((float*)es);
					break;
				case SRC(FLOAT)|CULONGLONG:
					*((unsigned long long*)es) = *((float*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(FLOAT)|CLONGDOUBLE:
					*((long double*)es) = *((float*)es);
					break;
#endif
				case SRC(DOUBLE)|BYTE:
					*((char*)es) = *((double*)es);
					break;
				case SRC(DOUBLE)|SHORT:
					*((short*)es) = *((double*)es);
					break;
				case SRC(DOUBLE)|LONG:
					*((long*)es) = *((double*)es);
					break;
				case SRC(DOUBLE)|UBYTE:
					*((unsigned char*)es) = *((double*)es);
					break;
				case SRC(DOUBLE)|USHORT:
					*((unsigned short*)es) = *((double*)es);
					break;
				case SRC(DOUBLE)|ULONG:
					*((unsigned long*)es) = *((double*)es);
					break;
				case SRC(DOUBLE)|FLOAT:
					*((float*)es) = *((double*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(DOUBLE)|CLONGLONG:
					*((long long*)es) = *((double*)es);
					break;
				case SRC(DOUBLE)|CULONGLONG:
					*((unsigned long long*)es) = *((double*)es);
					break;
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(DOUBLE)|CLONGDOUBLE:
					*((long double*)es) = *((double*)es);
					break;
#endif
#if SUPPORT_LONG_LONG
				case SRC(CLONGLONG)|FLOAT:
					*((float*)es) = *((long long*)es);
					break;
				case SRC(CLONGLONG)|DOUBLE:
					*((double*)es) = *((long long*)es);
					break;
#if SUPPORT_LONG_DOUBLE
				case SRC(CLONGLONG)|CLONGDOUBLE:
					*((long double*)es) = *((long long*)es);
					break;
#endif
				case SRC(CULONGLONG)|FLOAT:
					*((float*)es) = *((unsigned long long*)es);
					break;
				case SRC(CULONGLONG)|DOUBLE:
					*((double*)es) = *((unsigned long long*)es);
					break;
#if SUPPORT_LONG_DOUBLE
				case SRC(CULONGLONG)|CLONGDOUBLE:
					*((long double*)es) = *((unsigned long long*)es);
					break;
#endif
#endif
#if SUPPORT_LONG_DOUBLE
				case SRC(CLONGDOUBLE)|BYTE:
					*((char*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|SHORT:
					*((short*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|LONG:
					*((long*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|UBYTE:
					*((unsigned char*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|USHORT:
					*((unsigned short*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|ULONG:
					*((unsigned long*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|FLOAT:
					*((float*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|DOUBLE:
					*((double*)es) = *((long double*)es);
					break;
#if SUPPORT_LONG_LONG
				case SRC(CLONGDOUBLE)|CLONGLONG:
					*((long long*)es) = *((long double*)es);
					break;
				case SRC(CLONGDOUBLE)|CULONGLONG:
					*((unsigned long long*)es) = *((long double*)es);
					break;
#endif
#endif
			}
			break;
		}
		case IMMED:
		{
			++pc;
			++np;
			switch(*pc)
			{

				case SMI|A1|B1:
					STORMEMI1(char);
				case SMI|A1|B2:
					STORMEMI1(short);
				case SMI|A1|B4:
					STORMEMI1(long);
				case SMI|A1|B8:
					STORMEMI1(double);
				case SMI|A2|B1:
					STORMEMI2(char);
				case SMI|A2|B2:
					STORMEMI2(short);
				case SMI|A2|B4:
					STORMEMI2(long);
				case SMI|A2|B8:
					STORMEMI2(double);
				case SMI|A3|B1:
					STORMEMI3(char);
				case SMI|A3|B2:
					STORMEMI3(short);
				case SMI|A3|B4:
					STORMEMI3(long);
				case SMI|A3|B8:
					STORMEMI3(double);
				case SMI|A4|B1:
					STORMEMI4(char);
				case SMI|A4|B2:
					STORMEMI4(short);
				case SMI|A4|B4:
					STORMEMI4(long);
				case SMI|A4|B8:
					STORMEMI4(double);

				case SSI|A1|B1:
					STORSTKI1(char);
				case SSI|A1|B2:
					STORSTKI1(short);
				case SSI|A1|B4:
					STORSTKI1(long);
				case SSI|A1|B8:
					STORSTKI1(double);
				case SSI|A2|B1:
					STORSTKI2(char);
				case SSI|A2|B2:
					STORSTKI2(short);
				case SSI|A2|B4:
					STORSTKI2(long);
				case SSI|A2|B8:
					STORSTKI2(double);
				case SSI|A3|B1:
					STORSTKI3(char);
				case SSI|A3|B2:
					STORSTKI3(short);
				case SSI|A3|B4:
					STORSTKI3(long);
				case SSI|A3|B8:
					STORSTKI3(double);

				case MODI|BYTE:
					MODI_ES(char);
				case MODI|SHORT:
					MODI_ES(short);
				case MODI|LONG:
					MODI_ES(long);
				case MODI|UBYTE:
					MODI_ES(unsigned char);
				case MODI|USHORT:
					MODI_ES(unsigned short);
				case MODI|ULONG:
					MODI_ES(unsigned long);

				case DEREF|BYTE:
					DEREF_ES(char);
				case DEREF|SHORT:
					DEREF_ES(short);
				case DEREF|LONG:
					DEREF_ES(long);
				case DEREF|UBYTE:
					UDEREF_ES(unsigned char);
				case DEREF|USHORT:
					UDEREF_ES(unsigned short);
				case DEREF|ULONG:
					UDEREF_ES(unsigned long);
				case DEREF|FLOAT:
					FDEREF_ES(float);
				case DEREF|DOUBLE:
					FDEREF_ES(double);

				case DEREF1|BYTE:
					DEREF1_ES(char);
				case DEREF1|SHORT:
					DEREF1_ES(short);
				case DEREF1|LONG:
					DEREF1_ES(long);
				case DEREF1|UBYTE:
					UDEREF1_ES(unsigned char);
				case DEREF1|USHORT:
					UDEREF1_ES(unsigned short);
				case DEREF1|ULONG:
					UDEREF1_ES(unsigned long);
				case DEREF1|FLOAT:
					FDEREF1_ES(float);
				case DEREF1|DOUBLE:
					FDEREF1_ES(double);
			}
			break;
		}
		case LI|B1:
			LOADI1();
		case LI|B2:
			LOADI2();
		case LI|B4:
			LOADI4();
		case LI|B8:
			LOADI8();
		case LAI|D1:
			LOADADDRI1();
		case LAI|D2:
			LOADADDRI2();
		case LAI|D3:
			LOADADDRI3();
		case LAI|D4:
			LOADADDRI4();

		case LUI|B1:
			LOADUI1();
		case LUI|B2:
			LOADUI2();
		case LUI|B4:
			LOADUI4();
		case LUI|B8:
			LOADI8();

		case SM|A1|B1:
			STORMEM1(char);
		case SM|A1|B2:
			STORMEM1(short);
		case SM|A1|B4:
			STORMEM1(long);
		case SM|A1|B8:
			STORMEM1(double);
		case SM|A2|B1:
			STORMEM2(char);
		case SM|A2|B2:
			STORMEM2(short);
		case SM|A2|B4:
			STORMEM2(long);
		case SM|A2|B8:
			STORMEM2(double);
		case SM|A3|B1:
			STORMEM3(char);
		case SM|A3|B2:
			STORMEM3(short);
		case SM|A3|B4:
			STORMEM3(long);
		case SM|A3|B8:
			STORMEM3(double);
		case SM|A4|B1:
			STORMEM4(char);
		case SM|A4|B2:
			STORMEM4(short);
		case SM|A4|B4:
			STORMEM4(long);
		case SM|A4|B8:
			STORMEM4(double);


		case ADD|BYTE:
			ADD_ES(char);
		case ADD|SHORT:
			ADD_ES(short);
		case ADD|LONG:
			ADD_ES(long);
		case ADD|UBYTE:
			ADD_ES(unsigned char);
		case ADD|USHORT:
			ADD_ES(unsigned short);
		case ADD|ULONG:
			ADD_ES(unsigned long);
		case ADD|FLOAT:
			ADD_ES(float);
		case ADD|DOUBLE:
			ADD_ES(double);

		case SUB|BYTE:
			SUB_ES(char);
		case SUB|SHORT:
			SUB_ES(short);
		case SUB|LONG:
			SUB_ES(long);
		case SUB|UBYTE:
			SUB_ES(unsigned char);
		case SUB|USHORT:
			SUB_ES(unsigned short);
		case SUB|ULONG:
			SUB_ES(unsigned long);
		case SUB|FLOAT:
			SUB_ES(float);
		case SUB|DOUBLE:
			SUB_ES(double);

		case MUL|BYTE:
			MUL_ES(char);
		case MUL|SHORT:
			MUL_ES(short);
		case MUL|LONG:
			MUL_ES(long);
		case MUL|UBYTE:
			MUL_ES(unsigned char);
		case MUL|USHORT:
			MUL_ES(unsigned short);
		case MUL|ULONG:
			MUL_ES(unsigned long);
		case MUL|FLOAT:
			MUL_ES(float);
		case MUL|DOUBLE:
			MUL_ES(double);

		case DIV|BYTE:
			DIV_ES(char);
		case DIV|SHORT:
			DIV_ES(short);
		case DIV|LONG:
			DIV_ES(long);
		case DIV|UBYTE:
			DIV_ES(unsigned char);
		case DIV|USHORT:
			DIV_ES(unsigned short);
		case DIV|ULONG:
			DIV_ES(unsigned long);
		case DIV|FLOAT:
			DIV_ES(float);
		case DIV|DOUBLE:
			DIV_ES(double);

		case OR|B1:
			OR_ES(unsigned char);
		case OR|B2:
			OR_ES(unsigned short);