X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=parmode.h;h=ca313efb1bd8dbcff02169303831d0c8bc4f6bc8;hp=0c5ca2c0818e01b9ab248016127482dc41c456ce;hb=4205233c8397c581b4d27ab36ab81ec896ef3dd0;hpb=f3c7d186a15b89c39e360b9cc89545a0d24bd6a4

diff --git a/parmode.h b/parmode.h
index 0c5ca2c..ca313ef 100644
--- a/parmode.h
+++ b/parmode.h
@@ -1,7 +1,7 @@
 //
 // RMAC - Reboot's Macro Assembler for all Atari computers
 // PARMODE.C - Addressing Modes Parser Include
-// Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends
+// Copyright (C) 199x Landon Dyer, 2011-2020 Reboot and Friends
 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
 // Source utilised with the kind permission of Landon Dyer
 //
@@ -9,22 +9,27 @@
 // This file is included (twice) to parse two addressing modes, into slightly
 // different var names
 {
+	uint64_t scaleval;			// Expression's value
+	TOKEN scaleexpr[EXPRSIZE];	// Expression
+	WORD scaleattr;				// Expression's attribute
+	SYM * scaleesym;			// External symbol involved in expr
+
 	// Dn
 	// An
 	// # expression
-	if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7))
+	if ((*tok >= KW_D0) && (*tok <= KW_D7))
 	{
 		AMn = DREG;
-		AnREG = *tok.u32++ & 7;
+		AnREG = *tok++ & 7;
 	}
-	else if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7))
+	else if ((*tok >= KW_A0) && (*tok <= KW_A7))
 	{
 		AMn = AREG;
-		AnREG = *tok.u32++ & 7;
+		AnREG = *tok++ & 7;
 	}
-	else if (*tok.u32 == '#')
+	else if (*tok == '#')
 	{
-		tok.u32++;
+		tok++;
 
 		if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
 			return ERROR;
@@ -44,25 +49,25 @@
 	// (d8,An,Xn[.siz][*scale])
 	// (d16,PC)
 	// (d8,PC,Xn[.siz][*scale])
-	// ([bd,An],Xn,od)
-	// ([bd,An,Xn],od)
-	// ([bd,PC],Xn,od)
-	// ([bd,PC,Xn],od)
-	else if (*tok.u32 == '(')
+	// ([bd,An],Xn[.siz][*scale],od)
+	// ([bd,An,Xn[.siz][*scale]],od)
+	// ([bd,PC],Xn[.siz][*scale],od)
+	// ([bd,PC,Xn[.siz][*scale]],od)
+	else if (*tok == '(')
 	{
-		tok.u32++;
+		tok++;
 
-		if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7))
+		if ((*tok >= KW_A0) && (*tok <= KW_A7))
 		{
-			AnREG = *tok.u32++ & 7;
+			AnREG = *tok++ & 7;
 
-			if (*tok.u32 == ')')
+			if (*tok == ')')
 			{
-				tok.u32++;
+				tok++;
 
-				if (*tok.u32 == '+')
+				if (*tok == '+')
 				{
-					tok.u32++;
+					tok++;
 					AMn = APOSTINC;
 				}
 				else
@@ -74,14 +79,14 @@
 			AMn = AINDEXED;
 			goto AMn_IX0;            // Handle ",Xn[.siz][*scale])"
 		}
-		else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7))
+		else if ((*tok >= KW_D0) && (*tok <= KW_D7))
 		{
 			//Since index register isn't used here, store register number in this field
-			AnIXREG = *tok.u32++ & 7;                                // (Dn)
+			AnIXREG = *tok++ & 7;                                // (Dn)
 
-			if (*tok.u32 == ')')
+			if (*tok == ')')
 			{
-				tok.u32++;
+				tok++;
 				AnEXTEN |= EXT_FULLWORD;    // Definitely using full extension format, so set bit 8
 				AnEXTEN |= EXT_BS;          // Base register suppressed
 				AnEXTEN |= EXT_BDSIZE0;     // Base displacement null
@@ -90,21 +95,19 @@
 				AnREG = 6 << 3;		// stuff 110 to mode field
 				goto AnOK;
 			}
-			else if (*tok.u32 == 'L')
+			else if (*tok == 'L')
 			{
-				// TODO: does DINDL gets used at all?
-				AMn = DINDL;                                     // (Dn.l)
-				AnEXTEN = 1 << 1;   // Long index size
-				tok.u32++;
+				AMn = DINDL;									 // (Dn.l)
+				AnEXTEN = 1 << 11;   // Long index size
+				tok++;
 			}
-			else if (*tok.u32 == 'W')                                // (Dn.w)
+			else if (*tok == 'W')                                // (Dn.w)
 			{
-				// TODO: does DINDW gets used at all?
 				AMn = DINDW;
-				AnEXTEN = 1 << 1;   // Word index size
-				tok.u32++;
+				AnEXTEN = 0 << 11;   // Word index size
+				tok++;
 			}
-			else if (*tok.u32 == ',')
+			else if (*tok == ',')
 			{
 				// ([bd,An],Xn..) without bd, An
 				// Base displacement is suppressed
@@ -112,7 +115,7 @@
 				AnEXTEN |= EXT_BS;          // Base register suppressed
 				AnEXTEN |= EXT_BDSIZE0;
 				AnREG = 6 << 3;		// stuff 110 to mode field
-				tok.u32++;
+				tok++;
 				goto CHECKODn;
 			}
 			else
@@ -120,58 +123,66 @@
 				return error("(Dn) error");
 			}
 
