Subversion Repositories pentevo

Rev

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

  1. /* codeh8_3.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator H8/300(L/H)                                                 */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <ctype.h>
  14.  
  15. #include "nls.h"
  16. #include "bpemu.h"
  17. #include "strutil.h"
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmallg.h"
  22. #include "onoff_common.h"
  23. #include "asmstructs.h"
  24. #include "asmitree.h"
  25. #include "codepseudo.h"
  26. #include "motpseudo.h"
  27. #include "codevars.h"
  28. #include "errmsg.h"
  29.  
  30. #include "codeh8_3.h"
  31.  
  32. #define ModNone (-1)
  33. #define ModReg 0
  34. #define MModReg (1 << ModReg)
  35. #define ModImm 1
  36. #define MModImm (1 << ModImm)
  37. #define ModAbs8 2
  38. #define MModAbs8 (1 << ModAbs8)
  39. #define ModAbs16 3
  40. #define MModAbs16 (1 << ModAbs16)
  41. #define ModAbs24 4
  42. #define MModAbs24 (1 << ModAbs24)
  43. #define MModAbs (MModAbs8 | MModAbs16 | MModAbs24)
  44. #define ModIReg 5
  45. #define MModIReg (1 << ModIReg)
  46. #define ModPreDec 6
  47. #define MModPreDec (1 << ModPreDec)
  48. #define ModPostInc 7
  49. #define MModPostInc (1 << ModPostInc)
  50. #define ModInd16 8
  51. #define MModInd16 (1 << ModInd16)
  52. #define ModInd24 9
  53. #define MModInd24 (1 << ModInd24)
  54. #define ModIIAbs 10
  55. #define MModIIAbs (1 << ModIIAbs)
  56. #define MModInd (MModInd16 | MModInd24)
  57.  
  58. /* keep in the same order as in registration */
  59.  
  60. #define M_CPUH8_300L  (1 << 0)
  61. #define M_CPU6413308  (1 << 1)
  62. #define M_CPUH8_300   (1 << 2)
  63. #define M_CPU6413309  (1 << 3)
  64. #define M_CPUH8_300H  (1 << 4)
  65.  
  66. #define REG_SP 7
  67.  
  68. static tSymbolSize OpSize, MomSize;
  69. static ShortInt AdrMode;    /* Ergebnisadressmodus */
  70. static Byte AdrPart;        /* Adressierungsmodusbits im Opcode */
  71. static Word AdrVals[6];     /* Adressargument */
  72.  
  73. static CPUVar CPUH8_300L;
  74. static CPUVar CPU6413308,CPUH8_300;
  75. static CPUVar CPU6413309,CPUH8_300H;
  76. static Boolean CPU16;       /* keine 32-Bit-Register */
  77.  
  78. /*-------------------------------------------------------------------------*/
  79. /* Adressparsing */
  80.  
  81. static void SetOpSize(tSymbolSize Size)
  82. {
  83.   if (OpSize == eSymbolSizeUnknown)
  84.     OpSize = Size;
  85.   else if (Size != OpSize)
  86.   {
  87.     WrError(ErrNum_ConfOpSizes);
  88.     AdrMode = ModNone;
  89.     AdrCnt = 0;
  90.   }
  91. }
  92.  
  93. static Boolean IsNum(char Inp, Byte *Erg)
  94. {
  95.   if ((Inp < '0') || (Inp > '7'))
  96.     return False;
  97.   else
  98.   {
  99.     *Erg = Inp - AscOfs;
  100.     return True;
  101.   }
  102. }
  103.  
  104. /*!------------------------------------------------------------------------
  105.  * \fn     DecodeRegCore(char *pArg, Byte *pResult, tSymbolSize *pSize)
  106.  * \brief  check whether argument is a CPU register
  107.  * \param  pArg source argument
  108.  * \param  pResult register # if yes
  109.  * \param  pSize register size if yes
  110.  * \return True if it is a register
  111.  * ------------------------------------------------------------------------ */
  112.  
  113. static Boolean DecodeRegCore(char *pArg, Byte *pResult, tSymbolSize *pSize)
  114. {
  115.   if (!as_strcasecmp(pArg, "SP"))
  116.   {
  117.     *pResult = REG_SP | REGSYM_FLAG_ALIAS;
  118.     *pSize = MaxMode ? eSymbolSize32Bit : eSymbolSize16Bit;
  119.     return True;
  120.   }
  121.  
  122.   switch (strlen(pArg))
  123.   {
  124.     case 2:
  125.       if (IsNum(pArg[1], pResult))
  126.       {
  127.         if (as_toupper(*pArg) == 'R')
  128.         {
  129.           *pSize = eSymbolSize16Bit;
  130.           return True;
  131.         }
  132.         else if (as_toupper(*pArg) == 'E')
  133.         {
  134.           *pResult += 8;
  135.           *pSize = eSymbolSize16Bit;
  136.           return True;
  137.         }
  138.       }
  139.       break;
  140.     case 3:
  141.       if ((as_toupper(*pArg) == 'R') && IsNum(pArg[1], pResult))
  142.       {
  143.         if (as_toupper(pArg[2]) == 'L')
  144.         {
  145.           *pResult += 8;
  146.           *pSize = eSymbolSize8Bit;
  147.           return True;
  148.         }
  149.         else if (as_toupper(pArg[2]) == 'H')
  150.         {
  151.           *pSize = eSymbolSize8Bit;
  152.           return True;
  153.         }
  154.       }
  155.       else if ((as_toupper(*pArg) == 'E') && (as_toupper(pArg[1]) == 'R') && IsNum(pArg[2], pResult))
  156.       {
  157.         *pSize = eSymbolSize32Bit;
  158.         return True;
  159.       }
  160.   }
  161.  
  162.   *pSize = eSymbolSizeUnknown;
  163.   return False;
  164. }
  165.  
  166. /*!------------------------------------------------------------------------
  167.  * \fn     DissectReg_H8_3(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  168.  * \brief  dissect register symbols - C16x variant
  169.  * \param  pDest destination buffer
  170.  * \param  DestSize destination buffer size
  171.  * \param  Value numeric register value
  172.  * \param  InpSize register size
  173.  * ------------------------------------------------------------------------ */
  174.  
  175. static void DissectReg_H8_3(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  176. {
  177.   switch (InpSize)
  178.   {
  179.     case eSymbolSize8Bit:
  180.       as_snprintf(pDest, DestSize, "R%u%c", (unsigned)(Value & 7), "HL"[(Value >> 3) & 1]);
  181.       break;
  182.     case eSymbolSize16Bit:
  183.       if (Value == (REG_SP | REGSYM_FLAG_ALIAS))
  184.         as_snprintf(pDest, DestSize, "SP");
  185.       else
  186.         as_snprintf(pDest, DestSize, "%c%u", "RE"[(Value >> 3) & 1], (unsigned)(Value & 7));
  187.       break;
  188.     case eSymbolSize32Bit:
  189.       if (Value == (REG_SP | REGSYM_FLAG_ALIAS))
  190.         as_snprintf(pDest, DestSize, "SP");
  191.       else
  192.         as_snprintf(pDest, DestSize, "ER%u", (unsigned)Value);
  193.       break;
  194.     default:
  195.       as_snprintf(pDest, DestSize, "%d-%u", (int)InpSize, (unsigned)Value);
  196.   }
  197. }
  198.  
  199. /*!------------------------------------------------------------------------
  200.  * \fn     DecodeReg(const tStrComp *pArg, Byte *pResult, tSymbolSize ReqSize, tSymbolSize *pSize)
  201.  * \brief  check whether argument is a CPU register or register alias
  202.  * \param  pArg source argument
  203.  * \param  pResult register # if yes
  204.  * \param  SizeMask requested register size(s)
  205.  * \param  pSize register size if yes
  206.  * \return reg eval result
  207.  * ------------------------------------------------------------------------ */
  208.  
  209. static tRegEvalResult DecodeReg(const tStrComp *pArg, Byte *pResult, unsigned SizeMask, tSymbolSize *pSize, Boolean MustBeReg)
  210. {
  211.   tRegDescr RegDescr;
  212.   tEvalResult EvalResult;
  213.   tRegEvalResult RegEvalResult;
  214.  
  215.   if (DecodeRegCore(pArg->str.p_str, pResult, pSize))
  216.   {
  217.     RegEvalResult = eIsReg;
  218.     *pResult &= ~REGSYM_FLAG_ALIAS;
  219.   }
  220.   else
  221.   {
  222.     RegEvalResult = EvalStrRegExpressionAsOperand(pArg, &RegDescr, &EvalResult, eSymbolSizeUnknown, MustBeReg);
  223.     *pSize = EvalResult.DataSize;
  224.     *pResult = RegDescr.Reg & ~REGSYM_FLAG_ALIAS;
  225.   }
  226.  
  227.   if ((RegEvalResult == eIsReg)
  228.    && !((SizeMask >> *pSize) & 1))
  229.   {
  230.     WrStrErrorPos(ErrNum_InvOpSize, pArg);
  231.     return MustBeReg ? eIsNoReg : eRegAbort;
  232.   }
  233.  
  234.   return RegEvalResult;
  235. }
  236.  
  237. static void CutSize(tStrComp *pArg)
  238. {
  239.   int ArgLen = strlen(pArg->str.p_str);
  240.  
  241.   if ((ArgLen >= 2) && !strcmp(pArg->str.p_str + ArgLen - 2, ":8"))
  242.   {
  243.     StrCompShorten(pArg, 2);
  244.     MomSize = eSymbolSize8Bit;
  245.   }
  246.   else if ((ArgLen >= 3) && !strcmp(pArg->str.p_str + ArgLen - 3, ":16"))
  247.   {
  248.     StrCompShorten(pArg, 3);
  249.     MomSize = eSymbolSize16Bit;
  250.   }
  251.   else if ((ArgLen >= 3) && !strcmp(pArg->str.p_str + ArgLen - 3, ":24"))
  252.   {
  253.     StrCompShorten(pArg, 3);
  254.     MomSize = eSymbolSize24Bit;
  255.   }
  256. }
  257.  
  258. static Boolean ChkCPU32(tErrorNum ErrorNum)
  259. {
  260.   return ChkMinCPUExt(CPU6413309, ErrorNum);
  261. }
  262.  
  263. static Byte DecodeBaseReg(const tStrComp *pArg, Byte *Erg, Boolean MustBeReg)
  264. {
  265.   tSymbolSize HSize;
  266.   Word Mask;
  267.  
  268.   switch (DecodeReg(pArg, Erg, (1 << eSymbolSize16Bit) | (1 << eSymbolSize32Bit), &HSize, MustBeReg))
  269.   {
  270.     case eIsNoReg:
  271.       return 0;
  272.     case eRegAbort:
  273.       return 1;
  274.     default:
  275.       break;
  276.   }
  277.   if ((HSize == eSymbolSize16Bit) && (*Erg > 7))
  278.   {
  279.     WrStrErrorPos(ErrNum_InvReg, pArg);
  280.     return 1;
  281.   }
  282.   Mask = (HSize == eSymbolSize16Bit) ? (M_CPUH8_300L | M_CPU6413308 | M_CPUH8_300) : (M_CPU6413309 | M_CPUH8_300H);
  283.   if (ChkExactCPUMaskExt(Mask, CPUH8_300L, ErrNum_AddrModeNotSupported) < 0)
  284.     return 1;
  285.   return 2;
  286. }
  287.  
  288. static Boolean Is8(LongInt Address)
  289. {
  290.   if (CPU16)
  291.     return (((Address >> 8) & 0xff) == 0xff);
  292.   else
  293.     return (((Address >> 8) & 0xffff) == 0xffff);
  294. }
  295.  
  296. static Boolean Is16(LongInt Address)
  297. {
  298.   return (CPU16) ? (True) : (((Address >= 0) && (Address <= 0x7fff)) || ((Address >= 0xff8000) && (Address <= 0xffffff)));
  299. }
  300.  
  301. static void DecideVAbsolute(LongInt Address, Word Mask)
  302. {
  303.   /* bei Automatik Operandengroesse festlegen */
  304.  
  305.   if (MomSize == eSymbolSizeUnknown)
  306.   {
  307.     if (Is8(Address))
  308.       MomSize = eSymbolSize8Bit;
  309.     else if (Is16(Address))
  310.       MomSize = eSymbolSize16Bit;
  311.     else
  312.       MomSize = eSymbolSize24Bit;
  313.   }
  314.  
  315.   /* wenn nicht vorhanden, eins rauf */
  316.  
  317.   if ((MomSize == eSymbolSize8Bit) && ((Mask & MModAbs8) == 0))
  318.     MomSize = eSymbolSize16Bit;
  319.   if ((MomSize == eSymbolSize16Bit) && ((Mask & MModAbs16) == 0))
  320.     MomSize = eSymbolSize24Bit;
  321.  
  322.   /* entsprechend Modus Bytes ablegen */
  323.  
  324.   switch (MomSize)
  325.   {
  326.     case eSymbolSize8Bit:
  327.       if (!Is8(Address)) WrError(ErrNum_AdrOverflow);
  328.       else
  329.       {
  330.         AdrCnt = 2;
  331.         AdrVals[0] = Address & 0xff;
  332.         AdrMode = ModAbs8;
  333.       }
  334.       break;
  335.     case eSymbolSize16Bit:
  336.       if (!Is16(Address)) WrError(ErrNum_AdrOverflow);
  337.       else
  338.       {
  339.         AdrCnt = 2;
  340.         AdrVals[0] = Address & 0xffff;
  341.         AdrMode = ModAbs16;
  342.       }
  343.       break;
  344.     case eSymbolSize24Bit:
  345.       AdrCnt = 4;
  346.       AdrVals[1] = Address & 0xffff;
  347.       AdrVals[0] = Lo(Address >> 16);
  348.       AdrMode = ModAbs24;
  349.       break;
  350.     default:
  351.       WrError(ErrNum_InternalError);
  352.   }
  353. }
  354.  
  355. static void DecideAbsolute(const tStrComp *pArg, Word Mask)
  356. {
  357.   LongInt Addr;
  358.   Boolean OK;
  359.  
  360.   Addr = EvalStrIntExpression(pArg, Int32, &OK);
  361.   if (OK)
  362.     DecideVAbsolute(Addr, Mask);
  363. }
  364.  
  365.  
  366. static void DecodeAdr(tStrComp *pArg, Word Mask)
  367. {
  368.   tSymbolSize HSize;
  369.   Byte HReg;
  370.   LongInt HLong;
  371.   Boolean OK;
  372.   char *p;
  373.   LongInt DispAcc;
  374.   int ArgLen;
  375.  
  376.   AdrMode = ModNone;
  377.   AdrCnt = 0;
  378.   MomSize = eSymbolSizeUnknown;
  379.  
  380.   /* immediate ? */
  381.  
  382.   if (*pArg->str.p_str == '#')
  383.   {
  384.     switch (OpSize)
  385.     {
  386.       case eSymbolSizeUnknown:
  387.         WrError(ErrNum_UndefOpSizes);
  388.         break;
  389.       case eSymbolSize8Bit:
  390.         HReg = EvalStrIntExpressionOffs(pArg, 1, Int8, &OK);
  391.         if (OK)
  392.         {
  393.           AdrCnt = 2;
  394.           AdrVals[0] = HReg;
  395.           AdrMode = ModImm;
  396.         }
  397.         break;
  398.       case eSymbolSize16Bit:
  399.         AdrVals[0] = EvalStrIntExpressionOffs(pArg, 1, Int16, &OK);
  400.         if (OK)
  401.         {
  402.           AdrCnt = 2;
  403.           AdrMode = ModImm;
  404.         }
  405.         break;
  406.       case eSymbolSize32Bit:
  407.         HLong = EvalStrIntExpressionOffs(pArg, 1, Int32, &OK);
  408.         if (OK)
  409.         {
  410.           AdrCnt = 4;
  411.           AdrVals[0] = HLong >> 16;
  412.           AdrVals[1] = HLong & 0xffff;
  413.           AdrMode = ModImm;
  414.         }
  415.         break;
  416.       default:
  417.         WrError(ErrNum_InvOpSize);
  418.     }
  419.     goto chk;
  420.   }
  421.  
  422.   /* Register ? */
  423.  
  424.   switch (DecodeReg(pArg, &HReg, (1 << eSymbolSize8Bit) | (1 << eSymbolSize16Bit) | (1 << eSymbolSize32Bit), &HSize, False))
  425.   {
  426.     case eIsReg:
  427.       AdrMode = ModReg;
  428.       AdrPart = HReg;
  429.       SetOpSize(HSize);
  430.       goto chk;
  431.     case eRegAbort:
  432.       return;
  433.     case eIsNoReg:
  434.       break;
  435.   }
  436.  
  437.   /* indirekt ? */
  438.  
  439.   if (*pArg->str.p_str == '@')
  440.   {
  441.     tStrComp Arg;
  442.  
  443.     StrCompRefRight(&Arg, pArg, 1);
  444.  
  445.     if (*Arg.str.p_str == '@')
  446.     {
  447.       AdrVals[0] = EvalStrIntExpressionOffs(&Arg, 1, UInt8, &OK) & 0xff;
  448.       if (OK)
  449.       {
  450.         AdrCnt = 1;
  451.         AdrMode = ModIIAbs;
  452.       }
  453.       goto chk;
  454.     }
  455.  
  456.     switch (DecodeBaseReg(&Arg, &AdrPart, False))
  457.     {
  458.       case 1:
  459.         goto chk;
  460.       case 2:
  461.         AdrMode = ModIReg;
  462.         goto chk;
  463.     }
  464.  
  465.     if (*Arg.str.p_str == '-')
  466.     {
  467.       tStrComp Reg;
  468.  
  469.       StrCompRefRight(&Reg, &Arg, 1);
  470.       switch (DecodeBaseReg(&Reg, &AdrPart, True))
  471.       {
  472.         case 1:
  473.           goto chk;
  474.         case 2:
  475.           AdrMode = ModPreDec;
  476.           goto chk;
  477.       }
  478.     }
  479.  
  480.     ArgLen = strlen(Arg.str.p_str);
  481.     if (*Arg.str.p_str && (Arg.str.p_str[ArgLen - 1] == '+'))
  482.     {
  483.       StrCompShorten(&Arg, 1);
  484.       switch (DecodeBaseReg(&Arg, &AdrPart, True))
  485.       {
  486.         case 1:
  487.           goto chk;
  488.         case 2:
  489.          AdrMode = ModPostInc;
  490.          goto chk;
  491.       }
  492.       Arg.str.p_str[ArgLen - 1] = '+'; Arg.Pos.Len++;
  493.     }
  494.  
  495.     if (IsIndirect(Arg.str.p_str))
  496.     {
  497.       tStrComp Part, Remainder;
  498.  
  499.       StrCompRefRight(&Part, &Arg, 1);
  500.       StrCompShorten(&Part, 1);
  501.  
  502.       AdrPart = 0xff;
  503.       DispAcc = 0;
  504.       do
  505.       {
  506.         p = QuotPos(Part.str.p_str, ',');
  507.         if (p)
  508.           StrCompSplitRef(&Part, &Remainder, &Part, p);
  509.         switch (DecodeBaseReg(&Part, &HReg, False))
  510.         {
  511.           case 2:
  512.             if (AdrPart != 0xff)
  513.             {
  514.               WrError(ErrNum_InvAddrMode);
  515.               goto chk;
  516.             }
  517.             else
  518.               AdrPart = HReg;
  519.             break;
  520.           case 1:
  521.             goto chk;
  522.           case 0:
  523.             CutSize(&Part);
  524.             DispAcc += EvalStrIntExpression(&Part, Int32, &OK);
  525.             if (!OK)
  526.             {
  527.               goto chk;
  528.             }
  529.             break;
  530.         }
  531.         if (p)
  532.           Part = Remainder;
  533.       }
  534.       while (p);
  535.  
  536.       if (AdrPart == 0xff)
  537.         DecideVAbsolute(DispAcc, Mask);
  538.       else
  539.       {
  540.         if ((CPU16) && ((DispAcc & 0xffff8000) == 0x8000))
  541.           DispAcc += 0xffff0000;
  542.         if (MomSize == eSymbolSizeUnknown)
  543.           MomSize = ((DispAcc >= -32768) && (DispAcc <= 32767)) ? eSymbolSize16Bit : eSymbolSize24Bit;
  544.         switch (MomSize)
  545.         {
  546.           case eSymbolSize8Bit:
  547.             WrError(ErrNum_InvOpSize);
  548.             break;
  549.           case eSymbolSize16Bit:
  550.             if (ChkRange(DispAcc, -32768, 32767))
  551.             {
  552.               AdrCnt = 2;
  553.               AdrVals[0] = DispAcc & 0xffff;
  554.               AdrMode = ModInd16;
  555.             }
  556.             break;
  557.           case eSymbolSize24Bit:
  558.             AdrVals[1] = DispAcc & 0xffff;
  559.             AdrVals[0] = Lo(DispAcc >> 16);
  560.             AdrCnt = 4;
  561.             AdrMode = ModInd24;
  562.             break;
  563.           default:
  564.             WrError(ErrNum_InternalError);
  565.         }
  566.       }
  567.     }
  568.     else
  569.     {
  570.       CutSize(&Arg);
  571.       DecideAbsolute(&Arg, Mask);
  572.     }
  573.     goto chk;
  574.   }
  575.  
  576.   CutSize(pArg);
  577.   DecideAbsolute(pArg, Mask);
  578.  
  579. chk:
  580.   if (((AdrMode == ModReg) && (OpSize == eSymbolSize32Bit))
  581.    || ((AdrMode == ModReg) && (OpSize == eSymbolSize16Bit) && (AdrPart > 7))
  582.    || (AdrMode == ModAbs24)
  583.    || (AdrMode == ModInd24))
  584.   {
  585.     if (!ChkMinCPUExt(CPU6413309, ErrNum_AddrModeNotSupported))
  586.     {
  587.       AdrMode = ModNone;
  588.       AdrCnt = 0;
  589.     }
  590.   }
  591.   if ((AdrMode != ModNone) && ((Mask & (1 << AdrMode)) == 0))
  592.   {
  593.     WrError(ErrNum_InvAddrMode);
  594.     AdrMode = ModNone;
  595.     AdrCnt = 0;
  596.   }
  597. }
  598.  
  599. static LongInt ImmVal(void)
  600. {
  601.   switch (OpSize)
  602.   {
  603.     case eSymbolSize8Bit:
  604.       return Lo(AdrVals[0]);
  605.     case eSymbolSize16Bit:
  606.       return AdrVals[0];
  607.     case eSymbolSize32Bit:
  608.       return (((LongInt)AdrVals[0]) << 16) + AdrVals[1];
  609.     default:
  610.       WrError(ErrNum_InternalError);
  611.       return 0;
  612.   }
  613. }
  614.  
  615. /*--------------------------------------------------------------------------*/
  616. /* Bit Symbol Handling */
  617.  
  618. /*
  619.  * Compact representation of bits in symbol table:
  620.  * Bits 10...3: Absolute address (8-bit value for range $FFxx or $FFFFxx)
  621.  * Bits 0..2: Bit position
  622.  */
  623.  
  624. /*!------------------------------------------------------------------------
  625.  * \fn     EvalBitPosition(const tStrComp *pArg, Boolean *pOK)
  626.  * \brief  evaluate bit position
  627.  * \param  bit position argument (with or without #)
  628.  * \param  pOK parsing OK?
  629.  * \return numeric bit position
  630.  * ------------------------------------------------------------------------ */
  631.  
  632. static LongWord EvalBitPosition(const tStrComp *pArg, Boolean *pOK)
  633. {
  634.   return EvalStrIntExpressionOffs(pArg, !!(*pArg->str.p_str == '#'), UInt3, pOK);
  635. }
  636.  
  637. /*!------------------------------------------------------------------------
  638.  * \fn     AssembleBitSymbol(Byte BitPos, LongWord Address)
  639.  * \brief  build the compact internal representation of a bit symbol
  640.  * \param  BitPos bit position in byte
  641.  * \param  Address register address
  642.  * \return compact representation
  643.  * ------------------------------------------------------------------------ */
  644.  
  645. static LongWord AssembleBitSymbol(Byte BitPos, Word Address)
  646. {
  647.   return
  648.     (Address << 3)
  649.   | (BitPos << 0);
  650. }
  651.  
  652. /*!------------------------------------------------------------------------
  653.  * \fn     DecodeBitArg2(LongWord *pResult, const tStrComp *pBitArg, tStrComp *pRegArg)
  654.  * \brief  encode a bit symbol, address & bit position separated
  655.  * \param  pResult resulting encoded bit
  656.  * \param  pRegArg register argument
  657.  * \param  pBitArg bit argument
  658.  * \return True if success
  659.  * ------------------------------------------------------------------------ */
  660.  
  661. static Boolean DecodeBitArg2(LongWord *pResult, const tStrComp *pBitArg, tStrComp *pRegArg)
  662. {
  663.   Boolean OK;
  664.   LongWord BitPos;
  665.  
  666.   BitPos = EvalBitPosition(pBitArg, &OK);
  667.   if (!OK)
  668.     return False;
  669.  
  670.   DecideAbsolute(pRegArg, MModAbs8);
  671.   if (AdrMode != ModAbs8)
  672.     return False;
  673.  
  674.   *pResult = AssembleBitSymbol(BitPos, AdrVals[0]);
  675.   return True;
  676. }
  677.  
  678. /*!------------------------------------------------------------------------
  679.  * \fn     DecodeBitArg(LongWord *pResult, int Start, int Stop)
  680.  * \brief  encode a bit symbol from instruction argument(s)
  681.  * \param  pResult resulting encoded bit
  682.  * \param  Start first argument
  683.  * \param  Stop last argument
  684.  * \return True if success
  685.  * ------------------------------------------------------------------------ */
  686.  
  687. static Boolean DecodeBitArg(LongWord *pResult, int Start, int Stop)
  688. {
  689.   *pResult = 0;
  690.  
  691.   /* Just one argument -> parse as bit argument */
  692.  
  693.   if (Start == Stop)
  694.   {
  695.     tEvalResult EvalResult;
  696.  
  697.     *pResult = EvalStrIntExpressionWithResult(&ArgStr[Start], UInt32, &EvalResult);
  698.     if (EvalResult.OK)
  699.       ChkSpace(SegBData, EvalResult.AddrSpaceMask);
  700.     return EvalResult.OK;
  701.   }
  702.  
  703.   /* register & bit position are given as separate arguments */
  704.  
  705.   else if (Stop == Start + 1)
  706.     return DecodeBitArg2(pResult, &ArgStr[Start], &ArgStr[Stop]);
  707.  
  708.   /* other # of arguments not allowed */
  709.  
  710.   else
  711.   {
  712.     WrError(ErrNum_WrongArgCnt);
  713.     return False;
  714.   }
  715. }
  716.  
  717. /*!------------------------------------------------------------------------
  718.  * \fn     DissectBitSymbol(LongWord BitSymbol, Word *pAddress, Byte *pBitPos)
  719.  * \brief  transform compact representation of bit (field) symbol into components
  720.  * \param  BitSymbol compact storage
  721.  * \param  pAddress register address
  722.  * \param  pBitPos bit position
  723.  * \return constant True
  724.  * ------------------------------------------------------------------------ */
  725.  
  726. static Boolean DissectBitSymbol(LongWord BitSymbol, LongWord *pAddress, Byte *pBitPos)
  727. {
  728.   *pAddress = (BitSymbol >> 3) & 0xfful;
  729.   *pBitPos = BitSymbol & 7;
  730.   return True;
  731. }
  732.  
  733. /*!------------------------------------------------------------------------
  734.  * \fn     DissectBit_H8_3(char *pDest, size_t DestSize, LargeWord Inp)
  735.  * \brief  dissect compact storage of bit (field) into readable form for listing
  736.  * \param  pDest destination for ASCII representation
  737.  * \param  DestSize destination buffer size
  738.  * \param  Inp compact storage
  739.  * ------------------------------------------------------------------------ */
  740.  
  741. static void DissectBit_H8_3(char *pDest, size_t DestSize, LargeWord Inp)
  742. {
  743.   Byte BitPos;
  744.   LongWord Address;
  745.  
  746.   DissectBitSymbol(Inp, &Address, &BitPos);
  747.  
  748.   as_snprintf(pDest, DestSize, "#%u,$%s%x", BitPos,
  749.               (HexStartCharacter == 'A') ? (CPU16 ? "FF" : "FFFF") : (CPU16 ? "ff" : "ffff"),
  750.               (unsigned)Address);
  751. }
  752.  
  753. /*!------------------------------------------------------------------------
  754.  * \fn     ExpandBit_H8_3(const tStrComp *pVarName, const struct sStructElem *pStructElem, LargeWord Base)
  755.  * \brief  expands bit definition when a structure is instantiated
  756.  * \param  pVarName desired symbol name
  757.  * \param  pStructElem element definition
  758.  * \param  Base base address of instantiated structure
  759.  * ------------------------------------------------------------------------ */
  760.  
  761. static void ExpandBit_H8_3(const tStrComp *pVarName, const struct sStructElem *pStructElem, LargeWord Base)
  762. {
  763.   LongWord Address = Base + pStructElem->Offset;
  764.  
  765.   if (pInnermostNamedStruct)
  766.   {
  767.     PStructElem pElem = CloneStructElem(pVarName, pStructElem);
  768.  
  769.     if (!pElem)
  770.       return;
  771.     pElem->Offset = Address;
  772.     AddStructElem(pInnermostNamedStruct->StructRec, pElem);
  773.   }
  774.   else
  775.   {
  776.     if (!ChkRange(Address, SegLimits[SegCode] - 0xff, SegLimits[SegCode])
  777.      || !ChkRange(pStructElem->BitPos, 0, 7))
  778.       return;
  779.  
  780.     PushLocHandle(-1);
  781.     EnterIntSymbol(pVarName, AssembleBitSymbol(pStructElem->BitPos, Address), SegBData, False);
  782.     PopLocHandle();
  783.     /* TODO: MakeUseList? */
  784.   }
  785. }
  786.  
  787. /*-------------------------------------------------------------------------*/
  788. /* Code Generators */
  789.  
  790. static void DecodeFixed(Word Code)
  791. {
  792.   if (!ChkArgCnt(0, 0));
  793.   else if (*AttrPart.str.p_str) WrError(ErrNum_UseLessAttr);
  794.   else
  795.   {
  796.     CodeLen = 2;
  797.     WAsmCode[0] = Code;
  798.   }
  799. }
  800.  
  801. static void DecodeEEPMOV(Word Code)
  802. {
  803.   UNUSED(Code);
  804.  
  805.   if (OpSize == eSymbolSizeUnknown)
  806.     OpSize = CPU16 ? eSymbolSize8Bit : eSymbolSize16Bit;
  807.   if (OpSize > eSymbolSize16Bit) WrError(ErrNum_InvOpSize);
  808.   else if (!ChkArgCnt(0, 0));
  809.   else if ((OpSize == eSymbolSize16Bit) && !ChkCPU32(ErrNum_AddrModeNotSupported));
  810.   else
  811.   {
  812.     CodeLen = 4;
  813.     WAsmCode[0] = (OpSize == eSymbolSize8Bit) ? 0x7b5c : 0x7bd4;
  814.     WAsmCode[1] = 0x598f;
  815.   }
  816. }
  817.  
  818. static void DecodeMOV(Word Code)
  819. {
  820.   Byte HReg;
  821.  
  822.   UNUSED(Code);
  823.  
  824.   if (ChkArgCnt(2, 2))
  825.   {
  826.     DecodeAdr(&ArgStr[2], MModReg | MModIReg | MModPreDec | MModInd | MModAbs);
  827.     switch (AdrMode)
  828.     {
  829.       case ModReg:
  830.         HReg = AdrPart;
  831.         DecodeAdr(&ArgStr[1], MModReg | MModIReg | MModPostInc | MModInd | MModImm | ((OpSize == eSymbolSize8Bit) ? MModAbs : (MModAbs16 | MModAbs24)));
  832.         switch (AdrMode)
  833.         {
  834.           case ModReg:
  835.           {
  836.             int z = (OpSize == eSymbolSize32Bit) ? 3 : OpSize;
  837.  
  838.             CodeLen = 2;
  839.             WAsmCode[0] = 0x0c00 + (z << 8) + (AdrPart << 4) + HReg;
  840.             if (OpSize == eSymbolSize32Bit)
  841.               WAsmCode[0] += 0x80;
  842.             break;
  843.           }
  844.           case ModIReg:
  845.             switch (OpSize)
  846.             {
  847.               case eSymbolSize8Bit:
  848.                 CodeLen = 2;
  849.                 WAsmCode[0] = 0x6800 + (AdrPart << 4) + HReg;
  850.                 break;
  851.               case eSymbolSize16Bit:
  852.                 CodeLen = 2;
  853.                 WAsmCode[0] = 0x6900 + (AdrPart << 4) + HReg;
  854.                 break;
  855.               case eSymbolSize32Bit:
  856.                 CodeLen = 4;
  857.                 WAsmCode[0] = 0x0100;
  858.                 WAsmCode[1] = 0x6900 + (AdrPart << 4) + HReg;
  859.                 break;
  860.               default:
  861.                 break;
  862.             }
  863.             break;
  864.           case ModPostInc:
  865.             switch (OpSize)
  866.             {
  867.               case eSymbolSize8Bit:
  868.                 CodeLen = 2;
  869.                 WAsmCode[0] = 0x6c00 + (AdrPart << 4) + HReg;
  870.                 break;
  871.               case eSymbolSize16Bit:
  872.                 CodeLen = 2;
  873.                 WAsmCode[0] = 0x6d00 + (AdrPart << 4) + HReg;
  874.                 break;
  875.               case eSymbolSize32Bit:
  876.                 CodeLen = 4;
  877.                 WAsmCode[0] = 0x0100;
  878.                 WAsmCode[1] = 0x6d00 + (AdrPart << 4) + HReg;
  879.                 break;
  880.               default:
  881.                 break;
  882.             }
  883.             break;
  884.           case ModInd16:
  885.             switch (OpSize)
  886.             {
  887.               case eSymbolSize8Bit:
  888.                 CodeLen = 4;
  889.                 WAsmCode[0] = 0x6e00 + (AdrPart << 4) + HReg;
  890.                 WAsmCode[1] = AdrVals[0];
  891.                 break;
  892.               case eSymbolSize16Bit:
  893.                 CodeLen = 4;
  894.                 WAsmCode[0] = 0x6f00 + (AdrPart << 4) + HReg;
  895.                 WAsmCode[1] = AdrVals[0];
  896.                 break;
  897.               case eSymbolSize32Bit:
  898.                 CodeLen = 6;
  899.                 WAsmCode[0] = 0x0100;
  900.                 WAsmCode[1] = 0x6f00 + (AdrPart << 4) + HReg;
  901.                 WAsmCode[2] = AdrVals[0];
  902.                 break;
  903.               default:
  904.                 break;
  905.             }
  906.             break;
  907.           case ModInd24:
  908.             switch (OpSize)
  909.             {
  910.               case eSymbolSize8Bit:
  911.                 CodeLen = 8;
  912.                 WAsmCode[0] = 0x7800 + (AdrPart << 4);
  913.                 WAsmCode[1] = 0x6a20 + HReg;
  914.                 memcpy(WAsmCode + 2, AdrVals, AdrCnt);
  915.                 break;
  916.               case eSymbolSize16Bit:
  917.                 CodeLen = 8;
  918.                 WAsmCode[0] = 0x7800 + (AdrPart << 4);
  919.                 WAsmCode[1] = 0x6b20 + HReg;
  920.                 memcpy(WAsmCode + 2, AdrVals, AdrCnt);
  921.                 break;
  922.               case eSymbolSize32Bit:
  923.                 CodeLen = 10;
  924.                 WAsmCode[0] = 0x0100;
  925.                 WAsmCode[1] = 0x7800 + (AdrPart << 4);
  926.                 WAsmCode[2] = 0x6b20 + HReg;
  927.                 memcpy(WAsmCode + 3, AdrVals, AdrCnt);
  928.                 break;
  929.               default:
  930.                 break;
  931.             }
  932.             break;
  933.           case ModAbs8:
  934.             CodeLen = 2;
  935.             WAsmCode[0] = 0x2000 + (((Word)HReg) << 8) + Lo(AdrVals[0]);
  936.             break;
  937.           case ModAbs16:
  938.             switch (OpSize)
  939.             {
  940.               case eSymbolSize8Bit:
  941.                 CodeLen = 4;
  942.                 WAsmCode[0] = 0x6a00 + HReg;
  943.                 WAsmCode[1] = AdrVals[0];
  944.                 break;
  945.               case eSymbolSize16Bit:
  946.                 CodeLen = 4;
  947.                 WAsmCode[0] = 0x6b00 + HReg;
  948.                 WAsmCode[1] = AdrVals[0];
  949.                 break;
  950.               case eSymbolSize32Bit:
  951.                 CodeLen = 6;
  952.                 WAsmCode[0] = 0x0100;
  953.                 WAsmCode[1] = 0x6b00 + HReg;
  954.                 WAsmCode[2] = AdrVals[0];
  955.                 break;
  956.               default:
  957.                 break;
  958.             }
  959.             break;
  960.           case ModAbs24:
  961.             switch (OpSize)
  962.             {
  963.               case eSymbolSize8Bit:
  964.                 CodeLen = 6;
  965.                 WAsmCode[0] = 0x6a20 + HReg;
  966.                 memcpy(WAsmCode + 1, AdrVals, AdrCnt);
  967.                 break;
  968.               case eSymbolSize16Bit:
  969.                 CodeLen = 6;
  970.                 WAsmCode[0] = 0x6b20 + HReg;
  971.                 memcpy(WAsmCode + 1, AdrVals, AdrCnt);
  972.                 break;
  973.               case eSymbolSize32Bit:
  974.                 CodeLen = 8;
  975.                 WAsmCode[0] = 0x0100;
  976.                 WAsmCode[1] = 0x6b20 + HReg;
  977.                 memcpy(WAsmCode + 2, AdrVals, AdrCnt);
  978.                 break;
  979.               default:
  980.                 break;
  981.             }
  982.             break;
  983.           case ModImm:
  984.             switch (OpSize)
  985.             {
  986.               case eSymbolSize8Bit:
  987.                 CodeLen = 2;
  988.                 WAsmCode[0] = 0xf000 + (((Word)HReg) << 8) + Lo(AdrVals[0]);
  989.                 break;
  990.               case eSymbolSize16Bit:
  991.                 CodeLen = 4;
  992.                 WAsmCode[0] = 0x7900 + HReg;
  993.                 WAsmCode[1] = AdrVals[0];
  994.                 break;
  995.               case eSymbolSize32Bit:
  996.                 CodeLen = 6;
  997.                 WAsmCode[0] = 0x7a00 + HReg;
  998.                 memcpy(WAsmCode + 1, AdrVals, AdrCnt);
  999.                 break;
  1000.               default:
  1001.                 break;
  1002.             }
  1003.             break;
  1004.         }
  1005.         break;
  1006.       case ModIReg:
  1007.         HReg = AdrPart;
  1008.         DecodeAdr(&ArgStr[1], MModReg);
  1009.         if (AdrMode != ModNone)
  1010.         {
  1011.           switch (OpSize)
  1012.           {
  1013.             case eSymbolSize8Bit:
  1014.               CodeLen = 2;
  1015.               WAsmCode[0] = 0x6880 + (HReg << 4) + AdrPart;
  1016.               break;
  1017.             case eSymbolSize16Bit:
  1018.               CodeLen = 2;
  1019.               WAsmCode[0] = 0x6980 + (HReg << 4) + AdrPart;
  1020.               break;
  1021.             case eSymbolSize32Bit:
  1022.               CodeLen = 4;
  1023.               WAsmCode[0] = 0x0100;
  1024.               WAsmCode[1] = 0x6980 + (HReg << 4) + AdrPart;
  1025.               break;
  1026.             default:
  1027.               break;
  1028.           }
  1029.         }
  1030.         break;
  1031.       case ModPreDec:
  1032.         HReg = AdrPart;
  1033.         DecodeAdr(&ArgStr[1], MModReg);
  1034.         if (AdrMode != ModNone)
  1035.         {
  1036.           switch (OpSize)
  1037.           {
  1038.             case eSymbolSize8Bit:
  1039.               CodeLen=2; WAsmCode[0]=0x6c80+(HReg << 4)+AdrPart;
  1040.               break;
  1041.             case eSymbolSize16Bit:
  1042.               CodeLen=2; WAsmCode[0]=0x6d80+(HReg << 4)+AdrPart;
  1043.               break;
  1044.             case eSymbolSize32Bit:
  1045.               CodeLen=4; WAsmCode[0]=0x0100;
  1046.               WAsmCode[1]=0x6d80+(HReg << 4)+AdrPart;
  1047.               break;
  1048.             default:
  1049.               break;
  1050.           }
  1051.         }
  1052.         break;
  1053.       case ModInd16:
  1054.         HReg = AdrPart;
  1055.         WAsmCode[1] = AdrVals[0];
  1056.         DecodeAdr(&ArgStr[1], MModReg);
  1057.         if (AdrMode!=ModNone)
  1058.         {
  1059.           switch (OpSize)
  1060.           {
  1061.             case eSymbolSize8Bit:
  1062.               CodeLen = 4;
  1063.               WAsmCode[0] = 0x6e80 + (HReg << 4) + AdrPart;
  1064.               break;
  1065.             case eSymbolSize16Bit:
  1066.               CodeLen = 4;
  1067.               WAsmCode[0] = 0x6f80 + (HReg << 4) + AdrPart;
  1068.               break;
  1069.             case eSymbolSize32Bit:
  1070.               CodeLen = 6;
  1071.               WAsmCode[0] = 0x0100;
  1072.               WAsmCode[2] = WAsmCode[1];
  1073.               WAsmCode[1] = 0x6f80 + (HReg << 4) + AdrPart;
  1074.               break;
  1075.             default:
  1076.               break;
  1077.           }
  1078.         }
  1079.         break;
  1080.       case ModInd24:
  1081.         HReg = AdrPart;
  1082.         memcpy(WAsmCode + 2, AdrVals, 4);
  1083.         DecodeAdr(&ArgStr[1], MModReg);
  1084.         if (AdrMode != ModNone)
  1085.         {
  1086.           switch (OpSize)
  1087.           {
  1088.             case eSymbolSize8Bit:
  1089.               CodeLen = 8;
  1090.               WAsmCode[0] = 0x7800 + (HReg << 4);
  1091.               WAsmCode[1] = 0x6aa0 + AdrPart;
  1092.               break;
  1093.             case eSymbolSize16Bit:
  1094.               CodeLen = 8;
  1095.               WAsmCode[0] = 0x7800 + (HReg << 4);
  1096.               WAsmCode[1] = 0x6ba0 + AdrPart;
  1097.               break;
  1098.             case eSymbolSize32Bit:
  1099.               CodeLen = 10;
  1100.               WAsmCode[0] = 0x0100;
  1101.               WAsmCode[4] = WAsmCode[3];
  1102.               WAsmCode[3] = WAsmCode[2];
  1103.               WAsmCode[1] = 0x7800 + (HReg << 4);
  1104.               WAsmCode[2] = 0x6ba0 + AdrPart;
  1105.               break;
  1106.             default:
  1107.               break;
  1108.           }
  1109.         }
  1110.         break;
  1111.       case ModAbs8:
  1112.         HReg = Lo(AdrVals[0]);
  1113.         DecodeAdr(&ArgStr[1], MModReg);
  1114.         if (AdrMode != ModNone)
  1115.         {
  1116.           switch (OpSize)
  1117.           {
  1118.             case eSymbolSize8Bit:
  1119.               CodeLen = 2;
  1120.               WAsmCode[0] = 0x3000 + (((Word)AdrPart) << 8) + HReg;
  1121.               break;
  1122.             case eSymbolSize16Bit:
  1123.               CodeLen = 4;
  1124.               WAsmCode[0] = 0x6b80 + AdrPart;
  1125.               WAsmCode[1] = 0xff00 + HReg;
  1126.               break;
  1127.             case eSymbolSize32Bit:
  1128.               CodeLen = 6;
  1129.               WAsmCode[0] = 0x0100;
  1130.               WAsmCode[1] = 0x6b80 + AdrPart;
  1131.               WAsmCode[2] = 0xff00 + HReg;
  1132.               break;
  1133.             default:
  1134.               break;
  1135.           }
  1136.         }
  1137.         break;
  1138.       case ModAbs16:
  1139.         WAsmCode[1] = AdrVals[0];
  1140.         DecodeAdr(&ArgStr[1], MModReg);
  1141.         if (AdrMode != ModNone)
  1142.         {
  1143.           switch (OpSize)
  1144.           {
  1145.             case eSymbolSize8Bit:
  1146.               CodeLen = 4;
  1147.               WAsmCode[0] = 0x6a80 + AdrPart;
  1148.               break;
  1149.             case eSymbolSize16Bit:
  1150.               CodeLen = 4;
  1151.               WAsmCode[0] = 0x6b80 + AdrPart;
  1152.               break;
  1153.             case eSymbolSize32Bit:
  1154.               CodeLen = 6;
  1155.               WAsmCode[0] = 0x0100;
  1156.               WAsmCode[2] = WAsmCode[1];
  1157.               WAsmCode[1] = 0x6b80 + AdrPart;
  1158.               break;
  1159.             default:
  1160.               break;
  1161.           }
  1162.         }
  1163.         break;
  1164.       case ModAbs24:
  1165.         memcpy(WAsmCode + 1, AdrVals, 4);
  1166.         DecodeAdr(&ArgStr[1], MModReg);
  1167.         if (AdrMode != ModNone)
  1168.         {
  1169.           switch (OpSize)
  1170.           {
  1171.             case eSymbolSize8Bit:
  1172.               CodeLen = 6;
  1173.               WAsmCode[0] = 0x6aa0 + AdrPart;
  1174.               break;
  1175.             case eSymbolSize16Bit:
  1176.               CodeLen = 6;
  1177.               WAsmCode[0] = 0x6ba0 + AdrPart;
  1178.               break;
  1179.             case eSymbolSize32Bit:
  1180.               CodeLen = 8;
  1181.               WAsmCode[0] = 0x0100;
  1182.               WAsmCode[3] = WAsmCode[2];
  1183.               WAsmCode[2] = WAsmCode[1];
  1184.               WAsmCode[1] = 0x6ba0 + AdrPart;
  1185.               break;
  1186.             default:
  1187.               break;
  1188.           }
  1189.         }
  1190.         break;
  1191.     }
  1192.   }
  1193. }
  1194.  
  1195. static void DecodeMOVTPE_MOVFPE(Word CodeTPE)
  1196. {
  1197.   if (ChkArgCnt(2, 2)
  1198.    && ChkMinCPU(CPU6413308))
  1199.   {
  1200.     tStrComp *pRegArg = CodeTPE ? &ArgStr[1] : &ArgStr[2],
  1201.              *pMemArg = CodeTPE ? &ArgStr[2] : &ArgStr[1];
  1202.  
  1203.     DecodeAdr(pRegArg, MModReg);
  1204.     if (AdrMode != ModNone)
  1205.     {
  1206.       if (OpSize != eSymbolSize8Bit) WrError(ErrNum_InvOpSize);
  1207.       else
  1208.       {
  1209.         Byte HReg = AdrPart;
  1210.         DecodeAdr(pMemArg, MModAbs16);
  1211.         if (AdrMode != ModNone)
  1212.         {
  1213.           CodeLen = 4;
  1214.           WAsmCode[0] = 0x6a40 + CodeTPE + HReg;
  1215.           WAsmCode[1] = AdrVals[0];
  1216.         }
  1217.       }
  1218.     }
  1219.   }
  1220. }
  1221.  
  1222. static void DecodePUSH_POP(Word Code)
  1223. {
  1224.   if (ChkArgCnt(1, 1))
  1225.   {
  1226.     DecodeAdr(&ArgStr[1], MModReg);
  1227.     if (AdrMode != ModNone)
  1228.     {
  1229.       if (OpSize == eSymbolSize8Bit) WrError(ErrNum_InvOpSize);
  1230.       else if ((OpSize != eSymbolSize32Bit) || ChkCPU32(ErrNum_AddrModeNotSupported))
  1231.       {
  1232.         if (OpSize == eSymbolSize32Bit)
  1233.           WAsmCode[0] = 0x0100;
  1234.         CodeLen = 2 * OpSize;
  1235.         WAsmCode[(CodeLen - 2) >> 1] = Code + AdrPart;
  1236.       }
  1237.     }
  1238.   }
  1239. }
  1240.  
  1241. static void DecodeLDC_STC(Word CodeIsSTC)
  1242. {
  1243.   if (ChkArgCnt(2, 2))
  1244.   {
  1245.     tStrComp *pRegArg = CodeIsSTC ? &ArgStr[1] : &ArgStr[2],
  1246.              *pMemArg = CodeIsSTC ? &ArgStr[2] : &ArgStr[1];
  1247.  
  1248.     if (as_strcasecmp(pRegArg->str.p_str, "CCR")) WrError(ErrNum_InvAddrMode);
  1249.     else
  1250.     {
  1251.        SetOpSize(eSymbolSize8Bit);
  1252.        DecodeAdr(pMemArg, MModReg | MModIReg | MModInd | MModAbs16 | MModAbs24 | (CodeIsSTC ? MModPreDec : (MModImm | MModPostInc)));
  1253.        switch (AdrMode)
  1254.        {
  1255.          case ModReg:
  1256.            CodeLen = 2;
  1257.            WAsmCode[0] = 0x0300 + AdrPart - (CodeIsSTC << 1);
  1258.            break;
  1259.          case ModIReg:
  1260.            CodeLen = 4;
  1261.            WAsmCode[0] = 0x0140;
  1262.            WAsmCode[1] = 0x6900 + CodeIsSTC + (AdrPart << 4);
  1263.            break;
  1264.          case ModPostInc:
  1265.          case ModPreDec:
  1266.            CodeLen = 4;
  1267.            WAsmCode[0] = 0x0140;
  1268.            WAsmCode[1] = 0x6d00 + CodeIsSTC + (AdrPart << 4);
  1269.            break;
  1270.          case ModInd16:
  1271.            CodeLen = 6;
  1272.            WAsmCode[0] = 0x0140;
  1273.            WAsmCode[2] = AdrVals[0];
  1274.            WAsmCode[1] = 0x6f00 + CodeIsSTC + (AdrPart << 4);
  1275.            break;
  1276.          case ModInd24:
  1277.            CodeLen = 10;
  1278.            WAsmCode[0] = 0x0140;
  1279.            WAsmCode[1] = 0x7800 + (AdrPart << 4);
  1280.            WAsmCode[2] = 0x6b20 + CodeIsSTC;
  1281.            memcpy(WAsmCode + 3, AdrVals, AdrCnt);
  1282.            break;
  1283.          case ModAbs16:
  1284.            CodeLen = 6;
  1285.            WAsmCode[0] = 0x0140;
  1286.            WAsmCode[2] = AdrVals[0];
  1287.            WAsmCode[1] = 0x6b00 + CodeIsSTC;
  1288.            break;
  1289.          case ModAbs24:
  1290.            CodeLen = 8;
  1291.            WAsmCode[0] = 0x0140;
  1292.            WAsmCode[1] = 0x6b20 + CodeIsSTC;
  1293.            memcpy(WAsmCode + 2, AdrVals, AdrCnt);
  1294.            break;
  1295.          case ModImm:
  1296.            CodeLen = 2;
  1297.            WAsmCode[0] = 0x0700 + Lo(AdrVals[0]);
  1298.            break;
  1299.        }
  1300.     }
  1301.   }
  1302. }
  1303.  
  1304. static void DecodeADD_SUB(Word IsSUB)
  1305. {
  1306.   if (ChkArgCnt(2, 2))
  1307.   {
  1308.     DecodeAdr(&ArgStr[2], MModReg);
  1309.     if (AdrMode != ModNone)
  1310.     {
  1311.       Byte HReg = AdrPart;
  1312.       DecodeAdr(&ArgStr[1], MModReg | MModImm);
  1313.       if (AdrMode != ModNone)
  1314.       {
  1315.         if (((OpSize > eSymbolSize16Bit) || ((OpSize == eSymbolSize16Bit) && (AdrMode == ModImm))) && !ChkCPU32(ErrNum_AddrModeNotSupported));
  1316.         else
  1317.         {
  1318.           switch (AdrMode)
  1319.           {
  1320.             case ModImm:
  1321.               switch (OpSize)
  1322.               {
  1323.                 case eSymbolSize8Bit:
  1324.                   if (IsSUB) WrError(ErrNum_InvAddrMode);
  1325.                   else
  1326.                   {
  1327.                     CodeLen = 2;
  1328.                     WAsmCode[0] = 0x8000 + (((Word)HReg) << 8) + Lo(AdrVals[0]);
  1329.                   }
  1330.                   break;
  1331.                 case eSymbolSize16Bit:
  1332.                   CodeLen = 4;
  1333.                   WAsmCode[1] = AdrVals[0];
  1334.                   WAsmCode[0] = 0x7910 + (IsSUB << 5) + HReg;
  1335.                   break;
  1336.                 case eSymbolSize32Bit:
  1337.                   CodeLen = 6;
  1338.                   memcpy(WAsmCode + 1, AdrVals, 4);
  1339.                   WAsmCode[0] = 0x7a10 + (IsSUB << 5) + HReg;
  1340.                   break;
  1341.                 default:
  1342.                   break;
  1343.               }
  1344.               break;
  1345.             case ModReg:
  1346.               switch (OpSize)
  1347.               {
  1348.                 case eSymbolSize8Bit:
  1349.                   CodeLen = 2;
  1350.                   WAsmCode[0] = 0x0800 + (IsSUB << 12) + (AdrPart << 4) + HReg;
  1351.                   break;
  1352.                 case eSymbolSize16Bit:
  1353.                   CodeLen = 2;
  1354.                   WAsmCode[0] = 0x0900 + (IsSUB << 12) + (AdrPart << 4) + HReg;
  1355.                   break;
  1356.                 case eSymbolSize32Bit:
  1357.                   CodeLen = 2;
  1358.                   WAsmCode[0] = 0x0a00 + (IsSUB << 12) + 0x80 + (AdrPart << 4) + HReg;
  1359.                   break;
  1360.                 default:
  1361.                   break;
  1362.               }
  1363.               break;
  1364.           }
  1365.         }
  1366.       }
  1367.     }
  1368.   }
  1369. }
  1370.  
  1371. static void DecodeCMP(Word Code)
  1372. {
  1373.   UNUSED(Code);
  1374.  
  1375.   if (ChkArgCnt(2, 2))
  1376.   {
  1377.     DecodeAdr(&ArgStr[2], MModReg);
  1378.     if (AdrMode != ModNone)
  1379.     {
  1380.       Byte HReg = AdrPart;
  1381.       DecodeAdr(&ArgStr[1], MModReg | MModImm);
  1382.       if (AdrMode != ModNone)
  1383.       {
  1384.         if (((OpSize > eSymbolSize16Bit) || ((OpSize == eSymbolSize16Bit) && (AdrMode == ModImm))) && !ChkCPU32(ErrNum_AddrModeNotSupported));
  1385.         else
  1386.         {
  1387.           switch (AdrMode)
  1388.           {
  1389.             case ModImm:
  1390.               switch (OpSize)
  1391.               {
  1392.                 case eSymbolSize8Bit:
  1393.                   CodeLen = 2;
  1394.                   WAsmCode[0] = 0xa000 + (((Word)HReg) << 8) + Lo(AdrVals[0]);
  1395.                   break;
  1396.                 case eSymbolSize16Bit:
  1397.                   CodeLen = 4;
  1398.                   WAsmCode[1] = AdrVals[0];
  1399.                   WAsmCode[0] = 0x7920 + HReg;
  1400.                   break;
  1401.                 case eSymbolSize32Bit:
  1402.                   CodeLen = 6;
  1403.                   memcpy(WAsmCode + 1, AdrVals, 4);
  1404.                   WAsmCode[0] = 0x7a20 + HReg;
  1405.                 default:
  1406.                   break;
  1407.               }
  1408.               break;
  1409.             case ModReg:
  1410.               switch (OpSize)
  1411.               {
  1412.                 case eSymbolSize8Bit:
  1413.                   CodeLen = 2;
  1414.                   WAsmCode[0] = 0x1c00 + (AdrPart << 4) + HReg;
  1415.                   break;
  1416.                 case eSymbolSize16Bit:
  1417.                   CodeLen = 2;
  1418.                   WAsmCode[0] = 0x1d00 + (AdrPart << 4) + HReg;
  1419.                   break;
  1420.                 case eSymbolSize32Bit:
  1421.                   CodeLen = 2;
  1422.                   WAsmCode[0] = 0x1f80 + (AdrPart << 4) + HReg;
  1423.                   break;
  1424.                 default:
  1425.                   break;
  1426.               }
  1427.               break;
  1428.           }
  1429.         }
  1430.       }
  1431.     }
  1432.   }
  1433. }
  1434.  
  1435. static void DecodeLogic(Word Code)
  1436. {
  1437.   if (ChkArgCnt(2, 2))
  1438.   {
  1439.     DecodeAdr(&ArgStr[2], MModReg);
  1440.     if (AdrMode != ModNone)
  1441.     {
  1442.       if ((OpSize <= eSymbolSize8Bit) || ChkCPU32(ErrNum_AddrModeNotSupported))
  1443.       {
  1444.         Byte HReg = AdrPart;
  1445.         DecodeAdr(&ArgStr[1], MModImm | MModReg);
  1446.         switch (AdrMode)
  1447.         {
  1448.           case ModImm:
  1449.             switch (OpSize)
  1450.             {
  1451.               case eSymbolSize8Bit:
  1452.                 CodeLen = 2;
  1453.                 WAsmCode[0] = 0xc000 + (Code << 12) + (((Word)HReg) << 8) + Lo(AdrVals[0]);
  1454.                 break;
  1455.               case eSymbolSize16Bit:
  1456.                 CodeLen = 4;
  1457.                 WAsmCode[1] = AdrVals[0];
  1458.                 WAsmCode[0] = 0x7940 + (Code << 4) + HReg;
  1459.                 break;
  1460.               case eSymbolSize32Bit:
  1461.                 CodeLen = 6;
  1462.                 memcpy(WAsmCode + 1, AdrVals, AdrCnt);
  1463.                 WAsmCode[0] = 0x7a40 + (Code << 4) + HReg;
  1464.                 break;
  1465.               default:
  1466.                 break;
  1467.             }
  1468.             break;
  1469.           case ModReg:
  1470.             switch (OpSize)
  1471.             {
  1472.               case eSymbolSize8Bit:
  1473.                 CodeLen = 2;
  1474.                 WAsmCode[0] = 0x1400 + (Code << 8) + (AdrPart << 4) + HReg;
  1475.                 break;
  1476.               case eSymbolSize16Bit:
  1477.                 CodeLen = 2;
  1478.                 WAsmCode[0] = 0x6400 + (Code << 8) + (AdrPart << 4) + HReg;
  1479.                 break;
  1480.               case eSymbolSize32Bit:
  1481.                 CodeLen = 4;
  1482.                 WAsmCode[0] = 0x01f0;
  1483.                 WAsmCode[1] = 0x6400 + (Code << 8) + (AdrPart << 4) + HReg;
  1484.                 break;
  1485.               default:
  1486.                 break;
  1487.             }
  1488.             break;
  1489.         }
  1490.       }
  1491.     }
  1492.   }
  1493. }
  1494.  
  1495. static void DecodeLogicBit(Word Code)
  1496. {
  1497.   SetOpSize(eSymbolSize8Bit);
  1498.   if (!ChkArgCnt(2, 2));
  1499.   else if (as_strcasecmp(ArgStr[2].str.p_str, "CCR")) WrError(ErrNum_InvAddrMode);
  1500.   else
  1501.   {
  1502.     DecodeAdr(&ArgStr[1], MModImm);
  1503.     if (AdrMode != ModNone)
  1504.     {
  1505.       CodeLen = 2;
  1506.       WAsmCode[0] = 0x0400 + (Code << 8) + Lo(AdrVals[0]);
  1507.     }
  1508.   }
  1509. }
  1510.  
  1511. static void DecodeADDX_SUBX(Word IsSUBX)
  1512. {
  1513.   if (ChkArgCnt(2, 2))
  1514.   {
  1515.     DecodeAdr(&ArgStr[2], MModReg);
  1516.     if (AdrMode != ModNone)
  1517.     {
  1518.       if (OpSize != eSymbolSize8Bit) WrError(ErrNum_InvOpSize);
  1519.       else
  1520.       {
  1521.         Byte HReg = AdrPart;
  1522.         DecodeAdr(&ArgStr[1], MModImm | MModReg);
  1523.         switch (AdrMode)
  1524.         {
  1525.           case ModImm:
  1526.             CodeLen = 2;
  1527.             WAsmCode[0] = 0x9000 + (((Word)HReg) << 8) + Lo(AdrVals[0]) + (IsSUBX << 13);
  1528.             break;
  1529.           case ModReg:
  1530.             CodeLen = 2;
  1531.             WAsmCode[0] = 0x0e00 + (AdrPart << 4) + HReg + (IsSUBX << 12);
  1532.             break;
  1533.         }
  1534.       }
  1535.     }
  1536.   }
  1537. }
  1538.  
  1539. static void DecodeADDS_SUBS(Word IsSUBS)
  1540. {
  1541.   if (ChkArgCnt(2, 2))
  1542.   {
  1543.     DecodeAdr(&ArgStr[2], MModReg);
  1544.     if (AdrMode != ModNone)
  1545.     {
  1546.       if (((CPU16) && (OpSize != eSymbolSize16Bit)) || ((!CPU16) && (OpSize != eSymbolSize32Bit))) WrError(ErrNum_InvOpSize);
  1547.       else
  1548.       {
  1549.         Byte HReg = AdrPart;
  1550.         DecodeAdr(&ArgStr[1], MModImm);
  1551.         if (AdrMode != ModNone)
  1552.         {
  1553.           LongInt AdrLong = ImmVal();
  1554.           if ((AdrLong != 1) && (AdrLong != 2) && (AdrLong != 4)) WrError(ErrNum_OverRange);
  1555.           else
  1556.           {
  1557.             switch (AdrLong)
  1558.             {
  1559.               case 1: WAsmCode[0] = 0x0b00; break;
  1560.               case 2: WAsmCode[0] = 0x0b80; break;
  1561.               case 4: WAsmCode[0] = 0x0b90; break;
  1562.             }
  1563.             CodeLen = 2;
  1564.             WAsmCode[0] += HReg + IsSUBS;
  1565.           }
  1566.         }
  1567.       }
  1568.     }
  1569.   }
  1570. }
  1571.  
  1572. static void DecodeMul(Word Code)
  1573. {
  1574.   if (ChkArgCnt(2, 2))
  1575.   {
  1576.     if (OpSize != eSymbolSizeUnknown) OpSize++;
  1577.     DecodeAdr(&ArgStr[2], MModReg);
  1578.     if (AdrMode != ModNone)
  1579.     {
  1580.       if (OpSize == eSymbolSize8Bit) WrError(ErrNum_InvOpSize);
  1581.       else if ((OpSize != eSymbolSize32Bit) || ChkCPU32(ErrNum_AddrModeNotSupported))
  1582.       {
  1583.         Byte HReg = AdrPart;
  1584.         OpSize--;
  1585.         DecodeAdr(&ArgStr[1], MModReg);
  1586.         if (AdrMode != ModNone)
  1587.         {
  1588.           if ((Code & 2) == 2)
  1589.           {
  1590.             CodeLen = 4;
  1591.             WAsmCode[0] = 0x01c0;
  1592.             if ((Code & 1) == 1)
  1593.               WAsmCode[0] += 0x10;
  1594.           }
  1595.           else
  1596.             CodeLen=2;
  1597.           WAsmCode[CodeLen >> 2] = 0x5000
  1598.                                  + (((Word)OpSize) << 9)
  1599.                                  + ((Code & 1) << 8)
  1600.                                  + (AdrPart << 4) + HReg;
  1601.         }
  1602.       }
  1603.     }
  1604.   }
  1605. }
  1606.  
  1607. static void DecodeBit1(Word Code)
  1608. {
  1609.   Word OpCode = 0x60 + (Code & 0x7f);
  1610.   Byte BitPos;
  1611.  
  1612.   switch (ArgCnt)
  1613.   {
  1614.     case 1:
  1615.     {
  1616.       LongWord BitSpec;
  1617.  
  1618.       if (DecodeBitArg(&BitSpec, 1, 1))
  1619.       {
  1620.         LongWord Addr;
  1621.  
  1622.         DissectBitSymbol(BitSpec, &Addr, &BitPos);
  1623.         AdrMode = ModAbs8;
  1624.         AdrVals[0] = Addr & 0xff;
  1625.         AdrCnt = 2;
  1626.         goto common;
  1627.       }
  1628.       break;
  1629.     }
  1630.     case 2:
  1631.     {
  1632.       Boolean OK;
  1633.  
  1634.       BitPos = EvalBitPosition(&ArgStr[1], &OK);
  1635.       if (OK)
  1636.       {
  1637.         DecodeAdr(&ArgStr[2], MModReg | MModIReg | MModAbs8);
  1638.         if (AdrMode != ModNone)
  1639.           goto common;
  1640.       }
  1641.       break;
  1642.     }
  1643.     common:
  1644.       if (OpSize > eSymbolSize8Bit) WrError(ErrNum_InvOpSize);
  1645.       else switch (AdrMode)
  1646.       {
  1647.         case ModReg:
  1648.           CodeLen = 2;
  1649.           WAsmCode[0] = (OpCode << 8) + (Code & 0x80) + (BitPos << 4) + AdrPart;
  1650.           break;
  1651.         case ModIReg:
  1652.           CodeLen = 4;
  1653.           WAsmCode[0] = 0x7c00 + (AdrPart << 4);
  1654.           WAsmCode[1] = (OpCode << 8) + (Code & 0x80) + (BitPos << 4);
  1655.           if (OpCode < 0x70)
  1656.             WAsmCode[0] += 0x100;
  1657.           break;
  1658.         case ModAbs8:
  1659.           CodeLen = 4;
  1660.           WAsmCode[0] = 0x7e00 + Lo(AdrVals[0]);
  1661.           WAsmCode[1] = (OpCode << 8) + (Code & 0x80) + (BitPos << 4);
  1662.           if (OpCode < 0x70)
  1663.             WAsmCode[0] += 0x100;
  1664.           break;
  1665.       }
  1666.       break;
  1667.     default:
  1668.       (void)ChkArgCnt(1, 2);
  1669.   }
  1670. }
  1671.  
  1672. static void DecodeBit2(Word Code)
  1673. {
  1674.   Word OpCode;
  1675.   Byte Bit;
  1676.   Boolean OK;
  1677.   tSymbolSize HSize;
  1678.  
  1679.   switch (ArgCnt)
  1680.   {
  1681.     case 1:
  1682.     {
  1683.       LongWord BitSpec;
  1684.  
  1685.       if (DecodeBitArg(&BitSpec, 1, 1))
  1686.       {
  1687.         LongWord Addr;
  1688.  
  1689.         DissectBitSymbol(BitSpec, &Addr, &Bit);
  1690.         OpCode = Code + 0x70;
  1691.         AdrMode = ModAbs8;
  1692.         AdrVals[0] = Addr & 0xff;
  1693.         AdrCnt = 2;
  1694.         goto common;
  1695.       }
  1696.       break;
  1697.     }
  1698.     case 2:
  1699.       switch (DecodeReg(&ArgStr[1], &Bit, 1 << eSymbolSize8Bit, &HSize, False))
  1700.       {
  1701.         case eIsReg:
  1702.           OpCode = Code + 0x60;
  1703.           OK = True;
  1704.           break;
  1705.         case eIsNoReg:
  1706.           OpCode = Code + 0x70;
  1707.           Bit = EvalBitPosition(&ArgStr[1], &OK);
  1708.           break;
  1709.         default: /* eRegAbort */
  1710.           return;
  1711.       }
  1712.       if (OK)
  1713.       {
  1714.         DecodeAdr(&ArgStr[2], MModReg | MModIReg | MModAbs8);
  1715.         if (AdrMode != ModNone)
  1716.           goto common;
  1717.         break;
  1718.       }
  1719.     common:
  1720.       if (OpSize > eSymbolSize8Bit) WrError(ErrNum_InvOpSize);
  1721.       else
  1722.       {
  1723.         switch (AdrMode)
  1724.         {
  1725.           case ModReg:
  1726.             CodeLen = 2;
  1727.             WAsmCode[0] = (OpCode << 8) + (Bit << 4) + AdrPart;
  1728.             break;
  1729.           case ModIReg:
  1730.             CodeLen = 4;
  1731.             WAsmCode[0] = 0x7d00 + (AdrPart << 4);
  1732.             WAsmCode[1] = (OpCode << 8) + (Bit << 4);
  1733.             if (Code == 3)
  1734.               WAsmCode[0] -= 0x100;
  1735.             break;
  1736.           case ModAbs8:
  1737.             CodeLen = 4;
  1738.             WAsmCode[0] = 0x7f00 + Lo(AdrVals[0]);
  1739.             WAsmCode[1] = (OpCode << 8) + (Bit << 4);
  1740.             if (Code == 3)
  1741.               WAsmCode[0] -= 0x100;
  1742.             break;
  1743.         }
  1744.       }
  1745.       break;
  1746.     default:
  1747.       (void)ChkArgCnt(1, 2);
  1748.   }
  1749. }
  1750.  
  1751. static void DecodeINC_DEC(Word Code)
  1752. {
  1753.   Boolean OK;
  1754.   int z;
  1755.   Byte HReg;
  1756.  
  1757.   if (ChkArgCnt(1, 2))
  1758.   {
  1759.     DecodeAdr(&ArgStr[ArgCnt], MModReg);
  1760.     if (AdrMode != ModNone)
  1761.     {
  1762.       if ((OpSize <= eSymbolSize8Bit) || ChkCPU32(ErrNum_AddrModeNotSupported))
  1763.       {
  1764.         HReg = AdrPart;
  1765.         if (ArgCnt == 1)
  1766.         {
  1767.           OK = True;
  1768.           z = 1;
  1769.         }
  1770.         else
  1771.         {
  1772.           DecodeAdr(&ArgStr[1], MModImm);
  1773.           OK = (AdrMode == ModImm);
  1774.           if (OK)
  1775.           {
  1776.             z = ImmVal();
  1777.             if (z < 1)
  1778.             {
  1779.               WrError(ErrNum_UnderRange);
  1780.               OK = False;
  1781.             }
  1782.             else if (((OpSize == eSymbolSize8Bit) && (z > 1)) || (z > 2))
  1783.             {
  1784.               WrError(ErrNum_OverRange);
  1785.               OK = False;
  1786.             }
  1787.           }
  1788.         }
  1789.         if (OK)
  1790.         {
  1791.           CodeLen = 2;
  1792.           z--;
  1793.           switch (OpSize)
  1794.           {
  1795.             case eSymbolSize8Bit:
  1796.               WAsmCode[0] = Code + 0x0a00 + HReg;
  1797.               break;
  1798.             case eSymbolSize16Bit:
  1799.               WAsmCode[0] = Code + 0x0b50 + HReg + (z << 7);
  1800.               break;
  1801.             case eSymbolSize32Bit:
  1802.               WAsmCode[0] = Code + 0x0b70 + HReg + (z << 7);
  1803.               break;
  1804.             default:
  1805.               break;
  1806.           }
  1807.         }
  1808.       }
  1809.     }
  1810.   }
  1811. }
  1812.  
  1813. static void DecodeShift(Word Code)
  1814. {
  1815.   if (ChkArgCnt(1, 1))
  1816.   {
  1817.     DecodeAdr(&ArgStr[1], MModReg);
  1818.     if (AdrMode != ModNone)
  1819.     {
  1820.       if ((OpSize <= eSymbolSize8Bit) || ChkCPU32(ErrNum_AddrModeNotSupported))
  1821.       {
  1822.         CodeLen = 2;
  1823.         switch (OpSize)
  1824.         {
  1825.           case eSymbolSize8Bit:
  1826.             WAsmCode[0] = Code + AdrPart;
  1827.             break;
  1828.           case eSymbolSize16Bit:
  1829.             WAsmCode[0] = Code + AdrPart + 0x10;
  1830.             break;
  1831.           case eSymbolSize32Bit:
  1832.             WAsmCode[0] = Code + AdrPart + 0x30;
  1833.             break;
  1834.           default:
  1835.             break;
  1836.         }
  1837.       }
  1838.     }
  1839.   }
  1840. }
  1841.  
  1842. static void DecodeNEG_NOT(Word Code)
  1843. {
  1844.   if (ChkArgCnt(1, 1))
  1845.   {
  1846.     DecodeAdr(&ArgStr[1], MModReg);
  1847.     if (AdrMode != ModNone)
  1848.     {
  1849.       if ((OpSize <= eSymbolSize8Bit) || ChkCPU32(ErrNum_AddrModeNotSupported))
  1850.       {
  1851.         CodeLen = 2;
  1852.         switch (OpSize)
  1853.         {
  1854.           case eSymbolSize8Bit:
  1855.             WAsmCode[0] = Code + 0x1700 + AdrPart;
  1856.             break;
  1857.           case eSymbolSize16Bit:
  1858.             WAsmCode[0] = Code + 0x1710 + AdrPart;
  1859.             break;
  1860.           case eSymbolSize32Bit:
  1861.             WAsmCode[0] = Code + 0x1730 + AdrPart;
  1862.             break;
  1863.           default:
  1864.             break;
  1865.         }
  1866.       }
  1867.     }
  1868.   }
  1869. }
  1870.  
  1871. static void DecodeEXTS_EXTU(Word IsEXTS)
  1872. {
  1873.   if (ChkArgCnt(1, 1)
  1874.    && ChkCPU32(ErrNum_InstructionNotSupported))
  1875.   {
  1876.     DecodeAdr(&ArgStr[1], MModReg);
  1877.     if (AdrMode != ModNone)
  1878.     {
  1879.       if ((OpSize != eSymbolSize16Bit) && (OpSize != 2)) WrError(ErrNum_InvOpSize);
  1880.       else
  1881.       {
  1882.         CodeLen = 2;
  1883.         switch (OpSize)
  1884.         {
  1885.           case eSymbolSize16Bit:
  1886.             WAsmCode[0] = IsEXTS ? 0x17d0 : 0x1750;
  1887.             break;
  1888.           case eSymbolSize32Bit:
  1889.             WAsmCode[0] = IsEXTS ? 0x17f0 : 0x1770;
  1890.             break;
  1891.           default:
  1892.             break;
  1893.         }
  1894.         WAsmCode[0] += AdrPart;
  1895.       }
  1896.     }
  1897.   }
  1898. }
  1899.  
  1900. static void DecodeDAA_DAS(Word Code)
  1901. {
  1902.   if (ChkArgCnt(1, 1))
  1903.   {
  1904.     DecodeAdr(&ArgStr[1], MModReg);
  1905.     if (AdrMode != ModNone)
  1906.     {
  1907.       if (OpSize != eSymbolSize8Bit) WrError(ErrNum_InvOpSize);
  1908.       else
  1909.       {
  1910.         CodeLen = 2;
  1911.         WAsmCode[0] = Code + AdrPart;
  1912.       }
  1913.     }
  1914.   }
  1915. }
  1916.  
  1917. static void DecodeCond(Word Code)
  1918. {
  1919.   if (!ChkArgCnt(1, 1));
  1920.   else if ((OpSize != eSymbolSizeUnknown) && (OpSize != eSymbolSizeFloat32Bit) && (OpSize != eSymbolSize32Bit)) WrError(ErrNum_InvOpSize);
  1921.   else
  1922.   {
  1923.     Boolean OK;
  1924.     tSymbolFlags Flags;
  1925.     LongInt AdrLong = EvalStrIntExpressionWithFlags(&ArgStr[1], Int24, &OK, &Flags) - (EProgCounter() + 2);
  1926.  
  1927.     if (OK)
  1928.     {
  1929.       if (OpSize == eSymbolSizeUnknown)
  1930.       {
  1931.         if ((AdrLong >= -128) && (AdrLong <= 127))
  1932.           OpSize = eSymbolSizeFloat32Bit;
  1933.         else
  1934.         {
  1935.           OpSize = eSymbolSize32Bit;
  1936.           AdrLong -= 2;
  1937.         }
  1938.       }
  1939.       else if (OpSize == eSymbolSize32Bit)
  1940.         AdrLong -= 2;
  1941.       if (OpSize == eSymbolSize32Bit)
  1942.       {
  1943.         if (!mSymbolQuestionable(Flags) && ((AdrLong < -32768) || (AdrLong > 32767))) WrError(ErrNum_JmpDistTooBig);
  1944.         else if (ChkCPU32(ErrNum_AddrModeNotSupported))
  1945.         {
  1946.           CodeLen = 4;
  1947.           WAsmCode[0] = 0x5800 + (Code << 4);
  1948.           WAsmCode[1] = AdrLong & 0xffff;
  1949.         }
  1950.       }
  1951.       else
  1952.       {
  1953.         if (!mSymbolQuestionable(Flags) && ((AdrLong < -128) || (AdrLong > 127))) WrError(ErrNum_JmpDistTooBig);
  1954.         else
  1955.         {
  1956.           CodeLen = 2;
  1957.           WAsmCode[0] = 0x4000 + (Code << 8) + (AdrLong & 0xff);
  1958.         }
  1959.       }
  1960.     }
  1961.   }
  1962. }
  1963.  
  1964. static void DecodeJMP_JSR(Word Code)
  1965. {
  1966.   if (ChkArgCnt(1, 1))
  1967.   {
  1968.     DecodeAdr(&ArgStr[1], MModIReg | ((CPU16) ? MModAbs16 : MModAbs24) | MModIIAbs);
  1969.     switch (AdrMode)
  1970.     {
  1971.       case ModIReg:
  1972.         CodeLen = 2;
  1973.         WAsmCode[0] = 0x5900 + Code + (AdrPart << 4);
  1974.         break;
  1975.       case ModAbs16:
  1976.         CodeLen = 4;
  1977.         WAsmCode[0] = 0x5a00 + Code;
  1978.         WAsmCode[1] = AdrVals[0];
  1979.         break;
  1980.       case ModAbs24:
  1981.         CodeLen = 4;
  1982.         WAsmCode[0] = 0x5a00 + Code + Lo(AdrVals[0]);
  1983.         WAsmCode[1] = AdrVals[1];
  1984.         break;
  1985.       case ModIIAbs:
  1986.         CodeLen = 2;
  1987.         WAsmCode[0] = 0x5b00 + Code + Lo(AdrVals[0]);
  1988.         break;
  1989.     }
  1990.   }
  1991. }
  1992.  
  1993. static void DecodeBSR(Word Code)
  1994. {
  1995.   UNUSED(Code);
  1996.  
  1997.   if (!ChkArgCnt(1, 1));
  1998.   else if ((OpSize != eSymbolSizeUnknown) && (OpSize != eSymbolSizeFloat32Bit) && (OpSize != eSymbolSize32Bit)) WrError(ErrNum_InvOpSize);
  1999.   else
  2000.   {
  2001.     Boolean OK;
  2002.     tSymbolFlags Flags;
  2003.     LongInt AdrLong = EvalStrIntExpressionWithFlags(&ArgStr[1], Int24, &OK, &Flags) - (EProgCounter() + 2);
  2004.  
  2005.     if (OK)
  2006.     {
  2007.       if (OpSize == eSymbolSizeUnknown)
  2008.       {
  2009.         if ((AdrLong >= -128) && (AdrLong <= 127))
  2010.           OpSize = eSymbolSizeFloat32Bit;
  2011.         else
  2012.         {
  2013.           OpSize = eSymbolSize32Bit;
  2014.           AdrLong -= 2;
  2015.         }
  2016.       }
  2017.       else
  2018.       {
  2019.         if (OpSize == eSymbolSize32Bit)
  2020.           AdrLong -= 2;
  2021.       }
  2022.       if (OpSize == eSymbolSize32Bit)
  2023.       {
  2024.         if (!mSymbolQuestionable(Flags) && ((AdrLong < -32768) || (AdrLong > 32767))) WrError(ErrNum_JmpDistTooBig);
  2025.         else if (ChkCPU32(ErrNum_AddrModeNotSupported))
  2026.         {
  2027.           CodeLen = 4;
  2028.           WAsmCode[0] = 0x5c00;
  2029.           WAsmCode[1] = AdrLong & 0xffff;
  2030.         }
  2031.       }
  2032.       else
  2033.       {
  2034.         if ((AdrLong < -128) || (AdrLong > 127)) WrError(ErrNum_JmpDistTooBig);
  2035.         else
  2036.         {
  2037.           CodeLen = 2;
  2038.           WAsmCode[0] = 0x5500 + (AdrLong & 0xff);
  2039.         }
  2040.       }
  2041.     }
  2042.   }
  2043. }
  2044.  
  2045. static void DecodeTRAPA(Word Code)
  2046. {
  2047.   UNUSED(Code);
  2048.  
  2049.   if (ChkArgCnt(1, 1)
  2050.    && ChkMinCPU(CPU6413309))
  2051.   {
  2052.     Boolean OK;
  2053.  
  2054.     WAsmCode[0] = EvalStrIntExpressionOffs(&ArgStr[1], !!(*ArgStr[1].str.p_str == '#'), UInt2, &OK) << 4;
  2055.     if (OK)
  2056.     {
  2057.       WAsmCode[0] += 0x5700;
  2058.       CodeLen = 2;
  2059.     }
  2060.   }
  2061. }
  2062.  
  2063. /*!------------------------------------------------------------------------
  2064.  * \fn     DecodeBIT(Word Code)
  2065.  * \brief  handle BIT instruction
  2066.  * ------------------------------------------------------------------------ */
  2067.  
  2068. static void DecodeBIT(Word Code)
  2069. {
  2070.   UNUSED(Code);
  2071.  
  2072.   /* if in structure definition, add special element to structure */
  2073.  
  2074.   if ((OpSize != eSymbolSize8Bit) && (OpSize != eSymbolSizeUnknown))
  2075.   {
  2076.     WrError(ErrNum_InvOpSize);
  2077.     return;
  2078.   }
  2079.   if (ActPC == StructSeg)
  2080.   {
  2081.     Boolean OK;
  2082.     Byte BitPos;
  2083.     PStructElem pElement;
  2084.  
  2085.     if (!ChkArgCnt(2, 2))
  2086.       return;
  2087.     BitPos = EvalBitPosition(&ArgStr[1], &OK);
  2088.     if (!OK)
  2089.       return;
  2090.     pElement = CreateStructElem(&LabPart);
  2091.     if (!pElement)
  2092.       return;
  2093.     pElement->pRefElemName = as_strdup(ArgStr[2].str.p_str);
  2094.     pElement->OpSize = eSymbolSize8Bit;
  2095.     pElement->BitPos = BitPos;
  2096.     pElement->ExpandFnc = ExpandBit_H8_3;
  2097.     AddStructElem(pInnermostNamedStruct->StructRec, pElement);
  2098.   }
  2099.   else
  2100.   {
  2101.     LongWord BitSpec;
  2102.  
  2103.     if (DecodeBitArg(&BitSpec, 1, ArgCnt))
  2104.     {
  2105.       *ListLine = '=';
  2106.       DissectBit_H8_3(ListLine + 1, STRINGSIZE - 3, BitSpec);
  2107.       PushLocHandle(-1);
  2108.       EnterIntSymbol(&LabPart, BitSpec, SegBData, False);
  2109.       PopLocHandle();
  2110.       /* TODO: MakeUseList? */
  2111.     }
  2112.   }
  2113. }
  2114.  
  2115. /*-------------------------------------------------------------------------*/
  2116. /* dynamische Belegung/Freigabe Codetabellen */
  2117.  
  2118. static void AddFixed(const char *NName, Word NCode)
  2119. {
  2120.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  2121. }
  2122.  
  2123. static void AddCond(const char *NName, Byte NCode)
  2124. {
  2125.   AddInstTable(InstTable, NName, NCode, DecodeCond);
  2126. }
  2127.  
  2128. static void AddShift(const char *NName, Word NCode)
  2129. {
  2130.   AddInstTable(InstTable, NName, NCode, DecodeShift);
  2131. }
  2132.  
  2133. static void AddLogic(const char *NName, const char *NNameBit, Word NCode)
  2134. {
  2135.   AddInstTable(InstTable, NName, NCode, DecodeLogic);
  2136.   AddInstTable(InstTable, NNameBit, NCode, DecodeLogicBit);
  2137. }
  2138.  
  2139. static void AddMul(const char *NName, Word NCode)
  2140. {
  2141.   AddInstTable(InstTable, NName, NCode, DecodeMul);
  2142. }
  2143.  
  2144. static void AddBit1(const char *NName, Word NCode)
  2145. {
  2146.   AddInstTable(InstTable, NName, NCode, DecodeBit1);
  2147. }
  2148.  
  2149. static void AddBit2(const char *NName, Word NCode)
  2150. {
  2151.   AddInstTable(InstTable, NName, NCode, DecodeBit2);
  2152. }
  2153.  
  2154. static void InitFields(void)
  2155. {
  2156.   InstTable = CreateInstTable(203);
  2157.  
  2158.   add_null_pseudo(InstTable);
  2159.  
  2160.   AddInstTable(InstTable, "EEPMOV", 0, DecodeEEPMOV);
  2161.   AddInstTable(InstTable, "MOV", 0, DecodeMOV);
  2162.   AddInstTable(InstTable, "MOVTPE", 0x80, DecodeMOVTPE_MOVFPE);
  2163.   AddInstTable(InstTable, "MOVFPE", 0x00, DecodeMOVTPE_MOVFPE);
  2164.   AddInstTable(InstTable, "PUSH", 0x6df0, DecodePUSH_POP);
  2165.   AddInstTable(InstTable, "POP", 0x6d70, DecodePUSH_POP);
  2166.   AddInstTable(InstTable, "LDC", 0x00, DecodeLDC_STC);
  2167.   AddInstTable(InstTable, "STC", 0x80, DecodeLDC_STC);
  2168.   AddInstTable(InstTable, "ADD", 0, DecodeADD_SUB);
  2169.   AddInstTable(InstTable, "SUB", 1, DecodeADD_SUB);
  2170.   AddInstTable(InstTable, "CMP", 0, DecodeCMP);
  2171.   AddInstTable(InstTable, "ADDX", 0, DecodeADDX_SUBX);
  2172.   AddInstTable(InstTable, "SUBX", 1, DecodeADDX_SUBX);
  2173.   AddInstTable(InstTable, "ADDS", 0x0000, DecodeADDS_SUBS);
  2174.   AddInstTable(InstTable, "SUBS", 0x1000, DecodeADDS_SUBS);
  2175.   AddInstTable(InstTable, "INC", 0x0000, DecodeINC_DEC);
  2176.   AddInstTable(InstTable, "DEC", 0x1000, DecodeINC_DEC);
  2177.   AddInstTable(InstTable, "NEG", 0x80, DecodeNEG_NOT);
  2178.   AddInstTable(InstTable, "NOT", 0x00, DecodeNEG_NOT);
  2179.   AddInstTable(InstTable, "EXTS", 1, DecodeEXTS_EXTU);
  2180.   AddInstTable(InstTable, "EXTU", 0, DecodeEXTS_EXTU);
  2181.   AddInstTable(InstTable, "DAA", 0x0f00, DecodeDAA_DAS);
  2182.   AddInstTable(InstTable, "DAS", 0x1f00, DecodeDAA_DAS);
  2183.   AddInstTable(InstTable, "JMP", 0x0000, DecodeJMP_JSR);
  2184.   AddInstTable(InstTable, "JSR", 0x0400, DecodeJMP_JSR);
  2185.   AddInstTable(InstTable, "BSR", 0, DecodeBSR);
  2186.   AddInstTable(InstTable, "TRAPA", 0, DecodeTRAPA);
  2187.  
  2188.   AddFixed("NOP", 0x0000); AddFixed("RTE"  , 0x5670);
  2189.   AddFixed("RTS", 0x5470); AddFixed("SLEEP", 0x0180);
  2190.  
  2191.   AddCond("BRA", 0x0); AddCond("BT" , 0x0);
  2192.   AddCond("BRN", 0x1); AddCond("BF" , 0x1);
  2193.   AddCond("BHI", 0x2); AddCond("BLS", 0x3);
  2194.   AddCond("BCC", 0x4); AddCond("BHS", 0x4);
  2195.   AddCond("BCS", 0x5); AddCond("BLO", 0x5);
  2196.   AddCond("BNE", 0x6); AddCond("BEQ", 0x7);
  2197.   AddCond("BVC", 0x8); AddCond("BVS", 0x9);
  2198.   AddCond("BPL", 0xa); AddCond("BMI", 0xb);
  2199.   AddCond("BGE", 0xc); AddCond("BLT", 0xd);
  2200.   AddCond("BGT", 0xe); AddCond("BLE", 0xf);
  2201.  
  2202.   AddShift("ROTL" , 0x1280); AddShift("ROTR" , 0x1380);
  2203.   AddShift("ROTXL", 0x1200); AddShift("ROTXR", 0x1300);
  2204.   AddShift("SHAL" , 0x1080); AddShift("SHAR" , 0x1180);
  2205.   AddShift("SHLL" , 0x1000); AddShift("SHLR" , 0x1100);
  2206.  
  2207.   AddLogic("OR", "ORC", 0);
  2208.   AddLogic("XOR", "XORC", 1);
  2209.   AddLogic("AND", "ANDC", 2);
  2210.  
  2211.   AddMul("DIVXS", 3);
  2212.   AddMul("DIVXU", 1);
  2213.   AddMul("MULXS", 2);
  2214.   AddMul("MULXU", 0);
  2215.  
  2216.   AddBit1("BAND", 0x16); AddBit1("BIAND", 0x96);
  2217.   AddBit1("BOR" , 0x14); AddBit1("BIOR" , 0x94);
  2218.   AddBit1("BXOR", 0x15); AddBit1("BIXOR", 0x95);
  2219.   AddBit1("BLD" , 0x17); AddBit1("BILD" , 0x97);
  2220.   AddBit1("BST" , 0x07); AddBit1("BIST" , 0x87);
  2221.  
  2222.   AddBit2("BCLR", 2);
  2223.   AddBit2("BNOT", 1);
  2224.   AddBit2("BSET", 0);
  2225.   AddBit2("BTST", 3);
  2226.  
  2227.   AddInstTable(InstTable, "REG", 0, CodeREG);
  2228.   AddInstTable(InstTable, "BIT", 0, DecodeBIT);
  2229.   AddMoto16Pseudo(InstTable, e_moto_pseudo_flags_be);
  2230. }
  2231.  
  2232. static void DeinitFields(void)
  2233. {
  2234.   DestroyInstTable(InstTable);
  2235. }
  2236.  
  2237. /*-------------------------------------------------------------------------*/
  2238.  
  2239. /*!------------------------------------------------------------------------
  2240.  * \fn     InternSymbol_H8_3(char *pArg, TempResult *pResult)
  2241.  * \brief  handle built-in symbols on H8/300
  2242.  * \param  pArg source argument
  2243.  * \param  pResult result buffer
  2244.  * ------------------------------------------------------------------------ */
  2245.  
  2246. static void InternSymbol_H8_3(char *pArg, TempResult *pResult)
  2247. {
  2248.   Byte Result;
  2249.   tSymbolSize Size;
  2250.  
  2251.   if (DecodeRegCore(pArg, &Result, &Size))
  2252.   {
  2253.     pResult->Typ = TempReg;
  2254.     pResult->DataSize = Size;
  2255.     pResult->Contents.RegDescr.Reg = Result;
  2256.     pResult->Contents.RegDescr.Dissect = DissectReg_H8_3;
  2257.     pResult->Contents.RegDescr.compare = NULL;
  2258.   }
  2259. }
  2260.  
  2261. static Boolean DecodeAttrPart_H8_3(void)
  2262. {
  2263.   if (*AttrPart.str.p_str)
  2264.   {
  2265.     if (strlen(AttrPart.str.p_str) != 1)
  2266.     {
  2267.       WrStrErrorPos(ErrNum_TooLongAttr, &AttrPart);
  2268.       return False;
  2269.     }
  2270.     if (!DecodeMoto16AttrSize(*AttrPart.str.p_str, &AttrPartOpSize[0], False))
  2271.       return False;
  2272.   }
  2273.   return True;
  2274. }
  2275.  
  2276. static void MakeCode_H8_3(void)
  2277. {
  2278.   OpSize = eSymbolSizeUnknown;
  2279.   if (AttrPartOpSize[0] != eSymbolSizeUnknown)
  2280.     SetOpSize(AttrPartOpSize[0]);
  2281.  
  2282.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  2283.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  2284. }
  2285.  
  2286. static Boolean IsDef_H8_3(void)
  2287. {
  2288.   return Memo("REG")
  2289.       || Memo("BIT");
  2290. }
  2291.  
  2292. static void SwitchTo_H8_3(void)
  2293. {
  2294.   TurnWords = True;
  2295.   SetIntConstMode(eIntConstModeMoto);
  2296.  
  2297.   PCSymbol = "*";
  2298.   HeaderID = 0x68;
  2299.   NOPCode = 0x0000;
  2300.   DivideChars = ",";
  2301.   HasAttrs = True;
  2302.   AttrChars = ".";
  2303.  
  2304.   ValidSegs = 1 << SegCode;
  2305.   Grans[SegCode] = 1;
  2306.   ListGrans[SegCode] = 2;
  2307.   SegInits[SegCode] = 0;
  2308.   SegLimits[SegCode] = (MomCPU <= CPUH8_300) ? 0xffff : 0xffffffl;
  2309.  
  2310.   DecodeAttrPart = DecodeAttrPart_H8_3;
  2311.   MakeCode = MakeCode_H8_3;
  2312.   IsDef = IsDef_H8_3;
  2313.   InternSymbol = InternSymbol_H8_3;
  2314.   DissectReg = DissectReg_H8_3;
  2315.   DissectBit = DissectBit_H8_3;
  2316.   QualifyQuote = QualifyQuote_SingleQuoteConstant;
  2317.   IntConstModeIBMNoTerm = True;
  2318.   SwitchFrom = DeinitFields;
  2319.   InitFields();
  2320.   onoff_maxmode_add();
  2321.   AddMoto16PseudoONOFF(False);
  2322.  
  2323.   CPU16 = (MomCPU <= CPUH8_300);
  2324. }
  2325.  
  2326. void codeh8_3_init(void)
  2327. {
  2328.   CPUH8_300L = AddCPU("H8/300L"   , SwitchTo_H8_3);
  2329.   CPU6413308 = AddCPU("HD6413308" , SwitchTo_H8_3);
  2330.   CPUH8_300  = AddCPU("H8/300"    , SwitchTo_H8_3);
  2331.   CPU6413309 = AddCPU("HD6413309" , SwitchTo_H8_3);
  2332.   CPUH8_300H = AddCPU("H8/300H"   , SwitchTo_H8_3);
  2333. }
  2334.