X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=parmode.h;h=0c5d66dd655f8005d0d360e6f09dae92a8055e63;hb=0951a3e28907fbaf89a10c5201b71d8080ffe5a8;hp=20f0973becf494dc445bbc689c45cb36c28882d9;hpb=8a5d76b0e6c7433cdbdf3d612da5c209516cb594;p=rmac

diff --git a/parmode.h b/parmode.h
index 20f0973..0c5d66d 100644
--- a/parmode.h
+++ b/parmode.h
@@ -197,7 +197,9 @@
 				// 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
@@ -370,7 +372,7 @@
 			}
 			else if ((*tok >= KW_A0) && (*tok <= KW_A7))
 			{					// ([bd,An,...
-				AnREG = (6 << 3) | *tok & 7;
+				AnREG = (6 << 3) | (*tok & 7);
 				tok++;
 			}
 			else if ((*tok >= KW_D0) && (*tok <= KW_D7))
@@ -603,7 +605,7 @@
 				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
@@ -616,7 +618,26 @@
 				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++;
 
@@ -726,9 +747,9 @@ IS_SUPPRESSEDn:
 			}
 			else if (*tok == ',')
 			{
-				*tok++;			// ([bd,An,Xn.size*scale],od)
+				tok++;			// ([bd,An,Xn.size*scale],od)
 
-				//Check for Xn
+				// Check for Xn
 				if ((*tok >= KW_A0) && (*tok <= KW_A7))
 				{
 					AnEXTEN |= ((*tok & 7) << 12);
@@ -744,8 +765,8 @@ IS_SUPPRESSEDn:
 
 				// Check for size
 				{
-				// ([bd,An/PC],Xn.W/L...)
-				switch ((int)*tok)
+					// ([bd,An/PC],Xn.W/L...)
+					switch ((int)*tok)
 					{
 					// Index reg size: <empty> | .W | .L
 					case DOTW:
@@ -764,8 +785,8 @@ IS_SUPPRESSEDn:
 				}
 
 				// Check for scale
-				if (*tok == '*')			// ([bd,An/PC],Xn*...)
-				{                           // scale: *1, *2, *4, *8
+				if (*tok == '*')				// ([bd,An/PC],Xn*...)
+				{								// scale: *1, *2, *4, *8 
 					tok++;
 
 					if (*tok == SYMBOL)
@@ -929,6 +950,112 @@ IS_SUPPRESSEDn:
 
 				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;
 				}