-			if (*tok.u32 == '*')
+			if (*tok == '*')
 			{                        // scale: *1, *2, *4, *8
-				tok.u32++;
+				tok++;
 
-				if (*tok.u32 == SYMBOL)
+				if (*tok == SYMBOL)
 				{
-					if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+					if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
 						return error("scale factor expression must evaluate");
 
-					switch (AnEXVAL)
+					switch (scaleval)
 					{
 					case 1:
 						break;
 					case 2:
 						AnIXSIZ |= TIMES2;
+						AnEXTEN |= 1 << 9;
 						break;
 					case 4:
 						AnIXSIZ |= TIMES4;
+						AnEXTEN |= 2 << 9;
 						break;
 					case 8:
 						AnIXSIZ |= TIMES8;
+						AnEXTEN |= 3 << 9;
 						break;
 					default:
 						goto badmode;
 					}
 				}
-				else if (*tok.u32++ != CONST || *tok.u32 > 8)
+				else if (*tok++ != CONST)
 					goto badmode;
 				else
 				{
-					switch ((int)*tok.u32++)
+					switch ((int)*tok++)
 					{
 					case 1:
 						break;
 					case 2:
 						AnIXSIZ |= TIMES2;
+						AnEXTEN |= 1 << 9;
 						break;
 					case 4:
 						AnIXSIZ |= TIMES4;
+						AnEXTEN |= 2 << 9;
 						break;
 					case 8:
 						AnIXSIZ |= TIMES8;
+						AnEXTEN |= 3 << 9;
 						break;
 					default:
 						goto badmode;
 					}
+
+					tok++;  // Take into account that constants are 64-bit
 				}
 			}
 
-			if (*tok.u32 == ')')
+			if (*tok == ')')
 			{
-				tok.u32++;
+				tok++;
 				AnEXTEN |= EXT_FULLWORD;    // Definitely using full extension format, so set bit 8
 				AnEXTEN |= EXT_BS;          // Base register suppressed
 				AnEXTEN |= EXT_BDSIZE0;     // Base displacement null
@@ -180,65 +191,68 @@
 				AMn = MEMPOST;
 				goto AnOK;
 			}
-			else if (*tok.u32 == ',')
+			else if (*tok == ',')
 			{
-				tok.u32++;  // eat the comma
+				tok++;  // eat the comma
 				// It might be (Dn[.wl][*scale],od)
 				// Maybe this is wrong and we have to write some code here
 				// instead of reusing that path...
-				AnEXTEN |= EXT_BDSIZE0;     // Base displacement null - suppressed
+				AnEXTEN |= EXT_FULLWORD;	// Definitely using full extension format, so set bit 8
+				AnEXTEN |= EXT_BS;	 // Base displacement null - suppressed
+				AnEXTEN |= AnIXREG << 12;
 				goto CHECKODn;
 			}
 			else
 				return error("unhandled so far");
 		}
-		else if (*tok.u32 == KW_PC)
+		else if (*tok == KW_PC)
 		{                            // (PC,Xn[.siz][*scale])
-			tok.u32++;
+			tok++;
 			AMn = PCINDEXED;
 
 			// Common index handler; enter here with 'tok' pointing at the
 			// comma.
 
-			AMn_IX0:                 // Handle indexed with missing expr
+AMn_IX0:                 // Handle indexed with missing expr
 
 			AnEXVAL = 0;
 			AnEXATTR = ABS | DEFINED;
 
-			AMn_IXN:                 // Handle any indexed (tok -> a comma)
+AMn_IXN:                 // Handle any indexed (tok -> a comma)
 
-			if (*tok.u32++ != ',')
+			if (*tok++ != ',')
 				goto badmode;
 
-			if (*tok.u32 < KW_D0 || *tok.u32 > KW_A7)
+			if (*tok < KW_D0 || *tok > KW_A7)
 				goto badmode;
 
-			AnIXREG = *tok.u32++ & 15;
+			AnIXREG = *tok++ & 15;
 
-			switch ((int)*tok.u32)
+			switch ((int)*tok)
 			{                        // Index reg size: <empty> | .W | .L
 			case DOTW:
-				tok.u32++;
+				tok++;
 			default:
 				AnIXSIZ = 0;
 				break;
 			case DOTL:
 				AnIXSIZ = 0x0800;
-				tok.u32++;
+				tok++;
 				break;
 			case DOTB:               // .B not allowed here...
 				goto badmode;
 			}
 
-			if (*tok.u32 == '*')
+			if (*tok == '*')
 			{                        // scale: *1, *2, *4, *8
-				tok.u32++;
+				tok++;
 
-				if (*tok.u32 == SYMBOL)
+				if (*tok == SYMBOL)
 				{
-					if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+					if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
 						return error("scale factor expression must evaluate");
-					switch (AnEXVAL)
+
+					switch (scaleval)
 					{
 					case 1:
 						break;
@@ -255,11 +269,11 @@
 						goto badmode;
 					}
 				}
-				else if (*tok.u32++ != CONST || *tok.u32 > 8)
+				else if (*tok++ != CONST)
 					goto badmode;
 				else
 				{
-					switch ((int)*tok.u32++)
+					switch ((int)*tok++)
 					{
 					case 1:
 						break;
@@ -275,58 +289,63 @@
 					default:
 						goto badmode;
 					}
+
+					tok++;  // Take into account that constants are 64-bit
 				}
 			}
 
-			if (*tok.u32 == ',')
+			if (*tok == ',')
 			{
 				// If we got here we didn't get any [] stuff
 				// so let's suppress base displacement before
 				// branching off
-				tok.u32++;
+				tok++;
 				AnEXTEN |= EXT_BDSIZE0;     // Base displacement null - suppressed
 				goto CHECKODn;
 			}
-			if (*tok.u32++ != ')')         // final ")"
+			if (*tok++ != ')')         // final ")"
 				goto badmode;
 
 			goto AnOK;
 		}
