X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=expr.c;h=a0f6f9f49494d8ea96f55aee4a6f831ba50a348e;hp=4c4168f4a0c543eb45179a5ac376ff2337f8dc7c;hb=582df8950c285e1746d0c4a9e3ead6545c962dc8;hpb=a29cbeceeadc92ff48ffa70a51135b503c96cc6d

diff --git a/expr.c b/expr.c
index 4c4168f..a0f6f9f 100644
--- a/expr.c
+++ b/expr.c
@@ -1,7 +1,7 @@
 //
-// RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
+// RMAC - Reboot's Macro Assembler for all Atari computers
 // EXPR.C - Expression Analyzer
-// Copyright (C) 199x Landon Dyer, 2017 Reboot and Friends
+// Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends
 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
 // Source utilised with the kind permission of Landon Dyer
 //
@@ -23,13 +23,13 @@
 // N.B.: The size of tokenClass should be identical to the largest value of
 //       a token; we're assuming 256 but not 100% sure!
 static char tokenClass[256];		// Generated table of token classes
-static VALUE evstk[EVSTACKSIZE];	// Evaluator value stack
+static uint64_t evstk[EVSTACKSIZE];	// Evaluator value stack
 static WORD evattr[EVSTACKSIZE];	// Evaluator attribute stack
 
 // Token-class initialization list
 char itokcl[] = {
 	0,								// END
-	CONST, SYMBOL, 0,				// ID
+	CONST, FCONST, SYMBOL, 0,		// ID
 	'(', '[', '{', 0,				// OPAR
 	')', ']', '}', 0,				// CPAR
 	CR_DEFINED, CR_REFERENCED,		// SUNARY (special unary)
@@ -61,9 +61,9 @@ static int symbolNum;				// Pointer to the entry in symbolPtr[]
 //
 // Obtain a string value
 //
-static VALUE str_value(char * p)
+static uint32_t str_value(char * p)
 {
-	VALUE v;
+	uint32_t v;
 
 	for(v=0; *p; p++)
 		v = (v << 8) | (*p & 0xFF);
@@ -133,6 +133,7 @@ int expr1(void)
 	char * p, * p2;
 	WORD w;
 	int j;
+	uint64_t * evalTokenBuffer64;
 
 	class = tokenClass[*tok];
 
@@ -146,6 +147,10 @@ int expr1(void)
 		if (t == '-')
 			t = UNMINUS;
 
+		// With leading + we don't have to deposit
+		// anything to the buffer because there's
+		// no unary '+' nor we have to do anything about it
+		if (t != '+')
 		*evalTokenBuffer++ = t;
 	}
 	else if (class == SUNARY)
@@ -154,15 +159,21 @@ int expr1(void)
 		{
 		case CR_ABSCOUNT:
 			*evalTokenBuffer++ = CONST;
-			*evalTokenBuffer++ = (LONG)sect[ABS].sloc;
+			evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			*evalTokenBuffer64++ = (LONG)sect[ABS].sloc;
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 			break;
 		case CR_TIME:
 			*evalTokenBuffer++ = CONST;
-			*evalTokenBuffer++ = dos_time();
+			evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			*evalTokenBuffer64++ = dos_time();
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 			break;
 		case CR_DATE:
 			*evalTokenBuffer++ = CONST;
-			*evalTokenBuffer++ = dos_date();
+			evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			*evalTokenBuffer64++ = dos_date();
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 			break;
 		case CR_MACDEF:                                    // ^^macdef <macro-name>
 			if (*tok++ != SYMBOL)
@@ -170,7 +181,9 @@ int expr1(void)
 
 			p = string[*tok++];
 			w = (lookup(p, MACRO, 0) == NULL ? 0 : 1);
-			*evalTokenBuffer++ = CONST;
+			evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			*evalTokenBuffer64++ = (TOKEN)w;
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 			*evalTokenBuffer++ = (TOKEN)w;
 			break;
 		case CR_DEFINED:
@@ -186,7 +199,9 @@ getsym:
 			j = (*p == '.' ? curenv : 0);
 			w = ((sy = lookup(p, LABEL, j)) != NULL && (sy->sattr & w) ? 1 : 0);
 			*evalTokenBuffer++ = CONST;
-			*evalTokenBuffer++ = (TOKEN)w;
+			uint64_t *evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			*evalTokenBuffer64++ = (TOKEN)w;
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 			break;
 		case CR_STREQ:
 			if (*tok != SYMBOL && *tok != STRING)
@@ -206,7 +221,9 @@ getsym:
 
 			w = (WORD)(!strcmp(p, p2));
 			*evalTokenBuffer++ = CONST;
-			*evalTokenBuffer++ = (TOKEN)w;
+			evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			*evalTokenBuffer64++ = (TOKEN)w;
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 			break;
 		}
 	}
