]> Shamusworld >> Repos - rmac/blobdiff - parmode.h
Version bump (1.8.2) for last commit.
[rmac] / parmode.h
index 5ad5da90e1240e21bcd37da69a889228af048082..5f475dbf5a20753603b9c98b8fd2222b99ffb301 100644 (file)
--- a/parmode.h
+++ b/parmode.h
                        else if (*tok == 'L')
                        {
                                // TODO: does DINDL gets used at all?
-                               //AMn=DINDL;                                     // (Dn.l)
-                               //AnEXTEN = 1 << 1;   // Long index size
-                               //tok++;
+                               AMn=DINDL;                                     // (Dn.l)
+                               AnEXTEN = 1 << 1;   // Long index size
+                               tok++;
                        }
                        else if (*tok == 'W')                                // (Dn.w)
                        {
                                // TODO: does DINDW gets used at all?
-                               //AMn=DINDW;
-                               //AnEXTEN = 1 << 1;   // Word index size
-                               //tok++;
+                               AMn=DINDW;
+                               AnEXTEN = 1 << 1;   // Word index size
+                               tok++;
                        }
                        else if (*tok == ',')
                        {
                                goto CHECKODn;
                        }
                        else
+                       {
                                return error("(Dn) error");
+                       }
+
+                       if (*tok == '*')
+                       {                        // scale: *1, *2, *4, *8
+                               tok++;
+
+                               if (*tok == SYMBOL)
+                               {
+                                       if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+                                               return error("scale factor expression must evaluate");
+
+                                       switch (AnEXVAL)
+                                       {
+                                       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 || *tok > 8)
+                                       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;
+                                       }
+                               }
+                       }
 
                        if (*tok == ')')
                        {
                                AMn = MEMPOST;
                                goto AnOK;
                        }
+                       else if (*tok==',')
+                       {
+                               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...
+                               goto CHECKODn;
+                       }
                        else
                                return error("unhandled so far");
                }
                        {                        // scale: *1, *2, *4, *8
                                tok++;
 
-                               if (*tok++ != CONST || *tok > 8)
-                                       goto badmode;
+                               if (*tok == SYMBOL)
+                               {
+                                       if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+                                               return error("scale factor expression must evaluate");
 
-                               switch ((int)*tok++)
-                               {
-                               case 1:
-                                       break;
-                               case 2:
-                                       AnIXSIZ |= TIMES2;
-                                       break;
-                               case 4:
-                                       AnIXSIZ |= TIMES4;
-                                       break;
-                               case 8:
-                                       AnIXSIZ |= TIMES8;
-                                       break;
-                               default:
+                                       switch (AnEXVAL)
+                                       {
+                                       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 || *tok > 8)
                                        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;
+                                       }
                                }
                        }
 