-		else if (*tok.u32 == '[')
+		else if (*tok == '[')
 		{                              // ([...
-			tok.u32++;
+			tok++;
 			AnEXTEN |= EXT_FULLWORD;     // Definitely using full extension format, so set bit 8
 
 			// Check to see if base displacement is present
-			if (*tok.u32 != CONST && *tok.u32 != SYMBOL)
+			if (*tok != CONST && *tok != SYMBOL)
 			{
 				AnEXTEN |= EXT_BDSIZE0;
 			}
 			else
 			{
 				expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM);
+
 				if (CHECK_OPTS(OPT_BASE_DISP) && AnBEXVAL == 0 && AnEXATTR != 0)
 				{
 					// bd=0 so let's optimise it out
 					AnEXTEN|=EXT_BDSIZE0;
 				}
-				else if (*tok.u32 == DOTL)
-				{						// ([bd.l,...
-						AnEXTEN |= EXT_BDSIZEL;
-						tok.u32++;
+				else if (*tok == DOTL)
+				{
+					// ([bd.l,...
+					AnEXTEN |= EXT_BDSIZEL;
+					tok++;
 				}
 				else
-				{						// ([bd[.w],... or ([bd,...
+				{
+					// ([bd[.w],... or ([bd,...
 					// Is .W forced here?
-					if (*tok.u32 == DOTW)
+					if (*tok == DOTW)
 					{
 						AnEXTEN |= EXT_BDSIZEW;
-						tok.u32++;
+						tok++;
 					}
 					else
 					{
-						// Defined, absolute values from $FFFF8000..$00007FFF get optimized
-						// to absolute short
+						// Defined, absolute values from $FFFF8000..$00007FFF
+						// get optimized to absolute short
 						if (CHECK_OPTS(OPT_ABS_SHORT)
 							&& ((AnBEXATTR & (TDB | DEFINED)) == DEFINED)
 							&& (((uint32_t)AnBEXVAL + 0x8000) < 0x10000))
@@ -341,8 +360,8 @@
 					}
 				}
 
-				if (*tok.u32 == ',')
-					tok.u32++;
+				if (*tok == ',')
+					tok++;
 				//else
 				//	return error("Comma expected after base displacement");
 			}
@@ -350,57 +369,55 @@
 			// Check for address register or PC, suppress base register
 			// otherwise
 
-			if (*tok.u32 == KW_PC)
+			if (*tok == KW_PC)
 			{					// ([bd,PC,...
 				AnREG = (7 << 3) | 3;	// PC is special case - stuff 011 to register field and 111 to the mode field
-				tok.u32++;
+				tok++;
 			}
-			else if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7))
+			else if ((*tok >= KW_A0) && (*tok <= KW_A7))
 			{					// ([bd,An,...
-				AnREG = (6 << 3) | *tok.u32 & 7;
-				tok.u32++;
+				AnREG = (6 << 3) | (*tok & 7);
+				tok++;
 			}
-			else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7))
+			else if ((*tok >= KW_D0) && (*tok <= KW_D7))
 			{
 				// ([bd,Dn,...
 				AnREG = (6 << 3);
-				AnEXTEN |= ((*tok.u32 & 7) << 12);
+				AnEXTEN |= ((*tok & 7) << 12);
 				AnEXTEN |= EXT_D;
 				AnEXTEN |= EXT_BS; // Oh look, a data register! Which means that base register is suppressed
-				tok.u32++;
+				tok++;
 
 				// Check for size
-				{
 				// ([bd,An/PC],Xn.W/L...)
-				switch ((int)*tok.u32)
+				switch ((int)*tok)
 				{
 				// Index reg size: <empty> | .W | .L
 				case DOTW:
-					tok.u32++;
+					tok++;
 					break;
 				default:
 					break;
 				case DOTL:
 					AnEXTEN |= EXT_L;
-					tok.u32++;
+					tok++;
 					break;
 				case DOTB:
 					// .B not allowed here...
 					goto badmode;
 				}
-				}
 
 				// Check for scale
-				if (*tok.u32 == '*')			// ([bd,An/PC],Xn*...)
+				if (*tok == '*')			// ([bd,An/PC],Xn*...)
 				{                           // scale: *1, *2, *4, *8
-					tok.u32++;
+					tok++;
 
-					if (*tok.u32 == SYMBOL)
+					if (*tok == SYMBOL)
 					{
-						if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+						if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
 							return error("scale factor expression must evaluate");
 
-						switch (AnEXVAL)
+						switch (scaleval)
 						{
 						case 1:
 							break;
@@ -417,11 +434,11 @@
 							goto badmode;
 				}
 					}
-					else if (*tok.u32++ != CONST || *tok.u32 > 8)
+					else if (*tok++ != CONST)
 						goto badmode;
 					else
 					{
-						switch ((int)*tok.u32++)
+						switch ((int)*tok++)
 						{
 						case 1:
 							break;
@@ -437,15 +454,17 @@
 						default:
 							goto badmode;
 						}
+
+						tok++;  // Take into account that constants are 64-bit
 					}
 				}
-				if (*tok.u32 == ']')  // ([bd,Dn]...
+				if (*tok == ']')  // ([bd,Dn]...
 				{
-					tok.u32++;
+					tok++;
 					goto IS_SUPPRESSEDn;
 				}
 			}