@@ -225,12 +242,26 @@ int expr2(void)
 	char * p;
 	SYM * sy;
 	int j;
+	uint64_t * evalTokenBuffer64;
+	uint64_t * tok64;
 
 	switch ((int)*tok++)
 	{
 	case CONST:
 		*evalTokenBuffer++ = CONST;
-		*evalTokenBuffer++ = *tok++;
+		evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+		tok64 = (uint64_t *)tok;
+		*evalTokenBuffer64++ = *tok64++;
+		tok = (TOKEN *)tok64;
+		evalTokenBuffer = (TOKEN *)evalTokenBuffer64;
+		break;
+	case FCONST:
+		*evalTokenBuffer++ = FCONST;
+		evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+		tok64 = (uint64_t *)tok;
+		*evalTokenBuffer64++ = *tok64++;
+		tok = (TOKEN *)tok64;
+		evalTokenBuffer = (TOKEN *)evalTokenBuffer64;
 		break;
 	case SYMBOL:
 		p = string[*tok++];
@@ -244,10 +275,10 @@ int expr2(void)
 		if (sy->sattre & EQUATEDREG)
 		{
 			if ((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok)
-				warns("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
+				warn("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
 
 			if ((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok)
-				warns("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
+				warn("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
 		}
 
 		*evalTokenBuffer++ = SYMBOL;
@@ -257,14 +288,16 @@ int expr2(void)
 		break;
 	case STRING:
 		*evalTokenBuffer++ = CONST;
-		*evalTokenBuffer++ = str_value(string[*tok++]);
+		uint64_t *evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+		*evalTokenBuffer64++ = str_value(string[*tok++]);
+		evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 		break;
 	case '(':
 		if (expr0() != OK)
 			return ERROR;
 
 		if (*tok++ != ')')
-			return error("missing close parenthesis ')'");
+			return error("missing closing parenthesis ')'");
 
 		break;
 	case '[':
@@ -272,7 +305,7 @@ int expr2(void)
 			return ERROR;
 
 		if (*tok++ != ']')
-			return error("missing close parenthesis ']'");
+			return error("missing closing bracket ']'");
 
 		break;
 	case '$':
@@ -287,6 +320,20 @@ int expr2(void)
 		*evalTokenBuffer++ = (orgactive ? orgaddr : pcloc);
 		// '*' takes attributes of current section, not ABS!
 		*evalTokenBuffer++ = cursect | DEFINED;
+		break;
+	case '{':
+		if (expr0() != OK)							// Eat up first parameter (register or immediate)
+			return ERROR;
+
+		if (*tok++ != ':')							// Demand a ':' there
+			return error("missing colon ':'");
+
+		if (expr0() != OK)							// Eat up second parameter (register or immediate)
+			return ERROR;
+
+		if (*tok++ != '}')
+			return error("missing closing brace '}'");
+
 		break;
 	default:
 		return error("bad expression");
@@ -299,7 +346,7 @@ int expr2(void)
 //
 // Recursive-descent expression analyzer (with some simple speed hacks)
 //
-int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
+int expr(TOKEN * otk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym)
 {
 	// Passed in values (once derefenced, that is) can all be zero. They are
 	// there so that the expression analyzer can fill them in as needed. The
@@ -310,7 +357,8 @@ int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 	int j;
 
 	evalTokenBuffer = otk;	// Set token pointer to 'exprbuf' (direct.c)
-							// Also set in various other places too (riscasm.c, e.g.)
+							// Also set in various other places too (riscasm.c,
+							// e.g.)
 
 //printf("expr(): tokens 0-2: %i %i %i (%c %c %c); tc[2] = %i\n", tok[0], tok[1], tok[2], tok[0], tok[1], tok[2], tokenClass[tok[2]]);
 	// Optimize for single constant or single symbol.
@@ -320,14 +368,20 @@ int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 	//         (assuming tok[1] == EOL is a single token that is)
 	//         Seems that even other tokens (SUNARY type) can fuck this up too.
 //	if ((tok[1] == EOL)
-	if ((tok[1] == EOL && (tok[0] != CONST && tokenClass[tok[0]] != SUNARY))
-		|| (((*tok == CONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
-		&& (tokenClass[tok[2]] < UNARY)))
+	if ((tok[1] == EOL && ((tok[0] != CONST || tok[0] != FCONST) && tokenClass[tok[0]] != SUNARY))
+//		|| (((*tok == CONST || *tok == FCONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
+//		&& (tokenClass[tok[2]] < UNARY)))
+		|| (((tok[0] == SYMBOL) || (tok[0] >= KW_R0 && tok[0] <= KW_R31))
+		&& (tokenClass[tok[2]] < UNARY))
+		|| ((tok[0] == CONST || tok[0] == FCONST) && (tokenClass[tok[3]] < UNARY))
+		)
 	{
 		if (*tok >= KW_R0 && *tok <= KW_R31)
 		{
 			*evalTokenBuffer++ = CONST;
-			*evalTokenBuffer++ = *a_value = (*tok - KW_R0);
+			uint64_t *evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			*evalTokenBuffer64++ = *a_value = (*tok - KW_R0);
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 			*a_attr = ABS | DEFINED;
 
 			if (a_esym != NULL)
@@ -338,23 +392,44 @@ int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 		else if (*tok == CONST)
 		{
 			*evalTokenBuffer++ = CONST;
-			*evalTokenBuffer++ = *a_value = tok[1];
+			uint64_t *evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
+			uint64_t *tok64 = (uint64_t *)&tok[1];
+			*evalTokenBuffer64++ = *tok64++;
+			evalTokenBuffer = (TOKEN *)evalTokenBuffer64;
+			*a_value = tok[1];
 			*a_attr = ABS | DEFINED;
 
 			if (a_esym != NULL)
 				*a_esym = NULL;
 
-			tok += 2;
+			tok += 3;
+//printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
+		}
+		else if (*tok == FCONST)
+		{
+			*evalTokenBuffer++ = FCONST;
+			*((double *)evalTokenBuffer) = *((double *)&tok[1]);
+			evalTokenBuffer += 2;
+			//*(double *)evalTokenBuffer++ = tok[2];
+			*a_value = *((uint64_t *)&tok[1]);
+			*a_attr = ABS | DEFINED | FLOAT;
+
+			if (a_esym != NULL)
+				*a_esym = NULL;
+
+			tok += 3;
 //printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
 		}
 		else if (*tok == '*')
 		{
 			*evalTokenBuffer++ = CONST;
+			uint64_t *evalTokenBuffer64 = (uint64_t *)evalTokenBuffer;
 
 			if (orgactive)
-				*evalTokenBuffer++ = *a_value = orgaddr;
+				*evalTokenBuffer64++ = *a_value = orgaddr;
 			else
-				*evalTokenBuffer++ = *a_value = pcloc;
+				*evalTokenBuffer64++ = *a_value = pcloc;
+			evalTokenBuffer = (uint32_t *)evalTokenBuffer64;
 
 			// '*' takes attributes of current section, not ABS!
 			*a_attr = cursect | DEFINED;
@@ -386,7 +461,7 @@ if (symbol)
 			// means it will be fixed up later, and thus, not an error.
 			if ((symbol->sattre & UNDEF_EQUR) && !riscImmTokenSeen)
 			{
-				errors("undefined register equate '%s'", symbol->sname);
+				error("undefined register equate '%s'", symbol->sname);
 //if we return right away, it returns some spurious errors...
 //				return ERROR;
 			}
@@ -395,10 +470,10 @@ if (symbol)
 			if (symbol->sattre & EQUATEDREG)
 			{
 				if ((regbank == BANK_0) && (symbol->sattre & BANK_1) && !altbankok)
-					warns("equated symbol '%s' cannot be used in register bank 0", symbol->sname);
+					warn("equated symbol '%s' cannot be used in register bank 0", symbol->sname);
 
 				if ((regbank == BANK_1) && (symbol->sattre & BANK_0) && !altbankok)
-					warns("equated symbol '%s' cannot be used in register bank 1", symbol->sname);
+					warn("equated symbol '%s' cannot be used in register bank 1", symbol->sname);
 			}
 
 			*evalTokenBuffer++ = SYMBOL;
@@ -462,14 +537,15 @@ thrown away right here. What the hell is it for?
 // UNDEFINED, but it's value includes everything but the symbol value, and
 // `a_esym' is set to the external symbol.
 //
-int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
+int evexpr(TOKEN * tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym)
 {
-	WORD attr;
+	WORD attr, attr2;
 	SYM * sy;
-	VALUE * sval = evstk;					// (Empty) initial stack
+	uint64_t * sval = evstk;				// (Empty) initial stack
 	WORD * sattr = evattr;
 	SYM * esym = NULL;						// No external symbol involved
 	WORD sym_seg = 0;
+    uint64_t *tk64;
 
 	while (*tk != ENDEXPR)
 	{
@@ -509,10 +585,18 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 			sym_seg = (WORD)(sy->sattr & TDB);
 			break;
 		case CONST:
-//printf("evexpr(): CONST = %i\n", *tk);
-			*++sval = *tk++;				// Push value
+			tk64 = (uint64_t *)tk;
+			*++sval = *tk64++;
+			tk = (TOKEN *)tk64;
+//printf("evexpr(): CONST = %lX\n", *sval);
 			*++sattr = ABS | DEFINED;		// Push simple attribs
 			break;
+		case FCONST:
+//printf("evexpr(): CONST = %i\n", *tk);
+			*((double *)sval) = *((double *)tk);
+			tk += 2;
+			*++sattr = ABS | DEFINED | FLOAT; // Push simple attribs
+			break;
 		case ACONST:
 //printf("evexpr(): ACONST = %i\n", *tk);
 			*++sval = *tk++;				// Push value
@@ -535,11 +619,40 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 			--sval;							// Pop value
 			--sattr;						// Pop attrib
 //printf("--> N+N: %i + %i = ", *sval, sval[1]);
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+			attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float + Float
+				double * dst = (double *)sval;
+				double * src = (double *)(sval + 1);
+				*dst += *src;
+			}
+			else if (attr == FLOAT)
+			{
+				// Float + Int
+				double * dst = (double *)sval;
+				uint64_t * src = (uint64_t *)(sval + 1);
+				*dst += *src;
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int + Float
+				uint64_t * dst = (uint64_t *)sval;
+				double * src = (double *)(sval + 1);
+				*(double *)dst = *src + *dst;
+			}
+			else
+			{
 			*sval += sval[1];				// Compute value
+			}
 //printf("%i\n", *sval);
 
 			if (!(*sattr & TDB))
-				*sattr = sattr[1];
+				*sattr = sattr[1] | attr2;
 			else if (sattr[1] & TDB)
 				return error(seg_error);
 
@@ -549,13 +662,44 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 			--sval;							// Pop value
 			--sattr;						// Pop attrib
 //printf("--> N-N: %i - %i = ", *sval, sval[1]);
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+			attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float - Float
+				double * dst = (double *)sval;
+				double * src = (double *)(sval + 1);
+				*dst -= *src;
+			}
+			else if (attr == FLOAT)
+			{
+				// Float - Int
+				double * dst = (double *)sval;
+				uint64_t * src = (uint64_t *)(sval + 1);
+				*dst -= *src;
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int - Float
+				uint64_t * dst = (uint64_t *)sval;
+				double * src = (double *)(sval + 1);
+				*(double *)dst = *dst - *src;
+			}
+			else
+			{
 			*sval -= sval[1];				// Compute value
+			}
+
 //printf("%i\n", *sval);
 
 			attr = (WORD)(*sattr & TDB);
 #if 0
 printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 #endif
+			*sattr |= attr2;                // Inherit FLOAT attribute
 			// If symbol1 is ABS, take attributes from symbol2
 			if (!attr)
 				*sattr = sattr[1];
@@ -568,15 +712,27 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 		case UNMINUS:
 //printf("evexpr(): UNMINUS\n");
 			if (*sattr & TDB)
-				error(seg_error);
+				return error(seg_error);
 
+			if (*sattr & FLOAT)
+			{
+				double *dst = (double *)sval;
+				*dst = -*dst;
+				*sattr = ABS | DEFINED | FLOAT; // Expr becomes absolute
+			}
+			else
+			{
 			*sval = -(int)*sval;
 			*sattr = ABS | DEFINED;			// Expr becomes absolute
+			}
 			break;
 		case '!':
 //printf("evexpr(): !\n");
 			if (*sattr & TDB)
-				error(seg_error);
+				return error(seg_error);
+
+			if (*sattr & FLOAT)
+				return error("floating point numbers not allowed with operator '!'.");
 
 			*sval = !*sval;
 			*sattr = ABS | DEFINED;			// Expr becomes absolute
@@ -584,7 +740,10 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 		case '~':
 //printf("evexpr(): ~\n");
 			if (*sattr & TDB)
-				error(seg_error);
+				return error(seg_error);
+
+			if (*sattr & FLOAT)
+				return error("floating point numbers not allowed with operator '~'.");
 
 			*sval = ~*sval;
 			*sattr = ABS | DEFINED;			// Expr becomes absolute
@@ -597,10 +756,39 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 			sval--;
 
 			if ((*sattr & TDB) != (sattr[1] & TDB))
-				error(seg_error);
+				return error(seg_error);
 
-			*sattr = ABS | DEFINED;
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float <= Float
+				double * dst = (double *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst <= *src;
+			}
+			else if (attr == FLOAT)
+			{
+				// Float <= Int
+				double * dst = (double *)sval;
+				uint64_t * src = (uint64_t *)(sval + 1);
+				*sval = *dst <= *src;
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int <= Float
+				uint64_t * dst = (uint64_t *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst <= *src;
+			}
+			else
+			{
 			*sval = *sval <= sval[1];
+			}
+
+			*sattr = ABS | DEFINED;
 			break;
 		case GE:
 //printf("evexpr(): GE\n");
@@ -608,10 +796,41 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 			sval--;
 
 			if ((*sattr & TDB) != (sattr[1] & TDB))
-				error(seg_error);
+				return error(seg_error);
 
-			*sattr = ABS | DEFINED;
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float >= Float
+				double * dst = (double *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst >= *src;
+			}
+			else if (attr == FLOAT)
+			{
+				// Float >= Int
+				double * dst = (double *)sval;
+				uint64_t * src = (uint64_t *)(sval + 1);
+				*sval = *dst >= *src;
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int >= Float
+				uint64_t * dst = (uint64_t *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst >= *src;
+			}
+			else if (attr == 0)
+			{
 			*sval = *sval >= sval[1];
+			}
+			else
+
+			*sattr = ABS | DEFINED;
+
 			break;
 		case '>':
 //printf("evexpr(): >\n");
@@ -619,10 +838,40 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 			sval--;
 
 			if ((*sattr & TDB) != (sattr[1] & TDB))
-				error(seg_error);
+				return error(seg_error);
 
-			*sattr = ABS | DEFINED;
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float > Float
+				double * dst = (double *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst > *src;
+			}
+			else if (attr == FLOAT)
+			{
+				// Float > Int
+				double * dst = (double *)sval;
+				uint64_t * src = (uint64_t *)(sval + 1);
+				*sval = *dst > *src;
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int > Float
+				uint64_t * dst = (uint64_t *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst > *src;
+			}
+			else
+=			{
 			*sval = *sval > sval[1];
+			}
+
+			*sattr = ABS | DEFINED;
+
 			break;
 		case '<':
 //printf("evexpr(): <\n");
@@ -630,10 +879,40 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 			sval--;
 
 			if ((*sattr & TDB) != (sattr[1] & TDB))
-				error(seg_error);
+				return error(seg_error);
 
-			*sattr = ABS | DEFINED;
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) > >1);
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float < Float
+				double * dst = (double *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst < *src;
+			}
+			else if (attr == FLOAT)
+			{
+				// Float < Int
+				double * dst = (double *)sval;
+				uint64_t * src = (uint64_t *)(sval + 1);
+				*sval = *dst < *src;
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int < Float
+				uint64_t * dst = (uint64_t *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *dst < *src;
+			}
+			else
+			{
 			*sval = *sval < sval[1];
+			}
+
+			*sattr = ABS | DEFINED;
+
 			break;
 		case NE:
 //printf("evexpr(): NE\n");
@@ -641,10 +920,34 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 			sval--;
 
 			if ((*sattr & TDB) != (sattr[1] & TDB))
-				error(seg_error);
+				return error(seg_error);
 
-			*sattr = ABS | DEFINED;
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float <> Float
+				return error("comparison for equality with float types not allowed.");
+			}
+			else if (attr == FLOAT)
+			{
+				// Float <> Int
+				return error("comparison for equality with float types not allowed.");
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int != Float
+				return error("comparison for equality with float types not allowed.");
+			}
+			else
+			{
 			*sval = *sval != sval[1];
+			}
+
+			*sattr = ABS | DEFINED;
+
 			break;
 		case '=':
 //printf("evexpr(): =\n");
@@ -652,10 +955,38 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 			sval--;
 
 			if ((*sattr & TDB) != (sattr[1] & TDB))
-				error(seg_error);
+				return error(seg_error);
 
-			*sattr = ABS | DEFINED;
+			// Extract float attributes from both terms and pack them
+			// into a single value
+			attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+
+			if (attr == (FLOAT | (FLOAT >> 1)))
+			{
+				// Float = Float
+				double * dst = (double *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *src == *dst;
+			}
+			else if (attr == FLOAT)
+			{
+				// Float = Int
+				return error("equality with float ");
+			}
+			else if (attr == FLOAT >> 1)
+			{
+				// Int == Float
+				uint64_t * dst = (uint64_t *)sval;
+				double * src = (double *)(sval + 1);
+				*sval = *src == *dst;
+			}
+			else
+			{
 			*sval = *sval == sval[1];
+			}
+
+			*sattr = ABS | DEFINED;
+
 			break;
 		// All other binary operators must have two ABS items
 		// to work with.  They all produce an ABS value.
@@ -664,7 +995,6 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 			// GH - Removed for v1.0.15 as part of the fix for indexed loads.
 			//if ((*sattr & (TEXT|DATA|BSS)) || (*--sattr & (TEXT|DATA|BSS)))
 			//error(seg_error);
-			*sattr = ABS | DEFINED;			// Expr becomes absolute
 
 			switch ((int)tk[-1])
 			{
@@ -672,56 +1002,147 @@ printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
 				sval--;
 				sattr--;					// Pop attrib
 //printf("--> NxN: %i x %i = ", *sval, sval[1]);
+				// Extract float attributes from both terms and pack them
+				// into a single value
+				attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+				attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT
+
+				if (attr == (FLOAT | (FLOAT >> 1)))
+				{
+					// Float * Float
+					double * dst = (double *)sval;
+					double * src = (double *)(sval + 1);
+					*dst *= *src;
+				}
+				else if (attr == FLOAT)
+				{
+					// Float * Int
+					double * dst = (double *)sval;
+					uint64_t * src = (uint64_t *)(sval + 1);
+					*dst *= *src;
+				}
+				else if (attr == FLOAT >> 1)
+				{
+					// Int * Float
+					uint64_t * dst = (uint64_t *)sval;
+					double * src = (double *)(sval + 1);
+					*(double *)dst = *src * *dst;
+				}
+				else
+				{
 				*sval *= sval[1];
+				}
 //printf("%i\n", *sval);
+
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
+				*sattr |= attr2;
+
 				break;
 			case '/':
 				sval--;
 				sattr--;					// Pop attrib
 
-				if (sval[1] == 0)
-					return error("divide by zero");
 
+//printf("--> N/N: %i / %i = ", sval[0], sval[1]);
+				// Extract float attributes from both terms and pack them
+				// into a single value
+				attr = sattr[0] & FLOAT | ((sattr[1] & FLOAT) >> 1);
+				attr2 = sattr[0] | sattr[1] & FLOAT; // Returns FLOAT if either of the two numbers are FLOAT
+
+				if (attr == (FLOAT | (FLOAT >> 1)))
+				{
+					// Float / Float
+					double * dst = (double *)sval;
+					double * src = (double *)(sval + 1);
+					if (*src == 0)
+						return error("divide by zero");
+					*dst = *dst / *src;
+				}
+				else if (attr == FLOAT)
+				{
+					// Float / Int
+					double * dst = (double *)sval;
+					uint64_t * src = (uint64_t *)(sval + 1);
+					if (*src == 0)
+						return error("divide by zero");
+					*dst = *dst / *src;
+				}
+				else if (attr == FLOAT >> 1)
+				{
+					// Int / Float
+					uint64_t * dst=(uint64_t *)sval;
+					double * src=(double *)(sval + 1);
+					if (*src == 0)
+						return error("divide by zero");
+					*(double *)dst = *dst / *src;
+				}
+				else
+				{
+					if (sval[1] == 0)
+						return error("divide by zero");
 //printf("--> N/N: %i / %i = ", sval[0], sval[1]);
 				// Compiler is picky here: Without casting these, it discards
 				// the sign if dividing a negative # by a positive one,
 				// creating a bad result. :-/
-				// Probably a side effect of using VALUE intead of ints.
-				*sval = (int)sval[0] / (int)sval[1];
+				// Definitely a side effect of using uint32_ts intead of ints.
+				*sval = (int32_t)sval[0] / (int32_t)sval[1];
+				}
+
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
+				*sattr |= attr2;
+
 //printf("%i\n", *sval);
 				break;
 			case '%':
 				sval--;
 				sattr--;					// Pop attrib
+				if ((*sattr | sattr[1]) & FLOAT)
+					return error("floating point numbers not allowed with operator '%'.");
 
 				if (sval[1] == 0)
 					return error("mod (%) by zero");
 
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
 				*sval %= sval[1];
 				break;
 			case SHL:
 				sval--;
 				sattr--;					// Pop attrib
+				if ((*sattr | sattr[1]) & FLOAT)
+					return error("floating point numbers not allowed with operator '<<'.");
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
 				*sval <<= sval[1];
 				break;
 			case SHR:
 				sval--;
 				sattr--;					// Pop attrib
+				if ((*sattr | sattr[1]) & FLOAT)
+					return error("floating point numbers not allowed with operator '>>'.");
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
 				*sval >>= sval[1];
 				break;
 			case '&':
 				sval--;
 				sattr--;					// Pop attrib
+				if ((*sattr | sattr[1]) & FLOAT)
+					return error("floating point numbers not allowed with operator '&'.");
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
 				*sval &= sval[1];
 				break;
 			case '^':
 				sval--;
 				sattr--;					// Pop attrib
+				if ((*sattr | sattr[1]) & FLOAT)
+					return error("floating point numbers not allowed with operator '^'.");
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
 				*sval ^= sval[1];
 				break;
 			case '|':
 				sval--;
 				sattr--;					// Pop attrib
+				if ((*sattr | sattr[1]) & FLOAT)
+					return error("floating point numbers not allowed with operator '|'.");
+				*sattr = ABS | DEFINED;			// Expr becomes absolute
 				*sval |= sval[1];
 				break;
 			default: