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

diff --git a/parmode.h b/parmode.h
index 20f0973..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
 //
@@ -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
@@ -211,12 +213,12 @@
 			// 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++ != ',')
 				goto badmode;
@@ -249,6 +251,7 @@
 				{
 					if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
 						return error("scale factor expression must evaluate");
+
 					switch (scaleval)
 					{
 					case 1:
@@ -318,18 +321,21 @@
 			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 == DOTL)
-				{						// ([bd.l,...
-						AnEXTEN |= EXT_BDSIZEL;
-						tok++;
+				{
+					// ([bd.l,...
+					AnEXTEN |= EXT_BDSIZEL;
+					tok++;
 				}
 				else
-				{						// ([bd[.w],... or ([bd,...
+				{
+					// ([bd[.w],... or ([bd,...
 					// Is .W forced here?
 					if (*tok == DOTW)
 					{
@@ -338,8 +344,8 @@
 					}
 					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))
@@ -370,7 +376,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))
@@ -383,24 +389,22 @@
 				tok++;
 
 				// 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:
-						tok++;
-						break;
-					default:
-						break;
-					case DOTL:
-						AnEXTEN |= EXT_L;
-						tok++;
-						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
@@ -513,24 +517,22 @@
 				}
 
 				// 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:
-						tok++;
-						break;
-					default:
-						break;
-					case DOTL:
-						AnEXTEN |= EXT_L;
-						tok++;
-						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
@@ -599,11 +601,11 @@
 				else
 					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
@@ -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++;
 
@@ -640,9 +661,7 @@
 
 					// Is .W forced here?
 					if (*tok == DOTW)
-					{
 						tok++;
-					}
 				}
 
 				// Check for final closing parenthesis
@@ -726,9 +745,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);
@@ -743,35 +762,34 @@ IS_SUPPRESSEDn:
 				}
 
 				// Check for size
-				{
 				// ([bd,An/PC],Xn.W/L...)
 				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;
-					}
+				{
+				// 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
+				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:
@@ -929,6 +947,116 @@ 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;
 				}
@@ -1041,24 +1169,26 @@ CHK_FOR_DISPn:
 			// 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))
-			{
-				AMn = ABSW;
-
-				if (sbra_flag)
-					warn("absolute value from $FFFF8000..$00007FFF optimised to absolute short");
-			}
-
-			// Is .L forced here?
+			// .L is forced here
 			if (*tok == DOTL)
 			{
 				tok++;
 				AMn = ABSL;
 			}
+			else
+			{
+				// 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;
 		}