-			else if (*tok.u32 == ']')
+			else if (*tok == ']')
 			{
 				// PC and Xn is suppressed
 				AnREG = 6 << 3;		// stuff 110 to mode field
@@ -458,77 +477,75 @@
 			}
 
 			// At a crossroads here. We can accept either ([bd,An/PC],... or ([bd,An/PC,Xn*scale],...
-			if (*tok.u32 == ']')
+			if (*tok == ']')
 			{
 				//([bd,An/PC],Xn,od)
 				// Check for Xn
-				tok.u32++;
+				tok++;
 
-				if (*tok.u32 == ')')
+				if (*tok == ')')
 				{
 					//Xn and od are non existent, get out of jail free card
-					tok.u32++;
+					tok++;
 					AMn = MEMPRE;			// ([bc,An,Xn],od) with no Xn and od
 					AnEXTEN |= EXT_IS | EXT_IISPREN;	//Suppress Xn and od
 					goto AnOK;
 				}
-				else if (*tok.u32 != ',')
+				else if (*tok != ',')
 					return error("comma expected after ]");
 				else
-					tok.u32++;				// eat the comma
+					tok++;				// eat the comma
 
-				if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7))
+				if ((*tok >= KW_A0) && (*tok <= KW_A7))
 				{
-					AnIXREG = ((*tok.u32 & 7) << 12);
+					AnIXREG = ((*tok & 7) << 12);
 					AnEXTEN |= EXT_A;
-					tok.u32++;
+					tok++;
 				}
-				else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7))
+				else if ((*tok >= KW_D0) && (*tok <= KW_D7))
 				{
-					AnEXTEN |= ((*tok.u32 & 7) << 12);
+					AnEXTEN |= ((*tok & 7) << 12);
 					AnEXTEN |= EXT_D;
-					tok.u32++;
+					tok++;
 				}
 				else
 				{
 					//No index found, suppress it
 					AnEXTEN |= EXT_IS;
-					tok.u32--;					// Rewind tok to point to the comma
+					tok--;					// Rewind tok to point to the comma
 					goto IS_SUPPRESSEDn;	// https://xkcd.com/292/ - what does he know anyway?
 				}
 
 				// Check for size
+				// ([bd,An/PC],Xn.W/L...)
+				switch ((int)*tok)
 				{
-					// ([bd,An/PC],Xn.W/L...)
-					switch ((int)*tok.u32)
-					{
-					// Index reg size: <empty> | .W | .L
-					case DOTW:
-						tok.u32++;
-						break;
-					default:
-						break;
-					case DOTL:
-						AnEXTEN |= EXT_L;
-						tok.u32++;
-						break;
-					case DOTB:
-						// .B not allowed here...
-						goto badmode;
-					}
+				// Index reg size: <empty> | .W | .L
+				case DOTW:
+					tok++;
+					break;
+				default:
+					break;
+				case DOTL:
+					AnEXTEN |= EXT_L;
+					tok++;
+					break;
+				case DOTB:
+					// .B not allowed here...
+					goto badmode;
 				}
 
 				// Check for scale
-				if (*tok.u32 == '*')                   // ([bd,An/PC],Xn*...)
+				if (*tok == '*')                   // ([bd,An/PC],Xn*...)
 				{                                  // scale: *1, *2, *4, *8
-					tok.u32++;
+					tok++;
 
-					if (*tok.u32 == SYMBOL)
+					if (*tok == SYMBOL)
 					{
-						if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+						if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
 							return error("scale factor expression must evaluate");
 
-						switch (AnEXVAL)
+						switch (scaleval)
 						{
 						case 1:
 							break;
@@ -545,11 +562,11 @@
 							goto badmode;
 						}
 					}
-					else if (*tok.u32++ != CONST || *tok.u32 > 8)
+					else if (*tok++ != CONST)
 						goto badmode;
 					else
 					{
-						switch ((int)*tok.u32++)
+						switch ((int)*tok++)
 						{
 						case 1:
 							break;
@@ -565,43 +582,64 @@
 						default:
 							goto badmode;
 						}
+
+						tok++;  // Take into account that constants are 64-bit
 					}
 				}
 
 				// Check for od
