Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /* code6805.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator 68(HC)05/08                                                 */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12.  
  13. #include <string.h>
  14. #include <ctype.h>
  15.  
  16. #include "bpemu.h"
  17. #include "strutil.h"
  18.  
  19. #include "asmdef.h"
  20. #include "asmpars.h"
  21. #include "asmsub.h"
  22. #include "asmitree.h"
  23. #include "motpseudo.h"
  24. #include "codepseudo.h"
  25. #include "intpseudo.h"
  26. #include "codevars.h"
  27. #include "errmsg.h"
  28.  
  29. #include "code6805.h"
  30.  
  31. typedef struct
  32. {
  33.   CPUVar MinCPU;
  34.   Byte Code;
  35. } BaseOrder;
  36.  
  37. typedef struct
  38. {
  39.   CPUVar MinCPU;
  40.   Byte Code;
  41.   Word Mask;
  42.   tSymbolSize Size;
  43. } ALUOrder;
  44.  
  45. typedef struct
  46. {
  47.   CPUVar MinCPU;
  48.   Byte Code;
  49.   Word Mask;
  50. } RMWOrder;
  51.  
  52. enum
  53. {
  54.   ModNone = -1,
  55.   ModImm = 0,
  56.   ModDir = 1,
  57.   ModExt = 2,
  58.   ModIx2 = 3,
  59.   ModIx1 = 4,
  60.   ModIx = 5,
  61.   ModSP2 = 6,
  62.   ModSP1 = 7,
  63.   ModIxP = 8
  64. };
  65.  
  66. #define MModImm (1 << ModImm)
  67. #define MModDir (1 << ModDir)
  68. #define MModExt (1 << ModExt)
  69. #define MModIx2 (1 << ModIx2)
  70. #define MModIx1 (1 << ModIx1)
  71. #define MModIx  (1 << ModIx)
  72. #define MModSP2 (1 << ModSP2)
  73. #define MModSP1 (1 << ModSP1)
  74. #define MModIxP (1 << ModIxP)
  75. #define MMod05 (MModImm | MModDir | MModExt | MModIx2 | MModIx1 | MModIx)
  76. #define MMod08 (MModSP2 | MModSP1 | MModIxP)
  77.  
  78. static ShortInt AdrMode;
  79. static Byte AdrVals[2];
  80.  
  81. static IntType AdrIntType;
  82.  
  83. static CPUVar CPU6805, CPU68HC05, CPU68HC08, CPU68HCS08;
  84.  
  85. static BaseOrder *FixedOrders;
  86. static BaseOrder *RelOrders;
  87. static RMWOrder *RMWOrders;
  88. static ALUOrder *ALUOrders;
  89.  
  90. /*--------------------------------------------------------------------------*/
  91. /* address parser */
  92.  
  93.  
  94. static unsigned ChkZero(char *s, Byte *pErg)
  95. {
  96.   if (*s == '<')
  97.   {
  98.     *pErg = 2;
  99.     return 1;
  100.   }
  101.   else if (*s == '>')
  102.   {
  103.     *pErg = 1;
  104.     return 1;
  105.   }
  106.   else
  107.   {
  108.     *pErg = 0;
  109.     return 0;
  110.   }
  111. }
  112.  
  113. static void DecodeAdr(Byte Start, Byte Stop, tSymbolSize op_size, Word Mask)
  114. {
  115.   Boolean OK;
  116.   tSymbolFlags Flags;
  117.   Word AdrWord, Mask08;
  118.   Byte ZeroMode;
  119.   unsigned Offset;
  120.   ShortInt tmode1, tmode2;
  121.  
  122.   AdrMode = ModNone;
  123.   AdrCnt = 0;
  124.  
  125.   Mask08 = Mask & MMod08;
  126.   if (MomCPU == CPU6805)
  127.     Mask &= MMod05;
  128.  
  129.   if (Stop - Start == 1)
  130.   {
  131.     if (!as_strcasecmp(ArgStr[Stop].str.p_str, "X"))
  132.     {
  133.       tmode1 = ModIx1;
  134.       tmode2 = ModIx2;
  135.     }
  136.     else if (!as_strcasecmp(ArgStr[Stop].str.p_str,"SP"))
  137.     {
  138.       tmode1 = ModSP1;
  139.       tmode2 = ModSP2;
  140.       if (MomCPU < CPU68HC08)
  141.       {
  142.         WrStrErrorPos(ErrNum_InvReg, &ArgStr[Stop]);
  143.         goto chk;
  144.       }
  145.     }
  146.     else
  147.     {
  148.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[Stop]);
  149.       goto chk;
  150.     }
  151.  
  152.     Offset = ChkZero(ArgStr[Start].str.p_str, &ZeroMode);
  153.     if (ArgStr[Start].str.p_str[0])
  154.       AdrWord = EvalStrIntExpressionOffsWithFlags(&ArgStr[Start], Offset, (ZeroMode == 2) ? Int8 : Int16, &OK, &Flags);
  155.     else
  156.     {
  157.       OK = True;
  158.       AdrWord = 0;
  159.       Flags = eSymbolFlag_None;
  160.     }
  161.  
  162.     if (OK)
  163.     {
  164.       if ((ZeroMode == 0) && (AdrWord == 0) && (Mask & MModIx) && (tmode1 == ModIx1))
  165.         AdrMode = ModIx;
  166.  
  167.       else if (((Mask & (1 << tmode2)) == 0) || (ZeroMode == 2) || ((ZeroMode == 0) && (Hi(AdrWord) == 0)))
  168.       {
  169.         if (mFirstPassUnknown(Flags))
  170.           AdrWord &= 0xff;
  171.         if (Hi(AdrWord) != 0) WrError(ErrNum_NoShortAddr);
  172.         else
  173.         {
  174.           AdrCnt = 1;
  175.           AdrVals[0] = Lo(AdrWord);
  176.           AdrMode = tmode1;
  177.         }
  178.       }
  179.  
  180.       else
  181.       {
  182.         AdrVals[0] = Hi(AdrWord);
  183.         AdrVals[1] = Lo(AdrWord);
  184.         AdrCnt = 2;
  185.         AdrMode = tmode2;
  186.       }
  187.     }
  188.   }
  189.  
  190.   else if (Stop == Start)
  191.   {
  192.     /* Postinkrement */
  193.  
  194.     if (!as_strcasecmp(ArgStr[Start].str.p_str, "X+"))
  195.     {
  196.       AdrMode = ModIxP;
  197.       goto chk;
  198.     }
  199.  
  200.     /* X-indirekt */
  201.  
  202.     if (!as_strcasecmp(ArgStr[Start].str.p_str, "X"))
  203.     {
  204.       WrError(ErrNum_ConvIndX);
  205.       AdrMode = ModIx;
  206.       goto chk;
  207.     }
  208.  
  209.     /* immediate */
  210.  
  211.     if (*ArgStr[Start].str.p_str == '#')
  212.     {
  213.       switch (op_size)
  214.       {
  215.         case eSymbolSizeUnknown:
  216.           WrError(ErrNum_UndefOpSizes);
  217.           break;
  218.         case eSymbolSize8Bit:
  219.           AdrVals[0] = EvalStrIntExpressionOffs(&ArgStr[Start], 1, Int8, &OK);
  220.           if (OK)
  221.           {
  222.             AdrCnt = 1;
  223.             AdrMode = ModImm;
  224.           }
  225.           break;
  226.         case eSymbolSize16Bit:
  227.           AdrWord = EvalStrIntExpressionOffs(&ArgStr[Start], 1, Int16, &OK);
  228.           if (OK)
  229.           {
  230.             AdrVals[0] = Hi(AdrWord);
  231.             AdrVals[1] = Lo(AdrWord);
  232.             AdrCnt = 2;
  233.             AdrMode = ModImm;
  234.           }
  235.           break;
  236.         default:
  237.           break;
  238.       }
  239.       goto chk;
  240.     }
  241.  
  242.     /* absolut */
  243.  
  244.     Offset = ChkZero(ArgStr[Start].str.p_str, &ZeroMode);
  245.     AdrWord = EvalStrIntExpressionOffsWithFlags(&ArgStr[Start], Offset, (ZeroMode == 2) ? UInt8 : AdrIntType, &OK, &Flags);
  246.  
  247.     if (OK)
  248.     {
  249.       if (((Mask & MModExt) == 0) || (ZeroMode == 2) || ((ZeroMode == 0) && (Hi(AdrWord) == 0)))
  250.       {
  251.         if (mFirstPassUnknown(Flags))
  252.           AdrWord &= 0xff;
  253.         if (Hi(AdrWord) != 0) WrError(ErrNum_NoShortAddr);
  254.         else
  255.         {
  256.           AdrCnt = 1;
  257.           AdrVals[0] = Lo(AdrWord);
  258.           AdrMode = ModDir;
  259.         }
  260.       }
  261.       else
  262.       {
  263.         AdrVals[0] = Hi(AdrWord);
  264.         AdrVals[1] = Lo(AdrWord);
  265.         AdrCnt = 2;
  266.         AdrMode = ModExt;
  267.       }
  268.       goto chk;
  269.     }
  270.   }
  271.  
  272.   else
  273.     (void)ChkArgCnt(Start, Start + 1);
  274.  
  275. chk:
  276.   if ((AdrMode != ModNone) && (!(Mask & (1 << AdrMode))))
  277.   {
  278.     if ((1 << AdrMode) & Mask08)
  279.       (void)ChkMinCPUExt(CPU68HC08, ErrNum_AddrModeNotSupported);
  280.     else
  281.       WrError(ErrNum_InvAddrMode);
  282.     AdrMode = ModNone;
  283.     AdrCnt = 0;
  284.   }
  285. }
  286.  
  287. /*--------------------------------------------------------------------------*/
  288. /* instruction parsers */
  289.  
  290. static void DecodeFixed(Word Index)
  291. {
  292.   const BaseOrder *pOrder = FixedOrders + Index;
  293.  
  294.   if (ChkArgCnt(0, 0)
  295.    && ChkMinCPU(pOrder->MinCPU))
  296.   {
  297.     CodeLen = 1;
  298.     BAsmCode[0] = pOrder->Code;
  299.   }
  300. }
  301.  
  302. static void DecodeMOV(Word Index)
  303. {
  304.   UNUSED(Index);
  305.  
  306.   if (ChkArgCnt(2, 2)
  307.    && ChkMinCPU(CPU68HC08))
  308.   {
  309.     DecodeAdr(1, 1, eSymbolSize8Bit, MModImm | MModDir | MModIxP);
  310.     switch (AdrMode)
  311.     {
  312.       case ModImm:
  313.         BAsmCode[1] = AdrVals[0];
  314.         DecodeAdr(2, 2, eSymbolSizeUnknown, MModDir);
  315.         if (AdrMode == ModDir)
  316.         {
  317.           BAsmCode[0] = 0x6e;
  318.           BAsmCode[2] = AdrVals[0];
  319.           CodeLen = 3;
  320.         }
  321.         break;
  322.       case ModDir:
  323.         BAsmCode[1] = AdrVals[0];
  324.         DecodeAdr(2, 2, eSymbolSizeUnknown, MModDir | MModIxP);
  325.         switch (AdrMode)
  326.         {
  327.           case ModDir:
  328.             BAsmCode[0] = 0x4e;
  329.             BAsmCode[2] = AdrVals[0];
  330.             CodeLen = 3;
  331.             break;
  332.           case ModIxP:
  333.             BAsmCode[0] = 0x5e;
  334.             CodeLen = 2;
  335.             break;
  336.         }
  337.         break;
  338.       case ModIxP:
  339.         DecodeAdr(2, 2, eSymbolSizeUnknown, MModDir);
  340.         if (AdrMode == ModDir)
  341.         {
  342.           BAsmCode[0] = 0x7e;
  343.           BAsmCode[1] = AdrVals[0];
  344.           CodeLen = 2;
  345.         }
  346.         break;
  347.     }
  348.   }
  349. }
  350.  
  351. static void DecodeRel(Word Index)
  352. {
  353.   BaseOrder *pOrder = RelOrders + Index;
  354.   Boolean OK;
  355.   tSymbolFlags Flags;
  356.   LongInt AdrInt;
  357.  
  358.   if (ChkArgCnt(1, 1)
  359.    && ChkMinCPU(pOrder->MinCPU))
  360.   {
  361.     AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[1], AdrIntType, &OK, &Flags) - (EProgCounter() + 2);
  362.     if (OK)
  363.     {
  364.       if (!mSymbolQuestionable(Flags) && ((AdrInt < -128) || (AdrInt > 127))) WrError(ErrNum_JmpDistTooBig);
  365.       else
  366.       {
  367.         CodeLen = 2;
  368.         BAsmCode[0] = pOrder->Code;
  369.         BAsmCode[1] = Lo(AdrInt);
  370.       }
  371.     }
  372.   }
  373. }
  374.  
  375. static void DecodeCBEQx(Word Index)
  376. {
  377.   Boolean OK;
  378.   tSymbolFlags Flags;
  379.   LongInt AdrInt;
  380.  
  381.   if (ChkArgCnt(2, 2)
  382.    && ChkMinCPU(CPU68HC08))
  383.   {
  384.     DecodeAdr(1, 1, eSymbolSize8Bit, MModImm);
  385.     if (AdrMode == ModImm)
  386.     {
  387.       BAsmCode[1] = AdrVals[0];
  388.       AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[2], AdrIntType, &OK, &Flags) - (EProgCounter() + 3);
  389.       if (OK)
  390.       {
  391.         if (!mSymbolQuestionable(Flags) && ((AdrInt < -128) || (AdrInt > 127))) WrError(ErrNum_JmpDistTooBig);
  392.         else
  393.         {
  394.           BAsmCode[0] = 0x41 | Index;
  395.           BAsmCode[2] = AdrInt & 0xff;
  396.           CodeLen = 3;
  397.         }
  398.       }
  399.     }
  400.   }
  401. }
  402.  
  403. static void DecodeCBEQ(Word Index)
  404. {
  405.   Boolean OK;
  406.   tSymbolFlags Flags;
  407.   LongInt AdrInt;
  408.   Byte Disp = 0;
  409.  
  410.   UNUSED(Index);
  411.  
  412.   if (!ChkMinCPU(CPU68HC08));
  413.   else if (ArgCnt == 2)
  414.   {
  415.     DecodeAdr(1, 1, eSymbolSizeUnknown, MModDir | MModIxP);
  416.     switch (AdrMode)
  417.     {
  418.       case ModDir:
  419.         BAsmCode[0] = 0x31;
  420.         BAsmCode[1] = AdrVals[0];
  421.         Disp = 3;
  422.         break;
  423.       case ModIxP:
  424.         BAsmCode[0]=0x71;
  425.         Disp = 2;
  426.         break;
  427.     }
  428.     if (AdrMode != ModNone)
  429.     {
  430.       AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[2], AdrIntType, &OK, &Flags) - (EProgCounter() + Disp);
  431.       if (OK)
  432.       {
  433.         if (!mSymbolQuestionable(Flags) && ((AdrInt < -128) || (AdrInt > 127))) WrError(ErrNum_JmpDistTooBig);
  434.         else
  435.         {
  436.           BAsmCode[Disp - 1] = AdrInt & 0xff;
  437.           CodeLen = Disp;
  438.         }
  439.       }
  440.     }
  441.   }
  442.   else if (ArgCnt == 3)
  443.   {
  444.     OK = True;
  445.     if (!as_strcasecmp(ArgStr[2].str.p_str, "X+")) Disp = 3;
  446.     else if (!as_strcasecmp(ArgStr[2].str.p_str,"SP"))
  447.     {
  448.       BAsmCode[0] = 0x9e;
  449.       Disp = 4;
  450.     }
  451.     else
  452.     {
  453.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  454.       OK = False;
  455.     }
  456.     if (OK)
  457.     {
  458.       BAsmCode[Disp - 3] = 0x61;
  459.       BAsmCode[Disp - 2] = EvalStrIntExpression(&ArgStr[1], UInt8, &OK);
  460.       if (OK)
  461.       {
  462.         AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[3], AdrIntType, &OK, &Flags) - (EProgCounter() + Disp);
  463.         if (OK)
  464.         {
  465.           if (!mSymbolQuestionable(Flags) && ((AdrInt < -128) || (AdrInt > 127))) WrError(ErrNum_JmpDistTooBig);
  466.           else
  467.           {
  468.             BAsmCode[Disp - 1] = AdrInt & 0xff;
  469.             CodeLen = Disp;
  470.           }
  471.         }
  472.       }
  473.     }
  474.   }
  475.   else
  476.     (void)ChkArgCnt(2, 3);
  477. }
  478.  
  479. static void DecodeDBNZx(Word Index)
  480. {
  481.   Boolean OK;
  482.   tSymbolFlags Flags;
  483.   LongInt AdrInt;
  484.  
  485.   if (ChkArgCnt(1, 1)
  486.    && ChkMinCPU(CPU68HC08))
  487.   {
  488.     AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[1], AdrIntType, &OK, &Flags) - (EProgCounter() + 2);
  489.     if (OK)
  490.     {
  491.       if (!mSymbolQuestionable(Flags) && ((AdrInt < -128) || (AdrInt > 127))) WrError(ErrNum_JmpDistTooBig);
  492.       else
  493.       {
  494.         BAsmCode[0] = 0x4b | Index;
  495.         BAsmCode[1] = AdrInt & 0xff;
  496.         CodeLen = 2;
  497.       }
  498.     }
  499.   }
  500. }
  501.  
  502. static void DecodeDBNZ(Word Index)
  503. {
  504.   Boolean OK;
  505.   tSymbolFlags Flags;
  506.   LongInt AdrInt;
  507.   Byte Disp = 0;
  508.  
  509.   UNUSED(Index);
  510.  
  511.   if (ChkArgCnt(2, 3)
  512.    && ChkMinCPU(CPU68HC08))
  513.   {
  514.     DecodeAdr(1, ArgCnt - 1, eSymbolSizeUnknown, MModDir | MModIx | MModIx1 | MModSP1);
  515.     switch (AdrMode)
  516.     {
  517.       case ModDir:
  518.         BAsmCode[0] = 0x3b;
  519.         BAsmCode[1] = AdrVals[0];
  520.         Disp = 3;
  521.         break;
  522.       case ModIx:
  523.         BAsmCode[0] = 0x7b;
  524.         Disp = 2;
  525.         break;
  526.       case ModIx1:
  527.         BAsmCode[0] = 0x6b;
  528.         BAsmCode[1] = AdrVals[0];
  529.         Disp = 3;
  530.         break;
  531.       case ModSP1:
  532.         BAsmCode[0] = 0x9e;
  533.         BAsmCode[1] = 0x6b;
  534.         BAsmCode[2] = AdrVals[0];
  535.         Disp = 4;
  536.         break;
  537.     }
  538.     if (AdrMode != ModNone)
  539.     {
  540.       AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[ArgCnt], AdrIntType, &OK, &Flags) - (EProgCounter() + Disp);
  541.       if (OK)
  542.       {
  543.         if (!mSymbolQuestionable(Flags) && ((AdrInt < -128) || (AdrInt > 127))) WrError(ErrNum_JmpDistTooBig);
  544.         else
  545.         {
  546.           BAsmCode[Disp - 1] = AdrInt & 0xff;
  547.           CodeLen = Disp;
  548.         }
  549.       }
  550.     }
  551.   }
  552. }
  553.  
  554. static void DecodeALU(Word Index)
  555. {
  556.   const ALUOrder *pOrder = ALUOrders + Index;
  557.  
  558.   if (ChkMinCPU(pOrder->MinCPU))
  559.   {
  560.     DecodeAdr(1, ArgCnt, pOrder->Size, pOrder->Mask);
  561.     if (AdrMode != ModNone)
  562.     {
  563.       switch (AdrMode)
  564.       {
  565.         case ModImm:
  566.           BAsmCode[0] = 0xa0 + pOrder->Code;
  567.           CodeLen = 1; /* leave for CPHX */
  568.           break;
  569.         case ModDir:
  570.           BAsmCode[0] = 0xb0 + pOrder->Code;
  571.           CodeLen = 1;
  572.           break;
  573.         case ModExt:
  574.           BAsmCode[0] = 0xc0 | pOrder->Code;
  575.           CodeLen = 1;
  576.           break;
  577.         case ModIx:
  578.           BAsmCode[0] = 0xf0 | pOrder->Code;
  579.           CodeLen = 1;
  580.           break;
  581.         case ModIx1:
  582.           BAsmCode[0] = 0xe0 | pOrder->Code;
  583.           CodeLen = 1;
  584.           break;
  585.         case ModIx2:
  586.           BAsmCode[0] = 0xd0 | pOrder->Code;
  587.           CodeLen = 1;
  588.           break;
  589.         case ModSP1:
  590.           BAsmCode[0] = 0x9e;
  591.           BAsmCode[1] = 0xe0| pOrder->Code;
  592.           CodeLen = 2;
  593.           break;
  594.         case ModSP2:
  595.           BAsmCode[0] = 0x9e;
  596.           BAsmCode[1] = 0xd0 | pOrder->Code;
  597.           CodeLen = 2;
  598.           break;
  599.       }
  600.       memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  601.       CodeLen += AdrCnt;
  602.     }
  603.   }
  604. }
  605.  
  606. static void DecodeCPHX(Word Index)
  607. {
  608.   UNUSED(Index);
  609.  
  610.   if (ChkMinCPU(CPU68HC08))
  611.   {
  612.     Word Mask = MModImm | MModDir;
  613.  
  614.     if (MomCPU >= CPU68HCS08)
  615.       Mask |= MModExt| MModSP1;
  616.     DecodeAdr(1, ArgCnt, eSymbolSize16Bit, Mask);
  617.     if (AdrMode != ModNone)
  618.     {
  619.       switch (AdrMode)
  620.       {
  621.         case ModImm:
  622.           BAsmCode[0] = 0x65;
  623.           CodeLen = 1;
  624.           break;
  625.         case ModDir:
  626.           BAsmCode[0] = 0x75;
  627.           CodeLen = 1;
  628.           break;
  629.         case ModExt:
  630.           BAsmCode[0] = 0x3e;
  631.           CodeLen = 1;
  632.           break;
  633.         case ModSP1:
  634.           BAsmCode[0] = 0x9e;
  635.           BAsmCode[1] = 0xf3;
  636.           CodeLen = 2;
  637.           break;
  638.       }
  639.       memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  640.       CodeLen += AdrCnt;
  641.     }
  642.   }
  643. }
  644.  
  645. static void DecodeSTHX(Word Index)
  646. {
  647.   UNUSED(Index);
  648.  
  649.   if (ChkMinCPU(CPU68HC08))
  650.   {
  651.     Word Mask = MModDir;
  652.  
  653.     if (MomCPU >= CPU68HCS08)
  654.       Mask |= MModExt | MModSP1;
  655.     DecodeAdr(1, ArgCnt, eSymbolSizeUnknown, Mask);
  656.     if (AdrMode != ModNone)
  657.     {
  658.       switch (AdrMode)
  659.       {
  660.         case ModDir:
  661.           BAsmCode[0] = 0x35;
  662.           CodeLen = 1;
  663.           break;
  664.         case ModExt:
  665.           BAsmCode[0] = 0x96;
  666.           CodeLen = 1;
  667.           break;
  668.         case ModSP1:
  669.           BAsmCode[0] = 0x9e;
  670.           BAsmCode[1] = 0xff;
  671.           CodeLen = 2;
  672.           break;
  673.       }
  674.       memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  675.       CodeLen += AdrCnt;
  676.     }
  677.   }
  678. }
  679.  
  680. static void DecodeLDHX(Word Index)
  681. {
  682.   UNUSED(Index);
  683.  
  684.   if (ChkMinCPU(CPU68HC08))
  685.   {
  686.     Word Mask = MModImm | MModDir;
  687.  
  688.     if (MomCPU >= CPU68HCS08)
  689.       Mask |= MModExt| MModIx | MModIx1 | MModIx2 | MModSP1;
  690.     DecodeAdr(1, ArgCnt, eSymbolSize16Bit, Mask);
  691.     if (AdrMode != ModNone)
  692.     {
  693.       switch (AdrMode)
  694.       {
  695.         case ModImm:
  696.           BAsmCode[0] = 0x45;
  697.           CodeLen = 1;
  698.           break;
  699.         case ModDir:
  700.           BAsmCode[0] = 0x55;
  701.           CodeLen = 1;
  702.           break;
  703.         case ModExt:
  704.           BAsmCode[0] = 0x32;
  705.           CodeLen = 1;
  706.           break;
  707.         case ModIx  :
  708.           BAsmCode[0] = 0x9e;
  709.           BAsmCode[1] = 0xae;
  710.           CodeLen = 2;
  711.           break;
  712.         case ModIx1 :
  713.           BAsmCode[0] = 0x9e;
  714.           BAsmCode[1] = 0xce;
  715.           CodeLen = 2;
  716.           break;
  717.         case ModIx2 :
  718.           BAsmCode[0] = 0x9e;
  719.           BAsmCode[1] = 0xbe;
  720.           CodeLen = 2;
  721.           break;
  722.         case ModSP1:
  723.           BAsmCode[0] = 0x9e;
  724.           BAsmCode[1] = 0xfe;
  725.           CodeLen = 2;
  726.           break;
  727.       }
  728.       memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  729.       CodeLen += AdrCnt;
  730.     }
  731.   }
  732. }
  733.  
  734. static void DecodeAIx(Word Index)
  735. {
  736.   Boolean OK;
  737.  
  738.   if (!ChkArgCnt(1, 1));
  739.   else if (!ChkMinCPU(CPU68HC08));
  740.   else if (*ArgStr[1].str.p_str != '#') WrError(ErrNum_InvAddrMode);
  741.   else
  742.   {
  743.     BAsmCode[1] = EvalStrIntExpressionOffs(&ArgStr[1], 1, SInt8, &OK);
  744.     if (OK)
  745.     {
  746.       BAsmCode[0] = 0xa7 | Index;
  747.       CodeLen = 2;
  748.     }
  749.   }
  750. }
  751.  
  752. static void DecodeRMW(Word Index)
  753. {
  754.   const RMWOrder *pOrder = RMWOrders + Index;
  755.  
  756.   if (ChkMinCPU(pOrder->MinCPU))
  757.   {
  758.     DecodeAdr(1, ArgCnt, eSymbolSizeUnknown, pOrder->Mask);
  759.     if (AdrMode != ModNone)
  760.     {
  761.       switch (AdrMode)
  762.       {
  763.         case ModDir :
  764.           BAsmCode[0] = 0x30 | pOrder->Code;
  765.           CodeLen = 1;
  766.           break;
  767.         case ModIx  :
  768.           BAsmCode[0] = 0x70 | pOrder->Code;
  769.           CodeLen = 1;
  770.           break;
  771.         case ModIx1 :
  772.           BAsmCode[0] = 0x60 | pOrder->Code;
  773.           CodeLen = 1;
  774.           break;
  775.         case ModSP1 :
  776.           BAsmCode[0] = 0x9e; BAsmCode[1] = 0x60 | pOrder->Code;
  777.           CodeLen = 2;
  778.           break;
  779.       }
  780.       memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  781.       CodeLen += AdrCnt;
  782.     }
  783.   }
  784. }
  785.  
  786. static void decode_bset_bclr_core(Word code, int arg_index)
  787. {
  788.   Boolean ok;
  789.  
  790.   BAsmCode[1] = EvalStrIntExpression(&ArgStr[arg_index], Int8, &ok);
  791.   if (ok)
  792.   {
  793.     BAsmCode[0] = 0x10 | code;
  794.     CodeLen = 2;
  795.   }
  796. }
  797.  
  798. static void decode_bset_bclr_1(Word code)
  799. {
  800.   if (ChkArgCnt(1, 1))
  801.     decode_bset_bclr_core(code, 1);
  802. }
  803.  
  804. static void decode_bset_bclr_2(Word code)
  805. {
  806.   if (ChkArgCnt(2, 2))
  807.   {
  808.     Boolean ok;
  809.  
  810.     code |= EvalStrIntExpression(&ArgStr[1], UInt3, &ok) << 1;
  811.     if (ok)
  812.       decode_bset_bclr_core(code, 2);
  813.   }
  814. }
  815.  
  816. static void decode_brset_brclr_core(Word code, int arg_index)
  817. {
  818.   Boolean ok;
  819.  
  820.   BAsmCode[1] = EvalStrIntExpression(&ArgStr[arg_index], Int8, &ok);
  821.   if (ok)
  822.   {
  823.     tSymbolFlags flags;
  824.     LongInt address;
  825.  
  826.     address = EvalStrIntExpressionWithFlags(&ArgStr[arg_index + 1], AdrIntType, &ok, &flags) - (EProgCounter() + 3);
  827.     if (ok)
  828.     {
  829.       if (!mSymbolQuestionable(flags) && ((address < -128) || (address > 127))) WrError(ErrNum_JmpDistTooBig);
  830.       else
  831.       {
  832.         CodeLen = 3;
  833.         BAsmCode[0] = code;
  834.         BAsmCode[2] = Lo(address);
  835.       }
  836.     }
  837.   }
  838. }
  839.  
  840. static void decode_brset_brclr_2(Word code)
  841. {
  842.   if (ChkArgCnt(2, 2))
  843.     decode_brset_brclr_core(code, 1);
  844. }
  845.  
  846. static void decode_brset_brclr_3(Word code)
  847. {
  848.   if (ChkArgCnt(3, 3))
  849.   {
  850.     Boolean ok;
  851.  
  852.     code |= EvalStrIntExpression(&ArgStr[1], UInt3, &ok) << 1;
  853.     if (ok)
  854.       decode_brset_brclr_core(code, 2);
  855.   }
  856. }
  857.  
  858. /*--------------------------------------------------------------------------*/
  859. /* dynamic code table handling */
  860.  
  861. static void AddFixed(const char *NName, CPUVar NMin, Byte NCode)
  862. {
  863.   order_array_rsv_end(FixedOrders, BaseOrder);
  864.   FixedOrders[InstrZ].MinCPU = NMin;
  865.   FixedOrders[InstrZ].Code = NCode;
  866.   AddInstTable(InstTable, NName, InstrZ++, DecodeFixed);
  867. }
  868.  
  869. static void AddRel(const char *NName, CPUVar NMin, Byte NCode)
  870. {
  871.   order_array_rsv_end(RelOrders, BaseOrder);
  872.   RelOrders[InstrZ].MinCPU = NMin;
  873.   RelOrders[InstrZ].Code = NCode;
  874.   AddInstTable(InstTable, NName, InstrZ++, DecodeRel);
  875. }
  876.  
  877. static void AddALU(const char *NName, CPUVar NMin, Byte NCode, Word NMask, tSymbolSize NSize)
  878. {
  879.   order_array_rsv_end(ALUOrders, ALUOrder);
  880.   ALUOrders[InstrZ].MinCPU = NMin;
  881.   ALUOrders[InstrZ].Code = NCode;
  882.   ALUOrders[InstrZ].Mask = NMask;
  883.   ALUOrders[InstrZ].Size = NSize;
  884.   AddInstTable(InstTable, NName, InstrZ++, DecodeALU);
  885. }
  886.  
  887. static void AddRMW(const char *NName, CPUVar NMin, Byte NCode ,Word NMask)
  888. {
  889.   order_array_rsv_end(RMWOrders, RMWOrder);
  890.   RMWOrders[InstrZ].MinCPU = NMin;
  891.   RMWOrders[InstrZ].Code = NCode;
  892.   RMWOrders[InstrZ].Mask = NMask;
  893.   AddInstTable(InstTable, NName, InstrZ++, DecodeRMW);
  894. }
  895.  
  896. static void add_bset_bclr(const char *p_name, Word code)
  897. {
  898.   char name[10];
  899.   unsigned bit;
  900.  
  901.   AddInstTable(InstTable, p_name, code, decode_bset_bclr_2);
  902.   for (bit = 0; bit < 8; bit++)
  903.   {
  904.     as_snprintf(name, sizeof(name), "%s%c", p_name, bit + '0');
  905.     AddInstTable(InstTable, name, code | (bit << 1), decode_bset_bclr_1);
  906.   }
  907. }
  908.  
  909. static void add_brset_brclr(const char *p_name, Word code)
  910. {
  911.   char name[10];
  912.   unsigned bit;
  913.  
  914.   AddInstTable(InstTable, p_name, code, decode_brset_brclr_3);
  915.   for (bit = 0; bit < 8; bit++)
  916.   {
  917.     as_snprintf(name, sizeof(name), "%s%c", p_name, bit + '0');
  918.     AddInstTable(InstTable, name, code | (bit << 1), decode_brset_brclr_2);
  919.   }
  920. }
  921.  
  922. static void InitFields(void)
  923. {
  924.   InstTable = CreateInstTable(247);
  925.   SetDynamicInstTable(InstTable);
  926.  
  927.   add_null_pseudo(InstTable);
  928.  
  929.   InstrZ = 0;
  930.   AddFixed("RTI" , CPU6805   , 0x80); AddFixed("RTS" , CPU6805   , 0x81);
  931.   AddFixed("SWI" , CPU6805   , 0x83); AddFixed("TAX" , CPU6805   , 0x97);
  932.   AddFixed("CLC" , CPU6805   , 0x98); AddFixed("SEC" , CPU6805   , 0x99);
  933.   AddFixed("CLI" , CPU6805   , 0x9a); AddFixed("SEI" , CPU6805   , 0x9b);
  934.   AddFixed("RSP" , CPU6805   , 0x9c); AddFixed("NOP" , CPU6805   , 0x9d);
  935.   AddFixed("TXA" , CPU6805   , 0x9f); AddFixed("NEGA", CPU6805   , 0x40);
  936.   AddFixed("NEGX", CPU6805   , 0x50); AddFixed("COMA", CPU6805   , 0x43);
  937.   AddFixed("COMX", CPU6805   , 0x53); AddFixed("LSRA", CPU6805   , 0x44);
  938.   AddFixed("LSRX", CPU6805   , 0x54); AddFixed("RORA", CPU6805   , 0x46);
  939.   AddFixed("RORX", CPU6805   , 0x56); AddFixed("ASRA", CPU6805   , 0x47);
  940.   AddFixed("ASRX", CPU6805   , 0x57); AddFixed("ASLA", CPU6805   , 0x48);
  941.   AddFixed("ASLX", CPU6805   , 0x58); AddFixed("LSLA", CPU6805   , 0x48);
  942.   AddFixed("LSLX", CPU6805   , 0x58); AddFixed("ROLA", CPU6805   , 0x49);
  943.   AddFixed("ROLX", CPU6805   , 0x59); AddFixed("DECA", CPU6805   , 0x4a);
  944.   AddFixed("DECX", CPU6805   , 0x5a); AddFixed("INCA", CPU6805   , 0x4c);
  945.   AddFixed("INCX", CPU6805   , 0x5c); AddFixed("TSTA", CPU6805   , 0x4d);
  946.   AddFixed("TSTX", CPU6805   , 0x5d); AddFixed("CLRA", CPU6805   , 0x4f);
  947.   AddFixed("CLRX", CPU6805   , 0x5f); AddFixed("CLRH", CPU68HC08 , 0x8c);
  948.   AddFixed("DAA" , CPU68HC08 , 0x72); AddFixed("DIV" , CPU68HC08 , 0x52);
  949.   AddFixed("MUL" , CPU68HC05 , 0x42); AddFixed("NSA" , CPU68HC08 , 0x62);
  950.   AddFixed("PSHA", CPU68HC08 , 0x87); AddFixed("PSHH", CPU68HC08 , 0x8b);
  951.   AddFixed("PSHX", CPU68HC08 , 0x89); AddFixed("PULA", CPU68HC08 , 0x86);
  952.   AddFixed("PULH", CPU68HC08 , 0x8a); AddFixed("PULX", CPU68HC08 , 0x88);
  953.   AddFixed("STOP", CPU68HC05 , 0x8e); AddFixed("TAP" , CPU68HC08 , 0x84);
  954.   AddFixed("TPA" , CPU68HC08 , 0x85); AddFixed("TSX" , CPU68HC08 , 0x95);
  955.   AddFixed("TXS" , CPU68HC08 , 0x94); AddFixed("WAIT", CPU68HC05 , 0x8f);
  956.   AddFixed("INX" , CPU6805   , 0x5c); AddFixed("BGND", CPU68HCS08, 0x82);
  957.  
  958.   AddInstTable(InstTable, "MOV", 0, DecodeMOV);
  959.  
  960.   InstrZ = 0;
  961.   AddRel("BRA" , CPU6805   , 0x20); AddRel("BRN" , CPU6805   , 0x21);
  962.   AddRel("BHI" , CPU6805   , 0x22); AddRel("BLS" , CPU6805   , 0x23);
  963.   AddRel("BCC" , CPU6805   , 0x24); AddRel("BCS" , CPU6805   , 0x25);
  964.   AddRel("BNE" , CPU6805   , 0x26); AddRel("BEQ" , CPU6805   , 0x27);
  965.   AddRel("BHCC", CPU6805   , 0x28); AddRel("BHCS", CPU6805   , 0x29);
  966.   AddRel("BPL" , CPU6805   , 0x2a); AddRel("BMI" , CPU6805   , 0x2b);
  967.   AddRel("BMC" , CPU6805   , 0x2c); AddRel("BMS" , CPU6805   , 0x2d);
  968.   AddRel("BIL" , CPU6805   , 0x2e); AddRel("BIH" , CPU6805   , 0x2f);
  969.   AddRel("BSR" , CPU6805   , 0xad); AddRel("BGE" , CPU68HC08 , 0x90);
  970.   AddRel("BGT" , CPU68HC08 , 0x92); AddRel("BHS" , CPU6805   , 0x24);
  971.   AddRel("BLE" , CPU68HC08 , 0x93); AddRel("BLO" , CPU6805   , 0x25);
  972.   AddRel("BLT" , CPU68HC08 , 0x91);
  973.  
  974.   AddInstTable(InstTable, "CBEQA", 0x00, DecodeCBEQx);
  975.   AddInstTable(InstTable, "CBEQX", 0x10, DecodeCBEQx);
  976.   AddInstTable(InstTable, "CBEQ", 0, DecodeCBEQ);
  977.   AddInstTable(InstTable, "DBNZA", 0x00, DecodeDBNZx);
  978.   AddInstTable(InstTable, "DBNZX", 0x10, DecodeDBNZx);
  979.   AddInstTable(InstTable, "DBNZ", 0, DecodeDBNZ);
  980.  
  981.   InstrZ = 0;
  982.   AddALU("SUB" , CPU6805   , 0x00, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  983.   AddALU("CMP" , CPU6805   , 0x01, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  984.   AddALU("SBC" , CPU6805   , 0x02, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  985.   AddALU("CPX" , CPU6805   , 0x03, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  986.   AddALU("AND" , CPU6805   , 0x04, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  987.   AddALU("BIT" , CPU6805   , 0x05, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  988.   AddALU("LDA" , CPU6805   , 0x06, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  989.   AddALU("STA" , CPU6805   , 0x07,           MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  990.   AddALU("EOR" , CPU6805   , 0x08, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  991.   AddALU("ADC" , CPU6805   , 0x09, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  992.   AddALU("ORA" , CPU6805   , 0x0a, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  993.   AddALU("ADD" , CPU6805   , 0x0b, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  994.   AddALU("JMP" , CPU6805   , 0x0c,           MModDir | MModExt | MModIx | MModIx1 | MModIx2                    , eSymbolSizeUnknown);
  995.   AddALU("JSR" , CPU6805   , 0x0d,           MModDir | MModExt | MModIx | MModIx1 | MModIx2                    , eSymbolSizeUnknown);
  996.   AddALU("LDX" , CPU6805   , 0x0e, MModImm | MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  997.   AddALU("STX" , CPU6805   , 0x0f,           MModDir | MModExt | MModIx | MModIx1 | MModIx2 | MModSP1 | MModSP2, eSymbolSize8Bit);
  998.  
  999.   AddInstTable(InstTable, "CPHX", 0, DecodeCPHX);
  1000.   AddInstTable(InstTable, "LDHX", 0, DecodeLDHX);
  1001.   AddInstTable(InstTable, "STHX", 0, DecodeSTHX);
  1002.  
  1003.   AddInstTable(InstTable, "AIS", 0x00, DecodeAIx);
  1004.   AddInstTable(InstTable, "AIX", 0x08, DecodeAIx);
  1005.  
  1006.   InstrZ = 0;
  1007.   AddRMW("NEG", CPU6805, 0x00, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1008.   AddRMW("COM", CPU6805, 0x03, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1009.   AddRMW("LSR", CPU6805, 0x04, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1010.   AddRMW("ROR", CPU6805, 0x06, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1011.   AddRMW("ASR", CPU6805, 0x07, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1012.   AddRMW("ASL", CPU6805, 0x08, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1013.   AddRMW("LSL", CPU6805, 0x08, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1014.   AddRMW("ROL", CPU6805, 0x09, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1015.   AddRMW("DEC", CPU6805, 0x0a, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1016.   AddRMW("INC", CPU6805, 0x0c, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1017.   AddRMW("TST", CPU6805, 0x0d, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1018.   AddRMW("CLR", CPU6805, 0x0f, MModDir |        MModIx | MModIx1 |         MModSP1        );
  1019.  
  1020.   add_bset_bclr("BCLR", 0x01);
  1021.   add_bset_bclr("BSET", 0x00);
  1022.   add_brset_brclr("BRCLR", 0x01);
  1023.   add_brset_brclr("BRSET", 0x00);
  1024.  
  1025.   add_moto8_pseudo(InstTable, e_moto_pseudo_flags_be);
  1026.   AddMoto16Pseudo(InstTable, e_moto_pseudo_flags_be);
  1027.   AddInstTable(InstTable, "DB", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDB);
  1028.   AddInstTable(InstTable, "DW", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDW);
  1029. }
  1030.  
  1031. static void DeinitFields(void)
  1032. {
  1033.   DestroyInstTable(InstTable);
  1034.   order_array_free(FixedOrders);
  1035.   order_array_free(RelOrders);
  1036.   order_array_free(ALUOrders);
  1037.   order_array_free(RMWOrders);
  1038. }
  1039.  
  1040. /*--------------------------------------------------------------------------*/
  1041. /* Main Functions */
  1042.  
  1043. static Boolean DecodeAttrPart_6805(void)
  1044. {
  1045.   if (strlen(AttrPart.str.p_str) > 1)
  1046.   {
  1047.     WrStrErrorPos(ErrNum_UndefAttr, &AttrPart);
  1048.     return False;
  1049.   }
  1050.  
  1051.   /* deduce operand size - no size is zero-length string -> '\0' */
  1052.  
  1053.   return DecodeMoto16AttrSize(*AttrPart.str.p_str, &AttrPartOpSize[0], False);
  1054. }
  1055.  
  1056. static void MakeCode_6805(void)
  1057. {
  1058.   if (AttrPartOpSize[0] == eSymbolSizeUnknown)
  1059.     AttrPartOpSize[0] = eSymbolSize8Bit;
  1060.  
  1061.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  1062.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  1063. }
  1064.  
  1065. static Boolean IsDef_6805(void)
  1066. {
  1067.   return False;
  1068. }
  1069.  
  1070. static void SwitchFrom_6805(void)
  1071. {
  1072.   DeinitFields();
  1073. }
  1074.  
  1075. static void SwitchTo_6805(void)
  1076. {
  1077.   TurnWords = False;
  1078.   SetIntConstMode(eIntConstModeMoto);
  1079.  
  1080.   PCSymbol = "*";
  1081.   HeaderID = 0x62;
  1082.   NOPCode = 0x9d;
  1083.   DivideChars = ",";
  1084.   HasAttrs = True;
  1085.   AttrChars = ".";
  1086.  
  1087.   ValidSegs = (1 << SegCode);
  1088.   Grans[SegCode] = 1;
  1089.   ListGrans[SegCode] = 1;
  1090.   SegInits[SegCode] = 0;
  1091.   SegLimits[SegCode] = (MomCPU >= CPU68HC08) ? 0xffff : 0x1fff;
  1092.   AdrIntType = (MomCPU >= CPU68HC08) ? UInt16 : UInt13;
  1093.  
  1094.   DecodeAttrPart = DecodeAttrPart_6805;
  1095.   MakeCode = MakeCode_6805;
  1096.   IsDef = IsDef_6805;
  1097.   SwitchFrom = SwitchFrom_6805;
  1098.   InitFields();
  1099.   AddMoto16PseudoONOFF(False);
  1100. }
  1101.  
  1102. void code6805_init(void)
  1103. {
  1104.   CPU6805    = AddCPU("6805",    SwitchTo_6805);
  1105.   CPU68HC05  = AddCPU("68HC05",  SwitchTo_6805);
  1106.   CPU68HC08  = AddCPU("68HC08",  SwitchTo_6805);
  1107.   CPU68HCS08 = AddCPU("68HCS08", SwitchTo_6805);
  1108. }
  1109.