+                       if (*tok == ',')
+                       {
+                               tok++;
+                               goto CHECKODn;
+                       }
                        if (*tok++ != ')')         // final ")"
                                goto badmode;
 
                                        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)
                                        {
 
                                // Check for scale
                                if (*tok == '*')                        // ([bd,An/PC],Xn*...)
-                               {
+                               {                           // scale: *1, *2, *4, *8
                                        tok++;
 
-                                       if (*tok == CONST)      // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed?
-                                               tok++;
-
-                                       switch ((int)*tok++)
+                                       if (*tok == SYMBOL)
                                        {
-                                       case 1:
-                                               break;
-                                       case 2:
-                                               AnEXTEN |= EXT_TIMES2;
-                                               break;
-                                       case 4:
-                                               AnEXTEN |= EXT_TIMES4;
-                                               break;
-                                       case 8:
-                                               AnEXTEN |= EXT_TIMES8;
-                                               break;
-                                       default:
+                                               if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+                                                       return error("scale factor expression must evaluate");
+                                               switch (AnEXVAL)
+                                               {
+                                               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 || *tok > 8)
                                                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;
+                                               }
                                        }
                                }
-
                                if (*tok == ']')  // ([bd,Dn]...
                                {
                                        tok++;
                                if (*tok == ')')
                                {
                                        //Xn and od are non existent, get out of jail free card
+                                       tok++;
                                        AMn = MEMPRE;                   // ([bc,An,Xn],od) with no Xn and od
                                        AnEXTEN |= EXT_IS | EXT_IISPREN;        //Suppress Xn and od
-                                       tok++;
                                        goto AnOK;
                                }
                                else if (*tok != ',')
                                {
                                        //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
                                }
 
                                // Check for scale
-                               if (*tok == '*')
-                               {
-                                       // ([bd,An/PC],Xn*...)
+                               if (*tok == '*')                   // ([bd,An/PC],Xn*...)
+                               {                                  // scale: *1, *2, *4, *8
                                        tok++;
 
-                                       if (*tok == CONST)      // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed?
-                                               tok++;
-
-                                       switch ((int)*tok++)
+                                       if (*tok == SYMBOL)
                                        {
-                                       case 1:
-                                               break;
-                                       case 2:
-                                               AnEXTEN |= EXT_TIMES2;
-                                               break;
-                                       case 4:
-                                               AnEXTEN |= EXT_TIMES4;
-                                               break;
-                                       case 8:
-                                               AnEXTEN |= EXT_TIMES8;
-                                               break;
-                                       default:
+                                               if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+                                                       return error("scale factor expression must evaluate");
+
+                                               switch (AnEXVAL)
+                                               {
+                                               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 || *tok > 8)
                                                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++;  // eat the comma
 
                                CHECKODn:
-
                                if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
                                        goto badmode;
 
                                        tok++;
                                        goto AnOK;
                                }
-
                                // ([bd,An/PC],Xn,od)
                                if (*tok == DOTL)
                                {
                                        // expr.L
                                        AnEXTEN |= EXT_IISPOSL; // Long outer displacement
                                        AMn = MEMPOST;
+                                       tok++;
 
                                        // Defined, absolute values from $FFFF8000..$00007FFF get
                                        // optimized to absolute short
                                        // expr[.W][]
                                        AnEXTEN |= EXT_IISNOIW; // Word outer displacement with IS suppressed
                                        AMn = MEMPRE;
-
                                        if (*tok == DOTW)
                                        {
                                                //AnEXTEN|=EXT_IISNOIW; // Word outer displacement
 
                                // Check for scale
                                if (*tok == '*')                        // ([bd,An/PC],Xn*...)
-                               {
+                               {                           // scale: *1, *2, *4, *8
                                        tok++;
 
-                                       if (*tok == CONST)      // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed?
-                                               tok++;
-
-                                       switch ((int)*tok++)
+                                       if (*tok == SYMBOL)
                                        {
-                                       case 1:
-                                               break;
-                                       case 2:
-                                               AnEXTEN |= EXT_TIMES2;
-                                               break;
-                                       case 4:
-                                               AnEXTEN |= EXT_TIMES4;
-                                               break;
-                                       case 8:
-                                               AnEXTEN |= EXT_TIMES8;
-                                               break;
-                                       default:
+                                               if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+                                                       return error("scale factor expression must evaluate");
+                                               switch (AnEXVAL)
+                                               {
+                                               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 || *tok > 8)
                                                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;
+                                               }
                                        }
                                }
 
                                //Check for ]
                                if (*tok != ']')
                                        return error("Expected closing bracket ]");
-
                                tok++;                  // Eat the bracket
 
                                //Check for od
                                }
                                else if (*tok == ')')
                                {
-                                       AMn = PCDISP;                                // expr(PC)
+                                       AMn = PCDISP;             // expr(PC)
                                        tok++;
                                        goto AnOK;
                                }
                // After a cache keyword only a comma or EOL is allowed
                if ((*tok != ',') && (*tok != EOL))
                        return ERROR;
-
                goto AnOK;
        }
        else if ((*tok >= KW_SFC) && (*tok <= KW_CRP))
@@ -903,6 +1055,7 @@ CHK_FOR_DISPn:
                        AMn = PCINDEXED;
                        goto AMn_IXN;
                }
+
                goto badmode;
        }