-				if (*tok.u32 == ')')	// ([bd,An/PC],Xn)
+				if (*tok == ')')	// ([bd,An/PC],Xn)
 				{
-					//od is non existant, get out of jail free card
+					// od is non existent, get out of jail free card
 					AMn = MEMPOST;		// let's say it's ([bd,An],Xn,od) with od=0 then
 					AnEXTEN |= EXT_IISPOSN; // No outer displacement
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
-				else if (*tok.u32 != ',')
+				else if (*tok != ',')
 					return error("comma expected");
 				else
-					tok.u32++;	// eat the comma
+					tok++;	// eat the comma
 
-				CHECKODn:
+CHECKODn:
 				if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
 					goto badmode;
 
-				if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0))
+				if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXATTR & DEFINED) && (AnEXVAL == 0))
 				{
 					// od=0 so optimise it out
 					AMn = MEMPOST;		 // let's say it's ([bd,An],Xn,od) with od=0 then
 					AnEXTEN |= EXT_IISPOSN; // No outer displacement
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
 
 				// ([bd,An/PC],Xn,od)
-				if (*tok.u32 == DOTL)
+				if (*tok == DOTL)
 				{
 					// expr.L
-					AnEXTEN |= EXT_IISPOSL; // Long outer displacement
+					if (!(AnEXTEN & EXT_BS))
+						AnEXTEN |= EXT_IISPOSL; // Long outer displacement
+					else
+					{
+						// bd is suppressed, so sticking the od size in bd
+						AnEXTEN |= EXT_BDSIZEL;
+						// And of course the expression has to be copied to
+						// AnBEXPR instead of AnEXPR. Yay. :-/
+						int i = 0;
+
+						do
+						{
+							AnBEXPR[i] = AnEXPR[i];
+							i++;
+						}
+						while (AnEXPR[i] != 'E');
+
+						AnBEXPR[i] = 'E';
+					}
+
 					AMn = MEMPOST;
-					tok.u32++;
+					tok++;
 
 					// Defined, absolute values from $FFFF8000..$00007FFF get
 					// optimized to absolute short
@@ -622,16 +660,14 @@
 					AMn = MEMPOST;
 
 					// Is .W forced here?
-					if (*tok.u32 == DOTW)
-					{
-						tok.u32++;
-					}
+					if (*tok == DOTW)
+						tok++;
 				}
 
 				// Check for final closing parenthesis
-				if (*tok.u32 == ')')
+				if (*tok == ')')
 				{
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
 				else
@@ -640,20 +676,20 @@
 IS_SUPPRESSEDn:
 
 				// Check for od
-				if (*tok.u32 == ')')	// ([bd,An/PC],Xn)
+				if (*tok == ')')	// ([bd,An/PC],Xn)
 				{
-					//od is non existant, get out of jail free card
+					// od is non existent, get out of jail free card
 					AMn = MEMPOST;		// let's say it's ([bd,An],Xn,od) with od=0 then
 					AnEXTEN |= EXT_IISNOIN; // No outer displacement
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
-				else if (*tok.u32!=',')
+				else if (*tok!=',')
 					return error("comma expected");
 				else
-					tok.u32++;	// eat the comma
+					tok++;	// eat the comma
 
-                if ((*tok.u32 != CONST) && (*tok.u32 != SYMBOL))
+				if ((*tok != CONST) && (*tok != SYMBOL))
 					goto badmode;
 
 				expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM);
@@ -663,15 +699,15 @@ IS_SUPPRESSEDn:
 					// od=0 so optimise it out
 					AMn = MEMPOST;		 // let's say it's ([bd,An],Xn,od) with od=0 then
 					AnEXTEN |= EXT_IISNOIN; // No outer displacement
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
 
 				// ([bd,An/PC],Xn,od)
-				if (*tok.u32 == DOTL)
+				if (*tok == DOTL)
 				{
 					// expr.L
-					tok.u32++;
+					tok++;
 					AMn = MEMPOST;
 					AnEXTEN |= EXT_IISNOIL; // Long outer displacement with IS suppressed
 				}
@@ -681,11 +717,11 @@ IS_SUPPRESSEDn:
 					AnEXTEN |= EXT_IISNOIW; // Word outer displacement with IS suppressed
 					AMn = MEMPRE;
 
-					if (*tok.u32 == DOTW)
+					if (*tok == DOTW)
 					{
 						//AnEXTEN|=EXT_IISNOIW; // Word outer displacement
 						AMn = MEMPOST;
-						tok.u32++;
+						tok++;
 					}
 					// Defined, absolute values from $FFFF8000..$00007FFF get
 					// optimized to absolute short
@@ -699,63 +735,62 @@ IS_SUPPRESSEDn:
 				}
 
 				// Check for final closing parenthesis
-				if (*tok.u32 == ')')
+				if (*tok == ')')
 				{
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
 				else
 					return error("Closing parenthesis missing on addressing mode");
 			}
-			else if (*tok.u32 == ',')
+			else if (*tok == ',')
 			{
-				*tok.u32++;			// ([bd,An,Xn.size*scale],od)
+				tok++;			// ([bd,An,Xn.size*scale],od)
 
-				//Check for Xn
-				if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7))
+				// Check for Xn
+				if ((*tok >= KW_A0) && (*tok <= KW_A7))
 				{
-					AnEXTEN |= ((*tok.u32 & 7) << 12);
+					AnEXTEN |= ((*tok & 7) << 12);
 					AnEXTEN |= EXT_A;
-					tok.u32++;
+					tok++;
 				}
