]> Shamusworld >> Repos - rmac/blobdiff - parmode.h
Version bump (1.8.4) for last commit.
[rmac] / parmode.h
index e623084b252fb9928d33d7dd9170fc8a3c4b22ea..60eca336079551b416c3c43e8fab9c5429277b14 100644 (file)
--- a/parmode.h
+++ b/parmode.h
                                {
                                        if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
                                                return error("scale factor expression must evaluate");
+
                                        switch (AnEXVAL)
                                        {
                                        case 1:
                                                break;
                                        default:
                                                goto badmode;
-                       }
+                                       }
                                }
                                else if (*tok++ != CONST || *tok > 8)
                                        goto badmode;
                        }
 
                        if (*tok == '*')
-                       {                                  // scale: *1, *2, *4, *8
+                       {                        // scale: *1, *2, *4, *8
                                tok++;
 
                                if (*tok == SYMBOL)
                        tok++;
                        AnEXTEN|=EXT_FULLWORD;     //Definitely using full extension format, so set bit 8
                        // Check to see if base displacement is present
-                       //WARNING("expr will return a bad expression error here but this is expected, it needs to be silenced!");
                        if (*tok!=CONST && *tok !=SYMBOL)
-                       //if (expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM) != OK)
                        {
                                AnEXTEN|=EXT_BDSIZE0;
-                               //tok++;
-                               //tok--;                 //Rewind tok since expr advances it forward
                        }
                        else
                        {
                                expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM);
-                               if (optim_flags[OPT_BASE_DISP] && AnBEXVAL==0 && AnEXATTR!=0)
+                               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,...
+                               {                                               // ([bd.l,...
                                                AnEXTEN|=EXT_BDSIZEL;
                                                tok++;
                                }
                                else
-                               {                                                  // ([bd[.w],... or ([bd,...
+                               {                                               // ([bd[.w],... or ([bd,...
                                        // Is .W forced here?
                                        if (*tok == DOTW)
                                        {
                                        {
                                                // Defined, absolute values from $FFFF8000..$00007FFF get optimized
                                                // to absolute short
-                                               if (optim_flags[OPT_ABS_SHORT]
+                                               if (CHECK_OPTS(OPT_ABS_SHORT)
                                                        && ((AnBEXATTR & (TDB | DEFINED)) == DEFINED)
                                                        && ((AnBEXVAL + 0x8000) < 0x10000))
                                                {
                                {
                                        //No index found, suppress it
                                        AnEXTEN |= EXT_IS;
-                                       tok--;                                                  // Rewind tok to point to the comma
-                                       goto IS_SUPPRESSEDn;                    // https://xkcd.com/292/ - what does he know anyway?
+                                       tok--;                                  // Rewind tok to point to the comma
+                                       goto IS_SUPPRESSEDn;    // https://xkcd.com/292/ - what does he know anyway?
                                }
 
                                // Check for size
                                        {
                                                if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
                                                        return error("scale factor expression must evaluate");
+
                                                switch (AnEXVAL)
-                                       {
-                                       case 1:
-                                               break;
-                                       case 2:
+                                               {
+                                               case 1:
+                                                       break;
+                                               case 2:
                                                        AnIXSIZ |= TIMES2;
-                                               break;
-                                       case 4:
+                                                       break;
+                                               case 4:
                                                        AnIXSIZ |= TIMES4;
-                                               break;
-                                       case 8:
+                                                       break;
+                                               case 8:
                                                        AnIXSIZ |= TIMES8;
-                                               break;
-                                       default:
-                                               goto badmode;
+                                                       break;
+                                               default:
+                                                       goto badmode;
                                                }
                                        }
                                        else if (*tok++ != CONST || *tok > 8)
                                if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
                                        goto badmode;
 
-                               if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0))
+                               if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0))
                                {
                                        // od=0 so optimise it out
                                        AMn = MEMPOST;           // let's say it's ([bd,An],Xn,od) with od=0 then
 
                                        // Defined, absolute values from $FFFF8000..$00007FFF get
                                        // optimized to absolute short
-                                       if (optim_flags[OPT_ABS_SHORT]
+                                       if (CHECK_OPTS(OPT_ABS_SHORT)
                                                && ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
                                                && ((AnEXVAL + 0x8000) < 0x10000))
                                        {
 
                                expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM);
 
-                               if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0))
+                               if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0))
                                {
                                        // od=0 so optimise it out
                                        AMn = MEMPOST;           // let's say it's ([bd,An],Xn,od) with od=0 then
 
                                        // Defined, absolute values from $FFFF8000..$00007FFF get
                                        // optimized to absolute short
-                                       else if (optim_flags[OPT_BASE_DISP]
+                                       else if (CHECK_OPTS(OPT_BASE_DISP)
                                                && ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
                                                && ((AnEXVAL + 0x8000) < 0x10000))
                                        {
                                        tok++;
                                        goto AnOK;
                                }
-                               else if (*tok++!=',')
+                else if (*tok++ != ',')
                                        return error("comma expected after ]");
 
-                               WARNING(Put symbol and constant checks here!)
-
-                               if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
-                                       goto badmode;
-
-                               if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0))
+                               if (*tok == SYMBOL || *tok == CONST)
                                {
-                                       // 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++;
-                                       goto AnOK;
+                                       if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+                                               goto badmode;
+
+                                       if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0) && (AnEXATTR & DEFINED))
+                                       {
+                                               // 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++;
+                                               goto AnOK;
+                                       }
                                }
 
                                // ([bd,An/PC,Xn],od)
                                else
                                {
                                        // expr.[W]
-                                       //tok++;
-
-                                       AnEXTEN |= EXT_IISPREW;
                                        AMn = MEMPRE;
+                                       int expr_size = EXT_IISPREW; // Assume we have a .w value
 
-                    // Is .W forced here?
-                                       if (*tok == DOTW)
+                                       if ((AnEXVAL + 0x8000) > 0x10000)
                                        {
-                                               tok++;
+                                               // Long value, so mark it as such for now
+                                               expr_size = EXT_IISPREL;
+
+                                               // Defined, absolute values from $FFFF8000..$00007FFF
+                                               // get optimized to absolute short
+                        if (CHECK_OPTS(OPT_BASE_DISP)
+                                                       && ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
+                                                       && ((AnEXVAL + 0x8000) < 0x10000))
+                                               {
+                                                       expr_size = EXT_IISPREW;
+                                                       warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
+                                               }
                                        }
 
-                                       // Defined, absolute values from $FFFF8000..$00007FFF get optimized
-                                       // to absolute short
-                                       else if (optim_flags[OPT_BASE_DISP]
-                                               && ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
-                                               && ((AnEXVAL + 0x8000) < 0x10000))
+                                       AnEXTEN |= expr_size; // Assume we have a .w value
+
+                                       // Is .W forced here?
+                                       if (*tok == DOTW)
                                        {
-                                               AnEXTEN |= EXT_IISPREW;
-                                               warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
+                                               tok++;
+
+                                               if (expr_size == EXT_IISPREL)
+                                                       return error("outer displacement value does not fit in .w size");
                                        }
                                }
 
                                }
                                else if (*tok == ')')
                                {
-                                       AMn = PCDISP;                                // expr(PC)
+                                       AMn = PCDISP;             // expr(PC)
                                        tok++;
                                        goto AnOK;
                                }
@@ -1004,7 +1012,7 @@ CHK_FOR_DISPn:
 
                        // Defined, absolute values from $FFFF8000..$00007FFF get optimized
                        // to absolute short
-                       if (optim_flags[OPT_ABS_SHORT]
+                       if (CHECK_OPTS(OPT_ABS_SHORT)
                                && ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
                                && ((AnEXVAL + 0x8000) < 0x10000))
                        {
@@ -1052,6 +1060,7 @@ CHK_FOR_DISPn:
                        AMn = PCINDEXED;
                        goto AMn_IXN;
                }
+
                goto badmode;
        }