-				else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7))
+				else if ((*tok >= KW_D0) && (*tok <= KW_D7))
 				{
-					AnEXTEN |= ((*tok.u32 & 7) << 12);
+					AnEXTEN |= ((*tok & 7) << 12);
 					AnEXTEN |= EXT_D;
-					tok.u32++;
+					tok++;
 				}
 
 				// Check for size
-				{
 				// ([bd,An/PC],Xn.W/L...)
-				switch ((int)*tok.u32)
+				switch ((int)*tok)
 				{
 				// Index reg size: <empty> | .W | .L
 				case DOTW:
-					tok.u32++;
+					tok++;
 					break;
 				default:
 					break;
 				case DOTL:
-					tok.u32++;
+					tok++;
 					AnEXTEN |= EXT_L;
 					break;
 				case DOTB:
-					// .B not allowed here...
-					goto badmode;
-				}
+				// .B not allowed here...
+				goto badmode;
 				}
 
 				// Check for scale
-				if (*tok.u32 == '*')			// ([bd,An/PC],Xn*...)
-				{                           // scale: *1, *2, *4, *8
-					tok.u32++;
+				if (*tok == '*')				// ([bd,An/PC],Xn*...)
+				{								// scale: *1, *2, *4, *8
+					tok++;
 
-					if (*tok.u32 == SYMBOL)
+					if (*tok == SYMBOL)
 					{
-						if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+						if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
 							return error("scale factor expression must evaluate");
-						switch (AnEXVAL)
+
+						switch (scaleval)
 						{
 						case 1:
 							break;
@@ -772,48 +807,53 @@ IS_SUPPRESSEDn:
 							goto badmode;
 						}
 					}
-					else if (*tok.u32++ != CONST || *tok.u32 > 8)
+					else if (*tok++ != CONST)
 						goto badmode;
 					else
 					{
-						switch ((int)*tok.u32++)
+						switch ((int)*tok++)
 						{
 						case 1:
 							break;
 						case 2:
 							AnIXSIZ |= TIMES2;
+							AnEXTEN |= 1 << 9;
 							break;
 						case 4:
 							AnIXSIZ |= TIMES4;
+							AnEXTEN |= 2 << 9;
 							break;
 						case 8:
 							AnIXSIZ |= TIMES8;
+							AnEXTEN |= 3 << 9;
 							break;
 						default:
 							goto badmode;
 						}
+
+						tok++;  // Take into account that constants are 64-bit
 					}
 				}
 
-				//Check for ]
-				if (*tok.u32 != ']')
+				// Check for ]
+				if (*tok != ']')
 					return error("Expected closing bracket ]");
-				tok.u32++;			// Eat the bracket
+				tok++;			// Eat the bracket
 
-				//Check for od
-				if (*tok.u32 == ')')	// ([bd,An/PC,Xn]...
+				// Check for od
+				if (*tok == ')')	// ([bd,An/PC,Xn]...
 				{
-					//od is non existant, get out of jail free card
+					// od is non existent, get out of jail free card
 					//AnEXVAL=0;		// zero outer displacement
 					AMn = MEMPRE;			// let's say it's ([bd,An,Xn],od) with od suppressed then
 					AnEXTEN |= EXT_IISPREN; // No outer displacement
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
-                else if (*tok.u32++ != ',')
+				else if (*tok++ != ',')
 					return error("comma expected after ]");
 
-				if (*tok.u32 == SYMBOL || *tok.u32 == CONST)
+				if (*tok == SYMBOL || *tok == CONST)
 				{
 					if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
 						goto badmode;
@@ -823,17 +863,17 @@ IS_SUPPRESSEDn:
 						// od=0 so optimise it out
 						AMn = MEMPRE;		 // let's say it's ([bd,An],Xn,od) with od=0 then
 						AnEXTEN |= EXT_IISPRE0; // No outer displacement
-						tok.u32++;
+						tok++;
 						goto AnOK;
 					}
 				}
 
 				// ([bd,An/PC,Xn],od)
-				if (*tok.u32 == DOTL)
+				if (*tok == DOTL)
 				{
 					// expr.L
 					AMn = MEMPRE;
-					tok.u32++;
+					tok++;
 					AnEXTEN |= EXT_IISPREL;
 				}
 				else
@@ -849,7 +889,7 @@ IS_SUPPRESSEDn:
 
 						// Defined, absolute values from $FFFF8000..$00007FFF
 						// get optimized to absolute short
-                        if (CHECK_OPTS(OPT_BASE_DISP)
+						if (CHECK_OPTS(OPT_BASE_DISP)
 							&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
 							&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
 						{
@@ -861,9 +901,9 @@ IS_SUPPRESSEDn:
 					AnEXTEN |= expr_size; // Assume we have a .w value
 
 					// Is .W forced here?
-					if (*tok.u32 == DOTW)
+					if (*tok == DOTW)
 					{
-						tok.u32++;
+						tok++;
 
 						if (expr_size == EXT_IISPREL)
 							return error("outer displacement value does not fit in .w size");
@@ -871,9 +911,9 @@ IS_SUPPRESSEDn:
 				}
 
 				// Check for final closing parenthesis
-				if (*tok.u32 == ')')
+				if (*tok == ')')
 				{
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
 				else
@@ -890,46 +930,156 @@ IS_SUPPRESSEDn:
 
 			// It could be that this is really just an expression prefixing a
 			// register as a displacement...
-			if (*tok.u32 == ')')
+			if (*tok == ')')
 			{
-				tok.u32++;
+				tok++;
 				goto CHK_FOR_DISPn;
 			}
 
 			// Otherwise, check for PC & etc displacements...
-			if (*tok.u32++ != ',')
+			if (*tok++ != ',')
 				goto badmode;
 
-			if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7))
+			if ((*tok >= KW_A0) && (*tok <= KW_A7))
 			{
-				AnREG = *tok.u32 & 7;
-				tok.u32++;
+				AnREG = *tok & 7;
+				tok++;
 
-				if (*tok.u32 == ',')
+				if (*tok == ',')
 				{
+					// Check if we're actually doing d8(An,Dn) or
+					// (d16,An,Dn[.size][*scale])
+					// TODO: not a very clear cut case from what I can think.
+					// The only way to distinguish between the two is to check
+					// AnEXVAL and see if it's >127 or <-128. But this doesn't
+					// work if AnEXVAL isn't defined yet. For now we fall
+					// through to d8(An,Dn) but this might bite us in the arse
+					// during fixups...
+					if ((AnEXATTR & DEFINED) && (AnEXVAL + 0x80 > 0x100))
+					{
+						// We're going to treat it as a full extension format
+						// with no indirect access and no base displacement/
+						// index register suppression
+						AnEXTEN |= EXT_FULLWORD;	// Definitely using full extension format, so set bit 8
+						AnEXTEN |= EXT_IISPRE0;		// No Memory Indirect Action
+						AnEXTEN |= EXT_BDSIZEL;		// Base Displacement Size Long
+						tok++;						// Get past the comma
+
+						// Our expression is techically a base displacement,
+						// so let's copy it to the relevant variables so
+						// eagen0.c can pick it up properly
+						//AnBEXPR = AnEXPR;
+						AnBEXVAL = AnEXVAL;
+						AnBEXATTR = AnEXATTR;
+
+						if ((*tok >= KW_D0) && (*tok <= KW_D7))
+						{
+							AnEXTEN |= ((*tok++) & 7) << 12;
+							// Check for size
+							{
+								switch ((int)*tok)
+								{
+								// Index reg size: <empty> | .W | .L
+								case DOTW:
+									tok++;
+									break;
+								default:
+									break;
+								case DOTL:
+									tok++;
+									AnEXTEN |= EXT_L;
+									break;
+								case DOTB:
+									// .B not allowed here...
+									goto badmode;
+								}
+							}
+							// Check for scale
+							if (*tok == '*')		// ([bd,An/PC],Xn*...)
+							{						// scale: *1, *2, *4, *8
+								tok++;
+
+								if (*tok == SYMBOL)
+								{
+									if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
+										return error("scale factor expression must evaluate");
+
+									switch (scaleval)
+									{
+									case 1:
+										break;
+									case 2:
+										AnIXSIZ |= TIMES2;
+										break;
+									case 4:
+										AnIXSIZ |= TIMES4;
+										break;
+									case 8:
+										AnIXSIZ |= TIMES8;
+										break;
+									default:
+										goto badmode;
+									}
+								}
+								else if (*tok++ != CONST)
+									goto badmode;
+								else
+								{
+									switch ((int)*tok++)
+									{
+									case 1:
+										break;
+									case 2:
+										AnIXSIZ |= TIMES2;
+										break;
+									case 4:
+										AnIXSIZ |= TIMES4;
+										break;
+									case 8:
+										AnIXSIZ |= TIMES8;
+										break;
+									default:
+										goto badmode;
+									}
+
+									tok++;  // Take into account that constants are 64-bit
+								}
+							}
+
+							if (*tok++ != ')')
+								return error("Closing parenthesis missing on addressing mode");
+
+							// Let's say that this is the closest to our case
+							AMn = MEMPOST;
+							goto AnOK;
+						}
+						else
+							goto badmode;
+					}
+
 					AMn = AINDEXED;
 					goto AMn_IXN;
 				}
-				else if (*tok.u32 == ')')
+				else if (*tok == ')')
 				{
 					AMn = ADISP;
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
 				else
 					goto badmode;
 			}
-			else if (*tok.u32 == KW_PC)
+			else if (*tok == KW_PC)
 			{
-				if (*++tok.u32 == ',')
+				if (*++tok == ',')
 				{                             // expr(PC,Xn...)
 					AMn = PCINDEXED;
 					goto AMn_IXN;
 				}
-				else if (*tok.u32 == ')')
+				else if (*tok == ')')
 				{
 					AMn = PCDISP;             // expr(PC)
-					tok.u32++;
+					tok++;
 					goto AnOK;
 				}
 				else
@@ -939,56 +1089,56 @@ IS_SUPPRESSEDn:
 				goto badmode;
 		}
 	}
-	else if (*tok.u32 == '-' && tok.u32[1] == '(' && ((tok.u32[2] >= KW_A0) && (tok.u32[2] <= KW_A7)) && tok.u32[3] == ')')
+	else if (*tok == '-' && tok[1] == '(' && ((tok[2] >= KW_A0) && (tok[2] <= KW_A7)) && tok[3] == ')')
 	{
 		AMn = APREDEC;
-		AnREG = tok.u32[2] & 7;
-		tok.u32 += 4;
+		AnREG = tok[2] & 7;
+		tok += 4;
 	}
-	else if (*tok.u32 == KW_CCR)
+	else if (*tok == KW_CCR)
 	{
 		AMn = AM_CCR;
-		tok.u32++;
+		tok++;
 		goto AnOK;
 	}
-	else if (*tok.u32 == KW_SR)
+	else if (*tok == KW_SR)
 	{
 		AMn = AM_SR;
-		tok.u32++;
+		tok++;
 		goto AnOK;
 	}
-	else if (*tok.u32 == KW_USP)
+	else if (*tok == KW_USP)
 	{
 		AMn = AM_USP;
-		tok.u32++;
-		AnREG = 2;	//Added this for the case of USP used in movec (see CREGlut in mach.c). Hopefully nothing gets broken!
+		tok++;
+		AnREG = 2;	// Added this for the case of USP used in movec (see CREGlut in mach.c). Hopefully nothing gets broken!
 		goto AnOK;
 	}
-	else if ((*tok.u32 >= KW_IC40) && (*tok.u32 <= KW_BC40))
+	else if ((*tok >= KW_IC40) && (*tok <= KW_BC40))
 	{
 		AMn = CACHES;
-		AnREG = *tok.u32++ - KW_IC40;
+		AnREG = *tok++ - KW_IC40;
 
 		// After a cache keyword only a comma or EOL is allowed
-		if ((*tok.u32 != ',') && (*tok.u32 != EOL))
+		if ((*tok != ',') && (*tok != EOL))
 			return ERROR;
 		goto AnOK;
 	}
-	else if ((*tok.u32 >= KW_SFC) && (*tok.u32 <= KW_CRP))
+	else if ((*tok >= KW_SFC) && (*tok <= KW_CRP))
 	{
 		AMn = CREG;
-		AnREG = (*tok.u32++) - KW_SFC;
+		AnREG = (*tok++) - KW_SFC;
 		goto AnOK;
 	}
-	else if ((*tok.u32 >= KW_FP0) && (*tok.u32 <= KW_FP7))
+	else if ((*tok >= KW_FP0) && (*tok <= KW_FP7))
 	{
 		AMn = FREG;
-		AnREG = (*tok.u32++ & 7);
+		AnREG = (*tok++ & 7);
 	}
-	else if ((*tok.u32 >= KW_FPIAR) && (*tok.u32 <= KW_FPCR))
+	else if ((*tok >= KW_FPIAR) && (*tok <= KW_FPCR))
 	{
 		AMn = FPSCR;
-		AnREG = (1 << ((*tok.u32++) - KW_FPIAR + 10));
+		AnREG = (1 << ((*tok++) - KW_FPIAR + 10));
 	}
 	// expr
 	// expr.w
@@ -1003,10 +1153,10 @@ IS_SUPPRESSEDn:
 			return ERROR;
 
 CHK_FOR_DISPn:
-		if (*tok.u32 == DOTW)
+		if (*tok == DOTW)
 		{
 			// expr.W
-			tok.u32++;
+			tok++;
 			AMn = ABSW;
 
 			if (((AnEXATTR & (TDB | DEFINED)) == DEFINED) && (AnEXVAL < 0x10000))
@@ -1014,55 +1164,57 @@ CHK_FOR_DISPn:
 
 			goto AnOK;
 		}
-		else if (*tok.u32 != '(')
+		else if (*tok != '(')
 		{
 			// expr[.L]
 			AMn = ABSL;
 
-			// Defined, absolute values from $FFFF8000..$00007FFF get optimized
-			// to absolute short
-			if (CHECK_OPTS(OPT_ABS_SHORT)
-				&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
-				&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
+			// .L is forced here
+			if (*tok == DOTL)
 			{
-				AMn = ABSW;
-
-				if (sbra_flag)
-					warn("absolute value from $FFFF8000..$00007FFF optimised to absolute short");
+				tok++;
+				AMn = ABSL;
 			}
-
-			// Is .L forced here?
-			if (*tok.u32 == DOTL)
+			else
 			{
-				tok.u32++;
-				AMn = ABSL;
+				// Defined, absolute values from $FFFF8000..$00007FFF get
+				// optimized to absolute short
+				if (CHECK_OPTS(OPT_ABS_SHORT)
+					&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
+					&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
+				{
+					AMn = ABSW;
+
+					if (sbra_flag)
+						warn("absolute value from $FFFF8000..$00007FFF optimised to absolute short");
+				}
 			}
 
 			goto AnOK;
 		}
 
-		tok.u32++;
+		tok++;
 
-		if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7))
+		if ((*tok >= KW_A0) && (*tok <= KW_A7))
 		{
-			AnREG = *tok.u32++ & 7;
+			AnREG = *tok++ & 7;
 
-			if (*tok.u32 == ')')
+			if (*tok == ')')
 			{
 				AMn = ADISP;
-				tok.u32++;
+				tok++;
 				goto AnOK;
 			}
 
 			AMn = AINDEXED;
 			goto AMn_IXN;
 		}
-		else if (*tok.u32 == KW_PC)
+		else if (*tok == KW_PC)
 		{
-			if (*++tok.u32 == ')')
+			if (*++tok == ')')
 			{
 				AMn = PCDISP;
-				tok.u32++;
+				tok++;
 				goto AnOK;
 			}