Subversion Repositories pentevo

Rev

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

  1. /* code51.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator fuer MCS-51/252 Prozessoren                                 */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <ctype.h>
  14.  
  15. #include "bpemu.h"
  16. #include "strutil.h"
  17. #include "chunks.h"
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmallg.h"
  22. #include "onoff_common.h"
  23. #include "asmrelocs.h"
  24. #include "asmlist.h"
  25. #include "codepseudo.h"
  26. #include "intpseudo.h"
  27. #include "asmitree.h"
  28. #include "codevars.h"
  29. #include "fileformat.h"
  30. #include "errmsg.h"
  31. #include "intformat.h"
  32.  
  33. #include "code51.h"
  34.  
  35. /*-------------------------------------------------------------------------*/
  36. /* Daten */
  37.  
  38. typedef struct
  39. {
  40.   CPUVar MinCPU;
  41.   Word Code;
  42. } FixedOrder;
  43.  
  44. enum
  45. {
  46.   ModNone = -1,
  47.   ModReg = 1,
  48.   ModIReg8 = 2,
  49.   ModIReg = 3,
  50.   ModInd = 5,
  51.   ModImm = 7,
  52.   ModImmEx = 8,
  53.   ModDir8 = 9,
  54.   ModDir16 = 10,
  55.   ModAcc = 11,
  56.   ModBit51 = 12,
  57.   ModBit251 = 13
  58. };
  59.  
  60. #define MModReg (1 << ModReg)
  61. #define MModIReg8 (1 << ModIReg8)
  62. #define MModIReg (1 << ModIReg)
  63. #define MModInd (1 << ModInd)
  64. #define MModImm (1 << ModImm)
  65. #define MModImmEx (1 << ModImmEx)
  66. #define MModDir8 (1 << ModDir8)
  67. #define MModDir16 (1 << ModDir16)
  68. #define MModAcc (1 << ModAcc)
  69. #define MModBit51 (1 << ModBit51)
  70. #define MModBit251 (1 << ModBit251)
  71.  
  72. #define MMod51 (MModReg | MModIReg8 | MModImm | MModAcc | MModDir8)
  73. #define MMod251 (MModIReg | MModInd | MModImmEx | MModDir16)
  74.  
  75. #define AccReg 11
  76. #define DPXValue 14
  77. #define SPXValue 15
  78.  
  79. static FixedOrder *FixedOrders;
  80. static FixedOrder *AccOrders;
  81. static FixedOrder *CondOrders;
  82. static FixedOrder *BCondOrders;
  83.  
  84. static Byte AdrVals[5];
  85. static Byte AdrPart, AdrSize;
  86. static ShortInt AdrMode, OpSize;
  87. static tSymbolFlags adr_flags;
  88. static Boolean MinOneIs0;
  89.  
  90. static Boolean SrcMode;
  91.  
  92. static CPUVar CPU87C750, CPU8051, CPU8052, CPU80C320,
  93.        CPU80501, CPU80502, CPU80504, CPU80515, CPU80517,
  94.        CPU80C390,
  95.        CPU80251, CPU80251T;
  96.  
  97. static PRelocEntry AdrRelocInfo, BackupAdrRelocInfo;
  98. static LongWord AdrOffset, AdrRelocType,
  99.                 BackupAdrOffset, BackupAdrRelocType;
  100.  
  101. /*-------------------------------------------------------------------------*/
  102. /* Adressparser */
  103.  
  104. static void SetOpSize(ShortInt NewSize)
  105. {
  106.   if (OpSize == -1)
  107.     OpSize = NewSize;
  108.   else if (OpSize != NewSize)
  109.   {
  110.     WrError(ErrNum_ConfOpSizes);
  111.     AdrMode = ModNone;
  112.     AdrCnt = 0;
  113.   }
  114. }
  115.  
  116. /*!------------------------------------------------------------------------
  117.  * \fn     DecodeRegCore(const char *pAsc, tRegInt *pValue, tSymbolSize *pSize)
  118.  * \brief  check whether argument describes a CPU register
  119.  * \param  pAsc argument
  120.  * \param  pValue resulting register # if yes
  121.  * \param  pSize resulting register size if yes
  122.  * \return true if yes
  123.  * ------------------------------------------------------------------------ */
  124.  
  125. static Boolean DecodeRegCore(const char *pAsc, tRegInt *pValue, tSymbolSize *pSize)
  126. {
  127.   static Byte Masks[3] = { 0, 1, 3 };
  128.  
  129.   const char *Start;
  130.   int alen = strlen(pAsc);
  131.   Boolean IO;
  132.  
  133.   if (!as_strcasecmp(pAsc, "DPX"))
  134.   {
  135.     *pValue = DPXValue;
  136.     *pSize = eSymbolSize32Bit;
  137.     return True;
  138.   }
  139.  
  140.   if (!as_strcasecmp(pAsc, "SPX"))
  141.   {
  142.     *pValue = SPXValue;
  143.     *pSize = eSymbolSize32Bit;
  144.     return True;
  145.   }
  146.  
  147.   if ((alen >= 2) && (as_toupper(*pAsc) == 'R'))
  148.   {
  149.     Start = pAsc + 1;
  150.     *pSize = eSymbolSize8Bit;
  151.   }
  152.   else if ((MomCPU >= CPU80251) && (alen >= 3) && (as_toupper(*pAsc) == 'W') && (as_toupper(pAsc[1]) == 'R'))
  153.   {
  154.     Start = pAsc + 2;
  155.     *pSize = eSymbolSize16Bit;
  156.   }
  157.   else if ((MomCPU >= CPU80251) && (alen >= 3) && (as_toupper(*pAsc) == 'D') && (as_toupper(pAsc[1]) == 'R'))
  158.   {
  159.     Start = pAsc + 2;
  160.     *pSize = eSymbolSize32Bit;
  161.   }
  162.   else
  163.     return False;
  164.  
  165.   *pValue = ConstLongInt(Start, &IO, 10);
  166.   if (!IO) return False;
  167.   else if (*pValue & Masks[*pSize]) return False;
  168.   else
  169.   {
  170.     *pValue >>= *pSize;
  171.     switch (*pSize)
  172.     {
  173.       case eSymbolSize8Bit:
  174.         return ((*pValue < 8) || ((MomCPU >= CPU80251) && (*pValue < 16)));
  175.       case eSymbolSize16Bit:
  176.         return (*pValue < 16);
  177.       case eSymbolSize32Bit:
  178.         return ((*pValue < 8) || (*pValue == DPXValue) || (*pValue == SPXValue));
  179.       default:
  180.         return False;
  181.     }
  182.   }
  183. }
  184.  
  185. /*!------------------------------------------------------------------------
  186.  * \fn     DissectReg_51(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  187.  * \brief  dissect register symbols - 80(2)51 variant
  188.  * \param  pDest destination buffer
  189.  * \param  DestSize destination buffer size
  190.  * \param  Value numeric register value
  191.  * \param  InpSize register size
  192.  * ------------------------------------------------------------------------ */
  193.  
  194. static void DissectReg_51(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  195. {
  196.   switch (InpSize)
  197.   {
  198.     case eSymbolSize8Bit:
  199.       as_snprintf(pDest, DestSize, "R%u", (unsigned)Value);
  200.       break;
  201.     case eSymbolSize16Bit:
  202.       as_snprintf(pDest, DestSize, "WR%u", (unsigned)Value << 1);
  203.       break;
  204.     case eSymbolSize32Bit:
  205.       if (SPXValue == Value)
  206.         strmaxcpy(pDest, "SPX", DestSize);
  207.       else if (DPXValue == Value)
  208.         strmaxcpy(pDest, "DPX", DestSize);
  209.       else
  210.         as_snprintf(pDest, DestSize, "DR%u", (unsigned)Value << 2);
  211.       break;
  212.     default:
  213.       as_snprintf(pDest, DestSize, "%d-%u", (int)InpSize, (unsigned)Value);
  214.   }
  215. }
  216.  
  217. /*!------------------------------------------------------------------------
  218.  * \fn     DecodeReg(const tStrComp *pArg, Byte *pValue, tSymbolSize *pSize, Boolean MustBeReg)
  219.  * \brief  check whether argument is a CPU register or user-defined register alias
  220.  * \param  pArg argument
  221.  * \param  pValue resulting register # if yes
  222.  * \param  pSize resulting register size if yes
  223.  * \param  MustBeReg operand must be a register
  224.  * \return reg eval result
  225.  * ------------------------------------------------------------------------ */
  226.  
  227. static tRegEvalResult DecodeReg(const tStrComp *pArg, Byte *pValue, tSymbolSize *pSize, Boolean MustBeReg)
  228. {
  229.   tRegDescr RegDescr;
  230.   tEvalResult EvalResult;
  231.   tRegEvalResult RegEvalResult;
  232.  
  233.   if (DecodeRegCore(pArg->str.p_str, &RegDescr.Reg, pSize))
  234.   {
  235.     *pValue = RegDescr.Reg;
  236.     return eIsReg;
  237.   }
  238.  
  239.   RegEvalResult = EvalStrRegExpressionAsOperand(pArg, &RegDescr, &EvalResult, eSymbolSizeUnknown, MustBeReg);
  240.   *pValue = RegDescr.Reg;
  241.   *pSize = EvalResult.DataSize;
  242.   return RegEvalResult;
  243. }
  244.  
  245. static void SaveAdrRelocs(LongWord Type, LongWord Offset)
  246. {
  247.   AdrOffset = Offset;
  248.   AdrRelocType = Type;
  249.   AdrRelocInfo = LastRelocs;
  250.   LastRelocs = NULL;
  251. }
  252.  
  253. static void SaveBackupAdrRelocs(void)
  254. {
  255.   BackupAdrOffset = AdrOffset;
  256.   BackupAdrRelocType = AdrRelocType;
  257.   BackupAdrRelocInfo = AdrRelocInfo;
  258.   AdrRelocInfo = NULL;
  259. }
  260.  
  261. static void TransferAdrRelocs(LongWord Offset)
  262. {
  263.   TransferRelocs2(AdrRelocInfo, ProgCounter() + AdrOffset + Offset, AdrRelocType);
  264.   AdrRelocInfo = NULL;
  265. }
  266.  
  267. static void TransferBackupAdrRelocs(LargeWord Offset)
  268. {
  269.   TransferRelocs2(BackupAdrRelocInfo, ProgCounter() + BackupAdrOffset + Offset, BackupAdrRelocType);
  270.   AdrRelocInfo = NULL;
  271. }
  272.  
  273. static void DecodeAdr(tStrComp *pArg, Word Mask)
  274. {
  275.   Boolean OK, FirstFlag;
  276.   tEvalResult EvalResult;
  277.   tSymbolSize HSize;
  278.   Word H16;
  279.   LongWord H32;
  280.   tStrComp SegComp, AddrComp, *pAddrComp;
  281.   int SegType;
  282.   char Save = '\0', *pSegSepPos;
  283.   Word ExtMask;
  284.  
  285.   AdrMode = ModNone; AdrCnt = 0; adr_flags = eSymbolFlag_None;
  286.  
  287.   ExtMask = MMod251 & Mask;
  288.   if (MomCPU < CPU80251) Mask &= MMod51;
  289.  
  290.   if (!*pArg->str.p_str)
  291.      return;
  292.  
  293.   if (!as_strcasecmp(pArg->str.p_str, "A"))
  294.   {
  295.     if (!(Mask & MModAcc))
  296.     {
  297.       AdrMode = ModReg;
  298.       AdrPart = AccReg;
  299.     }
  300.     else
  301.       AdrMode = ModAcc;
  302.     SetOpSize(0);
  303.     goto chk;
  304.   }
  305.  
  306.   if (*pArg->str.p_str == '#')
  307.   {
  308.     tStrComp Comp;
  309.  
  310.     StrCompRefRight(&Comp, pArg, 1);
  311.     if ((OpSize == -1) && (MinOneIs0)) OpSize = 0;
  312.     switch (OpSize)
  313.     {
  314.       case -1:
  315.         WrError(ErrNum_UndefOpSizes);
  316.         break;
  317.       case 0:
  318.         AdrVals[0] = EvalStrIntExpressionWithFlags(&Comp, Int8, &OK, &adr_flags);
  319.         if (OK)
  320.         {
  321.           AdrMode = ModImm;
  322.           AdrCnt = 1;
  323.           SaveAdrRelocs(RelocTypeB8, 0);
  324.         }
  325.         break;
  326.       case 1:
  327.         H16 = EvalStrIntExpressionWithFlags(&Comp, Int16, &OK, &adr_flags);
  328.         if (OK)
  329.         {
  330.           AdrVals[0] = Hi(H16);
  331.           AdrVals[1] = Lo(H16);
  332.           AdrMode = ModImm;
  333.           AdrCnt = 2;
  334.           SaveAdrRelocs(RelocTypeB16, 0);
  335.         }
  336.         break;
  337.       case 2:
  338.         H32 = EvalStrIntExpressionWithResult(&Comp, Int32, &EvalResult);
  339.         if (mFirstPassUnknown(EvalResult.Flags))
  340.           H32 &= 0xffff;
  341.         if (EvalResult.OK)
  342.         {
  343.           adr_flags = EvalResult.Flags;
  344.           AdrVals[1] = H32 & 0xff;
  345.           AdrVals[0] = (H32 >> 8) & 0xff;
  346.           H32 >>= 16;
  347.           if (H32 == 0)
  348.             AdrMode = ModImm;
  349.           else if ((H32 == 1) || (H32 == 0xffff))
  350.             AdrMode = ModImmEx;
  351.           else
  352.             WrError(ErrNum_UndefOpSizes);
  353.           if (AdrMode != ModNone)
  354.             AdrCnt = 2;
  355.           SaveAdrRelocs(RelocTypeB16, 0);
  356.         }
  357.         break;
  358.       case 3:
  359.         H32 = EvalStrIntExpressionWithFlags(&Comp, Int24, &OK, &adr_flags);
  360.         if (OK)
  361.         {
  362.           AdrVals[0] = (H32 >> 16) & 0xff;
  363.           AdrVals[1] = (H32 >> 8) & 0xff;
  364.           AdrVals[2] = H32 & 0xff;
  365.           AdrCnt = 3;
  366.           AdrMode = ModImm;
  367.           SaveAdrRelocs(RelocTypeB24, 0);
  368.         }
  369.         break;
  370.     }
  371.     goto chk;
  372.   }
  373.  
  374.   switch (DecodeReg(pArg, &AdrPart, &HSize, False))
  375.   {
  376.     case eIsReg:
  377.       if ((MomCPU >= CPU80251) && ((Mask & MModReg) == 0))
  378.         AdrMode = ((HSize == 0) && (AdrPart == AccReg)) ? ModAcc : ModReg;
  379.       else
  380.         AdrMode = ModReg;
  381.       SetOpSize(HSize);
  382.       goto chk;
  383.     case eIsNoReg:
  384.       break;
  385.     case eRegAbort:
  386.       return;
  387.   }
  388.  
  389.   if (*pArg->str.p_str == '@')
  390.   {
  391.     tStrComp IndirComp;
  392.     char *PPos, *MPos;
  393.  
  394.     StrCompRefRight(&IndirComp, pArg, 1);
  395.     PPos = strchr(IndirComp.str.p_str, '+');
  396.     MPos = strchr(IndirComp.str.p_str, '-');
  397.     if ((MPos) && ((MPos < PPos) || (!PPos)))
  398.       PPos = MPos;
  399.     if (PPos)
  400.     {
  401.       Save = *PPos;
  402.       *PPos = '\0';
  403.       IndirComp.Pos.Len = PPos - IndirComp.str.p_str;
  404.     }
  405.     switch (DecodeReg(&IndirComp, &AdrPart, &HSize, False))
  406.     {
  407.       case eIsReg:
  408.       {
  409.         if (!PPos)
  410.         {
  411.           H32 = 0;
  412.           OK = True;
  413.         }
  414.         else
  415.         {
  416.           tStrComp DispComp;
  417.  
  418.           *PPos = Save;
  419.           StrCompRefRight(&DispComp, &IndirComp, PPos - IndirComp.str.p_str + !!(Save == '+'));
  420.           H32 = EvalStrIntExpression(&DispComp, SInt16, &OK);
  421.         }
  422.         if (OK)
  423.           switch (HSize)
  424.           {
  425.             case eSymbolSize8Bit:
  426.               if ((AdrPart>1) || (H32 != 0)) WrError(ErrNum_InvAddrMode);
  427.               else
  428.                 AdrMode = ModIReg8;
  429.               break;
  430.             case eSymbolSize16Bit:
  431.               if (H32 == 0)
  432.               {
  433.                 AdrMode = ModIReg;
  434.                 AdrSize = 0;
  435.               }
  436.               else
  437.               {
  438.                 AdrMode = ModInd;
  439.                 AdrSize = 0;
  440.                 AdrVals[1] = H32 & 0xff;
  441.                 AdrVals[0] = (H32 >> 8) & 0xff;
  442.                 AdrCnt = 2;
  443.               }
  444.               break;
  445.             case eSymbolSize32Bit:
  446.               if (H32 == 0)
  447.               {
  448.                 AdrMode = ModIReg;
  449.                 AdrSize = 2;
  450.               }
  451.               else
  452.               {
  453.                 AdrMode = ModInd;
  454.                 AdrSize = 2;
  455.                 AdrVals[1] = H32 & 0xff;
  456.                 AdrVals[0] = (H32 >> 8) & 0xff;
  457.                 AdrCnt = 2;
  458.               }
  459.               break;
  460.             default:
  461.               break;
  462.           }
  463.         break;
  464.       }
  465.       case eIsNoReg:
  466.         WrStrErrorPos(ErrNum_InvReg, &IndirComp);
  467.         break;
  468.       case eRegAbort:
  469.         /* will go to function end anyway after restoring separator */
  470.         break;
  471.     }
  472.     if (PPos)
  473.       *PPos = Save;
  474.     goto chk;
  475.   }
  476.  
  477.   FirstFlag = False;
  478.   SegType = -1;
  479.   pSegSepPos = QuotPos(pArg->str.p_str, ':');
  480.   if (pSegSepPos)
  481.   {
  482.     StrCompSplitRef(&SegComp, &AddrComp, pArg, pSegSepPos);
  483.     if (MomCPU < CPU80251)
  484.     {
  485.       WrError(ErrNum_InvAddrMode);
  486.       return;
  487.     }
  488.     else
  489.     {
  490.       if (!as_strcasecmp(SegComp.str.p_str, "S"))
  491.         SegType = -2;
  492.       else
  493.       {
  494.         SegType = EvalStrIntExpressionWithResult(&SegComp, UInt8, &EvalResult);
  495.         if (!EvalResult.OK)
  496.           return;
  497.         if (mFirstPassUnknown(EvalResult.Flags))
  498.           FirstFlag = True;
  499.       }
  500.     }
  501.     pAddrComp = &AddrComp;
  502.   }
  503.   else
  504.     pAddrComp = pArg;
  505.  
  506.   switch (SegType)
  507.   {
  508.     case -2:
  509.       H32 = EvalStrIntExpressionWithResult(pAddrComp, UInt9, &EvalResult);
  510.       ChkSpace(SegIO, EvalResult.AddrSpaceMask);
  511.       if (mFirstPassUnknown(EvalResult.Flags))
  512.         H32 = (H32 & 0xff) | 0x80;
  513.       break;
  514.     case -1:
  515.       H32 = EvalStrIntExpressionWithResult(pAddrComp, UInt24, &EvalResult);
  516.       break;
  517.     default:
  518.       H32 = EvalStrIntExpressionWithResult(pAddrComp, UInt16, &EvalResult);
  519.   }
  520.   if (mFirstPassUnknown(EvalResult.Flags))
  521.     FirstFlag = True;
  522.   if (!EvalResult.OK)
  523.     return;
  524.  
  525.   if ((SegType == -2) || ((SegType == -1) && (EvalResult.AddrSpaceMask & (1 << SegIO))))
  526.   {
  527.     if (ChkRange(H32, 0x80, 0xff))
  528.     {
  529.       SaveAdrRelocs(RelocTypeB8, 0);
  530.       AdrMode = ModDir8;
  531.       AdrVals[0] = H32 & 0xff;
  532.       AdrCnt = 1;
  533.     }
  534.   }
  535.  
  536.   else
  537.   {
  538.     if (SegType >= 0)
  539.       H32 += ((LongWord)SegType) << 16;
  540.     if (FirstFlag)
  541.       H32 &= ((MomCPU < CPU80251) || ((Mask & ModDir16) == 0)) ? 0xff : 0xffff;
  542.  
  543.     if (((H32 < 128) || ((H32 < 256) && (MomCPU < CPU80251))) && ((Mask & MModDir8) != 0))
  544.     {
  545.       if (MomCPU < CPU80251)
  546.         ChkSpace(SegData, EvalResult.AddrSpaceMask);
  547.       SaveAdrRelocs(RelocTypeB8, 0);
  548.       AdrMode = ModDir8;
  549.       AdrVals[0] = H32 &0xff;
  550.       AdrCnt = 1;
  551.     }
  552.     else if ((MomCPU < CPU80251) || (H32 > 0xffff)) WrError(ErrNum_AdrOverflow);
  553.     else
  554.     {
  555.       AdrMode = ModDir16;
  556.       AdrCnt = 2;
  557.       AdrVals[1] = H32 & 0xff;
  558.       AdrVals[0] = (H32 >> 8) & 0xff;
  559.     }
  560.     adr_flags = EvalResult.Flags;
  561.   }
  562.  
  563. chk:
  564.   if ((AdrMode != ModNone) && ((Mask & (1 << AdrMode)) == 0))
  565.   {
  566.     if (ExtMask & (1 << AdrMode))
  567.       (void)ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported);
  568.     else
  569.       WrError(ErrNum_InvAddrMode);
  570.     AdrCnt = 0;
  571.     AdrMode = ModNone;
  572.   }
  573. }
  574.  
  575. static void DissectBit_251(char *pDest, size_t DestSize, LargeWord Inp)
  576. {
  577.   as_snprintf(pDest, DestSize, "%~02.*u%s.%u",
  578.               ListRadixBase, (unsigned)(Inp & 0xff), GetIntConstIntelSuffix(ListRadixBase),
  579.               (unsigned)(Inp >> 24));
  580. }
  581.  
  582. static ShortInt DecodeBitAdr(tStrComp *pArg, LongInt *Erg, Boolean MayShorten)
  583. {
  584.   tEvalResult EvalResult;
  585.   char *pPos, Save = '\0';
  586.   tStrComp RegPart, BitPart;
  587.  
  588.   pPos = RQuotPos(pArg->str.p_str, '.');
  589.   if (pPos)
  590.     Save = StrCompSplitRef(&RegPart, &BitPart, pArg, pPos);
  591.   if (MomCPU < CPU80251)
  592.   {
  593.     if (!pPos)
  594.     {
  595.       *Erg = EvalStrIntExpressionWithResult(pArg, UInt8, &EvalResult);
  596.       if (EvalResult.OK)
  597.       {
  598.         ChkSpace(SegBData, EvalResult.AddrSpaceMask);
  599.         return ModBit51;
  600.       }
  601.       else
  602.         return ModNone;
  603.     }
  604.     else
  605.     {
  606.       *Erg = EvalStrIntExpressionWithResult(&RegPart, UInt8, &EvalResult);
  607.       if (mFirstPassUnknown(EvalResult.Flags))
  608.         *Erg = 0x20;
  609.       *pPos = Save;
  610.       if (!EvalResult.OK) return ModNone;
  611.       else
  612.       {
  613.         ChkSpace(SegData, EvalResult.AddrSpaceMask);
  614.         Save = EvalStrIntExpressionWithResult(&BitPart, UInt3, &EvalResult);
  615.         if (!EvalResult.OK) return ModNone;
  616.         else
  617.         {
  618.           if (*Erg > 0x7f)
  619.           {
  620.             if ((*Erg) & 7)
  621.               WrError(ErrNum_NotBitAddressable);
  622.           }
  623.           else
  624.           {
  625.             if (((*Erg) & 0xe0) != 0x20)
  626.               WrError(ErrNum_NotBitAddressable);
  627.             *Erg = (*Erg - 0x20) << 3;
  628.           }
  629.           *Erg += Save;
  630.           return ModBit51;
  631.         }
  632.       }
  633.     }
  634.   }
  635.   else
  636.   {
  637.     if (!pPos)
  638.     {
  639.       static const LongWord ValidBits = 0x070000fful;
  640.  
  641.       *Erg = EvalStrIntExpressionWithResult(pArg, Int32, &EvalResult);
  642.       if (mFirstPassUnknown(EvalResult.Flags))
  643.         *Erg &= ValidBits;
  644.       if (*Erg & ~ValidBits)
  645.       {
  646.         WrError(ErrNum_InvBitPos);
  647.         EvalResult.OK = False;
  648.       }
  649.     }
  650.     else
  651.     {
  652.       DecodeAdr(&RegPart, MModDir8);
  653.       *pPos = Save;
  654.       if (AdrMode == ModNone)
  655.         EvalResult.OK = False;
  656.       else
  657.       {
  658.         *Erg = EvalStrIntExpressionWithResult(&BitPart, UInt3, &EvalResult) << 24;
  659.         if (EvalResult.OK)
  660.           (*Erg) += AdrVals[0];
  661.       }
  662.     }
  663.     if (!EvalResult.OK)
  664.       return ModNone;
  665.     else if (MayShorten)
  666.     {
  667.       if (((*Erg) & 0x87) == 0x80)
  668.       {
  669.         *Erg = ((*Erg) & 0xf8) + ((*Erg) >> 24);
  670.         return ModBit51;
  671.       }
  672.       else if (((*Erg) & 0xf0) == 0x20)
  673.       {
  674.         *Erg = (((*Erg) & 0x0f) << 3) + ((*Erg) >> 24);
  675.         return ModBit51;
  676.       }
  677.       else
  678.         return ModBit251;
  679.     }
  680.     else
  681.       return ModBit251;
  682.   }
  683. }
  684.  
  685. static Boolean Chk504(LongInt Adr)
  686. {
  687.   return ((MomCPU == CPU80504) && ((Adr & 0x7ff) == 0x7fe));
  688. }
  689.  
  690. static Boolean NeedsPrefix(Word Opcode)
  691. {
  692.   return (((Opcode&0x0f) >= 6) && ((SrcMode != 0) != ((Hi(Opcode) != 0) != 0)));
  693. }
  694.  
  695. static void PutCode(Word Opcode)
  696. {
  697.   if (((Opcode&0x0f) < 6) || ((SrcMode != 0) != ((Hi(Opcode) == 0) != 0)))
  698.   {
  699.     BAsmCode[0] = Lo(Opcode);
  700.     CodeLen = 1;
  701.   }
  702.   else
  703.   {
  704.     BAsmCode[0] = 0xa5;
  705.     BAsmCode[1] = Lo(Opcode);
  706.     CodeLen = 2;
  707.   }
  708. }
  709.  
  710. static Boolean IsCarry(const char *pArg)
  711. {
  712.   return (!as_strcasecmp(pArg, "C")) || (!as_strcasecmp(pArg, "CY"));
  713. }
  714.  
  715. /*-------------------------------------------------------------------------*/
  716. /* Einzelfaelle */
  717.  
  718. static void DecodeMOV(Word Index)
  719. {
  720.   LongInt AdrLong;
  721.   Byte HSize, HReg;
  722.   Integer AdrInt;
  723.   UNUSED(Index);
  724.  
  725.   if (!ChkArgCnt(2, 2));
  726.   else if (IsCarry(ArgStr[1].str.p_str))
  727.   {
  728.     switch (DecodeBitAdr(&ArgStr[2], &AdrLong, True))
  729.     {
  730.       case ModBit51:
  731.         PutCode(0xa2);
  732.         BAsmCode[CodeLen] = AdrLong & 0xff;
  733.         CodeLen++;
  734.         break;
  735.       case ModBit251:
  736.         PutCode(0x1a9);
  737.         BAsmCode[CodeLen  ] = 0xa0 + (AdrLong >> 24);
  738.         BAsmCode[CodeLen + 1] = AdrLong & 0xff;
  739.         CodeLen+=2;
  740.         break;
  741.     }
  742.   }
  743.   else if ((!as_strcasecmp(ArgStr[2].str.p_str, "C")) || (!as_strcasecmp(ArgStr[2].str.p_str, "CY")))
  744.   {
  745.     switch (DecodeBitAdr(&ArgStr[1], &AdrLong, True))
  746.     {
  747.       case ModBit51:
  748.         PutCode(0x92);
  749.         BAsmCode[CodeLen] = AdrLong & 0xff;
  750.         CodeLen++;
  751.         break;
  752.       case ModBit251:
  753.         PutCode(0x1a9);
  754.         BAsmCode[CodeLen] = 0x90 + (AdrLong >> 24);
  755.         BAsmCode[CodeLen + 1] = AdrLong & 0xff;
  756.         CodeLen+=2;
  757.         break;
  758.     }
  759.   }
  760.   else if (!as_strcasecmp(ArgStr[1].str.p_str, "DPTR"))
  761.   {
  762.     SetOpSize((MomCPU == CPU80C390) ? 3 : 1);
  763.     DecodeAdr(&ArgStr[2], MModImm);
  764.     switch (AdrMode)
  765.     {
  766.       case ModImm:
  767.         PutCode(0x90);
  768.         memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  769.         TransferAdrRelocs(CodeLen);
  770.         CodeLen += AdrCnt;
  771.         break;
  772.     }
  773.   }
  774.   else
  775.   {
  776.     DecodeAdr(&ArgStr[1], MModAcc | MModReg | MModIReg8 | MModIReg | MModInd | MModDir8 | MModDir16);
  777.     switch (AdrMode)
  778.     {
  779.       case ModAcc:
  780.         DecodeAdr(&ArgStr[2], MModReg | MModIReg8 | MModIReg | MModInd | MModDir8 | MModDir16 | MModImm);
  781.         switch (AdrMode)
  782.         {
  783.           case ModReg:
  784.             if ((AdrPart < 8) && (!SrcMode))
  785.               PutCode(0xe8 + AdrPart);
  786.             else if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  787.             {
  788.               PutCode(0x17c);
  789.               BAsmCode[CodeLen++] = (AccReg << 4) + AdrPart;
  790.             }
  791.             break;
  792.           case ModIReg8:
  793.             PutCode(0xe6 + AdrPart);
  794.             break;
  795.           case ModIReg:
  796.             PutCode(0x17e);
  797.             BAsmCode[CodeLen++] = (AdrPart << 4) + 0x09 + AdrSize;
  798.             BAsmCode[CodeLen++] = (AccReg << 4);
  799.             break;
  800.           case ModInd:
  801.             PutCode(0x109 + (AdrSize << 4));
  802.             BAsmCode[CodeLen++] = (AccReg << 4) + AdrPart;
  803.             memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  804.             CodeLen += AdrCnt;
  805.             break;
  806.           case ModDir8:
  807.             if (!mFirstPassUnknownOrQuestionable(adr_flags)
  808.              && (AdrVals[0] == 0xe0)
  809.              && (MomCPU < CPU80251))
  810.               WrStrErrorPos(ErrNum_Unpredictable, &ArgStr[2]);
  811.             PutCode(0xe5);
  812.             TransferAdrRelocs(CodeLen);
  813.             BAsmCode[CodeLen++] = AdrVals[0];
  814.             break;
  815.           case ModDir16:
  816.             PutCode(0x17e);
  817.             BAsmCode[CodeLen++] = (AccReg << 4) + 0x03;
  818.             memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  819.             CodeLen += AdrCnt;
  820.             break;
  821.           case ModImm:
  822.             PutCode(0x74);
  823.             TransferAdrRelocs(CodeLen);
  824.             BAsmCode[CodeLen++] = AdrVals[0];
  825.             break;
  826.         }
  827.         break;
  828.       case ModReg:
  829.         HReg = AdrPart;
  830.         DecodeAdr(&ArgStr[2], MModReg | MModIReg8 | MModIReg | MModInd | MModDir8 | MModDir16 | MModImm | MModImmEx);
  831.         switch (AdrMode)
  832.         {
  833.           case ModReg:
  834.             if ((OpSize == 0) && (AdrPart == AccReg) && (HReg < 8))
  835.               PutCode(0xf8 + HReg);
  836.             else if ((OpSize == 0) && (HReg == AccReg) && (AdrPart < 8))
  837.               PutCode(0xe8 + AdrPart);
  838.             else if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  839.             {
  840.               PutCode(0x17c + OpSize);
  841.               if (OpSize == 2)
  842.                 BAsmCode[CodeLen - 1]++;
  843.               BAsmCode[CodeLen++] = (HReg << 4) + AdrPart;
  844.             }
  845.             break;
  846.           case ModIReg8:
  847.             if ((OpSize != 0) || (HReg != AccReg)) WrError(ErrNum_InvAddrMode);
  848.             else
  849.               PutCode(0xe6 + AdrPart);
  850.             break;
  851.           case ModIReg:
  852.             if (OpSize == 0)
  853.             {
  854.               PutCode(0x17e);
  855.               BAsmCode[CodeLen++] = (AdrPart << 4) + 0x09 + AdrSize;
  856.               BAsmCode[CodeLen++] = HReg << 4;
  857.             }
  858.             else if (OpSize == 1)
  859.             {
  860.               PutCode(0x10b);
  861.               BAsmCode[CodeLen++] = (AdrPart << 4) + 0x08 + AdrSize;
  862.               BAsmCode[CodeLen++] = HReg << 4;
  863.             }
  864.             else
  865.               WrError(ErrNum_InvAddrMode);
  866.             break;
  867.           case ModInd:
  868.             if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  869.             else
  870.             {
  871.               PutCode(0x109 + (AdrSize << 4) + (OpSize << 6));
  872.               BAsmCode[CodeLen++] = (HReg << 4) + AdrPart;
  873.               memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  874.               CodeLen += AdrCnt;
  875.             }
  876.             break;
  877.           case ModDir8:
  878.             if ((OpSize == 0) && (HReg == AccReg))
  879.             {
  880.               PutCode(0xe5);
  881.               TransferAdrRelocs(CodeLen);
  882.               BAsmCode[CodeLen++] = AdrVals[0];
  883.             }
  884.             else if ((OpSize == 0) && (HReg < 8) && (!SrcMode))
  885.             {
  886.               PutCode(0xa8 + HReg);
  887.               TransferAdrRelocs(CodeLen);
  888.               BAsmCode[CodeLen++] = AdrVals[0];
  889.             }
  890.             else if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  891.             {
  892.               PutCode(0x17e);
  893.               BAsmCode[CodeLen++] = 0x01 + (HReg << 4) + (OpSize << 2);
  894.               if (OpSize == 2)
  895.                 BAsmCode[CodeLen - 1] += 4;
  896.               TransferAdrRelocs(CodeLen);
  897.               BAsmCode[CodeLen++] = AdrVals[0];
  898.             }
  899.             break;
  900.           case ModDir16:
  901.             PutCode(0x17e);
  902.             BAsmCode[CodeLen++] = 0x03 + (HReg << 4) + (OpSize << 2);
  903.             if (OpSize == 2)
  904.               BAsmCode[CodeLen - 1] += 4;
  905.             memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  906.             CodeLen += AdrCnt;
  907.             break;
  908.           case ModImm:
  909.             if ((OpSize == 0) && (HReg == AccReg))
  910.             {
  911.               PutCode(0x74);
  912.               TransferAdrRelocs(CodeLen);
  913.               BAsmCode[CodeLen++] = AdrVals[0];
  914.             }
  915.             else if ((OpSize == 0) && (HReg < 8) && (!SrcMode))
  916.             {
  917.               PutCode(0x78 + HReg);
  918.               TransferAdrRelocs(CodeLen);
  919.               BAsmCode[CodeLen++] = AdrVals[0];
  920.             }
  921.             else if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  922.             {
  923.               PutCode(0x17e);
  924.               BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2);
  925.               memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  926.               CodeLen += AdrCnt;
  927.             }
  928.             break;
  929.           case ModImmEx:
  930.             PutCode(0x17e);
  931.             TransferAdrRelocs(CodeLen);
  932.             BAsmCode[CodeLen++] = 0x0c + (HReg << 4);
  933.             memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  934.             CodeLen += AdrCnt;
  935.             break;
  936.         }
  937.         break;
  938.       case ModIReg8:
  939.         SetOpSize(0); HReg = AdrPart;
  940.         DecodeAdr(&ArgStr[2], MModAcc | MModDir8 | MModImm);
  941.         switch (AdrMode)
  942.         {
  943.           case ModAcc:
  944.             PutCode(0xf6 + HReg);
  945.             break;
  946.           case ModDir8:
  947.             PutCode(0xa6 + HReg);
  948.             TransferAdrRelocs(CodeLen);
  949.             BAsmCode[CodeLen++] = AdrVals[0];
  950.             break;
  951.           case ModImm:
  952.             PutCode(0x76 + HReg);
  953.             TransferAdrRelocs(CodeLen);
  954.             BAsmCode[CodeLen++] = AdrVals[0];
  955.             break;
  956.         }
  957.         break;
  958.       case ModIReg:
  959.         HReg = AdrPart; HSize = AdrSize;
  960.         DecodeAdr(&ArgStr[2], MModReg);
  961.         switch (AdrMode)
  962.         {
  963.           case ModReg:
  964.             if (OpSize == 0)
  965.             {
  966.               PutCode(0x17a);
  967.               BAsmCode[CodeLen++] = (HReg << 4) + 0x09 + HSize;
  968.               BAsmCode[CodeLen++] = AdrPart << 4;
  969.             }
  970.             else if (OpSize == 1)
  971.             {
  972.               PutCode(0x11b);
  973.               BAsmCode[CodeLen++] = (HReg << 4) + 0x08 + HSize;
  974.               BAsmCode[CodeLen++] = AdrPart << 4;
  975.             }
  976.             else
  977.               WrError(ErrNum_InvAddrMode);
  978.         }
  979.         break;
  980.       case ModInd:
  981.         HReg = AdrPart; HSize = AdrSize;
  982.         AdrInt = (((Word)AdrVals[0]) << 8) + AdrVals[1];
  983.         DecodeAdr(&ArgStr[2], MModReg);
  984.         switch (AdrMode)
  985.         {
  986.           case ModReg:
  987.             if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  988.             else
  989.             {
  990.               PutCode(0x119 + (HSize << 4) + (OpSize << 6));
  991.               BAsmCode[CodeLen++] = (AdrPart << 4) + HReg;
  992.               BAsmCode[CodeLen++] = Hi(AdrInt);
  993.               BAsmCode[CodeLen++] = Lo(AdrInt);
  994.             }
  995.         }
  996.         break;
  997.       case ModDir8:
  998.         MinOneIs0 = True;
  999.         HReg = AdrVals[0];
  1000.         SaveBackupAdrRelocs();
  1001.         DecodeAdr(&ArgStr[2], MModReg | MModIReg8 | MModDir8 | MModImm);
  1002.         switch (AdrMode)
  1003.         {
  1004.           case ModReg:
  1005.             if ((OpSize == 0) && (AdrPart == AccReg))
  1006.             {
  1007.               PutCode(0xf5);
  1008.               TransferBackupAdrRelocs(CodeLen);
  1009.               BAsmCode[CodeLen++] = HReg;
  1010.             }
  1011.             else if ((OpSize == 0) && (AdrPart < 8) && (!SrcMode))
  1012.             {
  1013.               PutCode(0x88 + AdrPart);
  1014.               TransferBackupAdrRelocs(CodeLen);
  1015.               BAsmCode[CodeLen++] = HReg;
  1016.             }
  1017.             else if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  1018.             {
  1019.               PutCode(0x17a);
  1020.               BAsmCode[CodeLen++] = 0x01 + (AdrPart << 4) + (OpSize << 2);
  1021.               if (OpSize == 2)
  1022.                 BAsmCode[CodeLen - 1] += 4;
  1023.               BAsmCode[CodeLen++] = HReg;
  1024.             }
  1025.             break;
  1026.           case ModIReg8:
  1027.             PutCode(0x86 + AdrPart);
  1028.             TransferBackupAdrRelocs(CodeLen);
  1029.             BAsmCode[CodeLen++] = HReg;
  1030.             break;
  1031.           case ModDir8:
  1032.             PutCode(0x85);
  1033.             TransferAdrRelocs(CodeLen);
  1034.             BAsmCode[CodeLen++] = AdrVals[0];
  1035.             TransferBackupAdrRelocs(CodeLen);
  1036.             BAsmCode[CodeLen++] = HReg;
  1037.             break;
  1038.           case ModImm:
  1039.             PutCode(0x75);
  1040.             TransferBackupAdrRelocs(CodeLen);
  1041.             BAsmCode[CodeLen++] = HReg;
  1042.             TransferAdrRelocs(CodeLen);
  1043.             BAsmCode[CodeLen++] = AdrVals[0];
  1044.             break;
  1045.         }
  1046.         break;
  1047.       case ModDir16:
  1048.         AdrInt = (((Word)AdrVals[0]) << 8) + AdrVals[1];
  1049.         DecodeAdr(&ArgStr[2], MModReg);
  1050.         switch (AdrMode)
  1051.         {
  1052.           case ModReg:
  1053.             PutCode(0x17a);
  1054.             BAsmCode[CodeLen++] = 0x03 + (AdrPart << 4) + (OpSize << 2);
  1055.             if (OpSize == 2) BAsmCode[CodeLen - 1] += 4;
  1056.             BAsmCode[CodeLen++] = Hi(AdrInt);
  1057.             BAsmCode[CodeLen++] = Lo(AdrInt);
  1058.             break;
  1059.         }
  1060.         break;
  1061.     }
  1062.   }
  1063. }
  1064.  
  1065. static void DecodeLogic(Word Index)
  1066. {
  1067.   Byte HReg;
  1068.   LongInt AdrLong;
  1069.   int z;
  1070.  
  1071.   /* Index: ORL=0 ANL=1 XRL=2 */
  1072.  
  1073.   if (!ChkArgCnt(2, 2));
  1074.   else if (IsCarry(ArgStr[1].str.p_str))
  1075.   {
  1076.     if (Index == 2) WrError(ErrNum_InvAddrMode);
  1077.     else
  1078.     {
  1079.       Boolean InvFlag;
  1080.       ShortInt Result;
  1081.  
  1082.       HReg = Index << 4;
  1083.       InvFlag = *ArgStr[2].str.p_str == '/';
  1084.       if (InvFlag)
  1085.       {
  1086.         tStrComp Comp;
  1087.  
  1088.         StrCompRefRight(&Comp, &ArgStr[2], 1);
  1089.         Result = DecodeBitAdr(&Comp, &AdrLong, True);
  1090.       }
  1091.       else
  1092.         Result = DecodeBitAdr(&ArgStr[2], &AdrLong, True);
  1093.       switch (Result)
  1094.       {
  1095.         case ModBit51:
  1096.           PutCode((InvFlag) ? 0xa0 + HReg : 0x72 + HReg);
  1097.           BAsmCode[CodeLen++] = AdrLong & 0xff;
  1098.           break;
  1099.         case ModBit251:
  1100.           PutCode(0x1a9);
  1101.           BAsmCode[CodeLen++] = ((InvFlag) ? 0xe0 : 0x70) + HReg + (AdrLong >> 24);
  1102.           BAsmCode[CodeLen++] = AdrLong & 0xff;
  1103.           break;
  1104.       }
  1105.     }
  1106.   }
  1107.   else
  1108.   {
  1109.     z = (Index << 4) + 0x40;
  1110.     DecodeAdr(&ArgStr[1], MModAcc | MModReg | MModDir8);
  1111.     switch (AdrMode)
  1112.     {
  1113.       case ModAcc:
  1114.         DecodeAdr(&ArgStr[2], MModReg | MModIReg8 | MModIReg | MModDir8 | MModDir16 | MModImm);
  1115.         switch (AdrMode)
  1116.         {
  1117.           case ModReg:
  1118.             if ((AdrPart < 8) && (!SrcMode)) PutCode(z + 8 + AdrPart);
  1119.             else
  1120.             {
  1121.               PutCode(z + 0x10c);
  1122.               BAsmCode[CodeLen++] = AdrPart + (AccReg << 4);
  1123.             }
  1124.             break;
  1125.           case ModIReg8:
  1126.             PutCode(z + 6 + AdrPart);
  1127.             break;
  1128.           case ModIReg:
  1129.             PutCode(z + 0x10e);
  1130.             BAsmCode[CodeLen++] = 0x09 + AdrSize + (AdrPart << 4);
  1131.             BAsmCode[CodeLen++] = AccReg << 4;
  1132.             break;
  1133.           case ModDir8:
  1134.             PutCode(z + 0x05);
  1135.             TransferAdrRelocs(CodeLen);
  1136.             BAsmCode[CodeLen++] = AdrVals[0];
  1137.             break;
  1138.           case ModDir16:
  1139.             PutCode(0x10e + z);
  1140.             BAsmCode[CodeLen++] = 0x03 + (AccReg << 4);
  1141.             memcpy(BAsmCode+CodeLen, AdrVals, AdrCnt);
  1142.             CodeLen += AdrCnt;
  1143.             break;
  1144.           case ModImm:
  1145.             PutCode(z + 0x04);
  1146.             TransferAdrRelocs(CodeLen);
  1147.             BAsmCode[CodeLen++] = AdrVals[0];
  1148.             break;
  1149.         }
  1150.         break;
  1151.       case ModReg:
  1152.         if (MomCPU < CPU80251) WrError(ErrNum_InvAddrMode);
  1153.         else
  1154.         {
  1155.           HReg = AdrPart;
  1156.           DecodeAdr(&ArgStr[2], MModReg | MModIReg8 | MModIReg | MModDir8 | MModDir16 | MModImm);
  1157.           switch (AdrMode)
  1158.           {
  1159.             case ModReg:
  1160.               if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  1161.               else
  1162.               {
  1163.                 PutCode(z + 0x10c + OpSize);
  1164.                 BAsmCode[CodeLen++] = (HReg << 4) + AdrPart;
  1165.               }
  1166.               break;
  1167.             case ModIReg8:
  1168.               if ((OpSize != 0) || (HReg != AccReg)) WrError(ErrNum_InvAddrMode);
  1169.               else
  1170.                 PutCode(z + 0x06 + AdrPart);
  1171.               break;
  1172.             case ModIReg:
  1173.               if (OpSize != 0) WrError(ErrNum_InvAddrMode);
  1174.               else
  1175.               {
  1176.                 PutCode(0x10e + z);
  1177.                 BAsmCode[CodeLen++] = 0x09 + AdrSize + (AdrPart << 4);
  1178.                 BAsmCode[CodeLen++] = HReg << 4;
  1179.               }
  1180.               break;
  1181.             case ModDir8:
  1182.               if ((OpSize == 0) && (HReg == AccReg))
  1183.               {
  1184.                 PutCode(0x05 + z);
  1185.                 TransferAdrRelocs(CodeLen);
  1186.                 BAsmCode[CodeLen++] = AdrVals[0];
  1187.               }
  1188.               else if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  1189.               else
  1190.               {
  1191.                 PutCode(0x10e + z);
  1192.                 BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2) + 1;
  1193.                 BAsmCode[CodeLen++] = AdrVals[0];
  1194.               }
  1195.               break;
  1196.             case ModDir16:
  1197.               if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  1198.               else
  1199.               {
  1200.                 PutCode(0x10e + z);
  1201.                 BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2) + 3;
  1202.                 memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  1203.                 CodeLen += AdrCnt;
  1204.               }
  1205.               break;
  1206.             case ModImm:
  1207.               if ((OpSize == 0) && (HReg == AccReg))
  1208.               {
  1209.                 PutCode(0x04 + z);
  1210.                 TransferAdrRelocs(CodeLen);
  1211.                 BAsmCode[CodeLen++] = AdrVals[0];
  1212.               }
  1213.               else if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  1214.               else
  1215.               {
  1216.                 PutCode(0x10e + z);
  1217.                 BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2);
  1218.                 TransferAdrRelocs(CodeLen);
  1219.                 memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  1220.                 CodeLen += AdrCnt;
  1221.               }
  1222.               break;
  1223.           }
  1224.         }
  1225.         break;
  1226.       case ModDir8:
  1227.         HReg = AdrVals[0];
  1228.         SaveBackupAdrRelocs();
  1229.         SetOpSize(0);
  1230.         DecodeAdr(&ArgStr[2], MModAcc | MModImm);
  1231.         switch (AdrMode)
  1232.         {
  1233.           case ModAcc:
  1234.             PutCode(z + 0x02);
  1235.             TransferBackupAdrRelocs(CodeLen);
  1236.             BAsmCode[CodeLen++] = HReg;
  1237.             break;
  1238.           case ModImm:
  1239.             PutCode(z + 0x03);
  1240.             TransferBackupAdrRelocs(CodeLen);
  1241.             BAsmCode[CodeLen++] = HReg;
  1242.             TransferAdrRelocs(CodeLen);
  1243.             BAsmCode[CodeLen++] = AdrVals[0];
  1244.             break;
  1245.         }
  1246.         break;
  1247.     }
  1248.   }
  1249. }
  1250.  
  1251. static void DecodeMOVC(Word Index)
  1252. {
  1253.   UNUSED(Index);
  1254.  
  1255.   if (ChkArgCnt(2, 2))
  1256.   {
  1257.     DecodeAdr(&ArgStr[1], MModAcc);
  1258.     switch (AdrMode)
  1259.     {
  1260.       case ModAcc:
  1261.         if (!as_strcasecmp(ArgStr[2].str.p_str, "@A+DPTR"))
  1262.           PutCode(0x93);
  1263.         else if (!as_strcasecmp(ArgStr[2].str.p_str, "@A+PC"))
  1264.           PutCode(0x83);
  1265.         else
  1266.           WrError(ErrNum_InvAddrMode);
  1267.         break;
  1268.     }
  1269.   }
  1270. }
  1271.  
  1272. static void DecodeMOVH(Word Index)
  1273. {
  1274.   Byte HReg;
  1275.   UNUSED(Index);
  1276.  
  1277.   if (ChkArgCnt(2, 2)
  1278.    && ChkMinCPU(CPU80251))
  1279.   {
  1280.     DecodeAdr(&ArgStr[1], MModReg);
  1281.     switch (AdrMode)
  1282.     {
  1283.       case ModReg:
  1284.         if (OpSize != 2) WrError(ErrNum_InvAddrMode);
  1285.         else
  1286.         {
  1287.           HReg = AdrPart;
  1288.           OpSize--;
  1289.           DecodeAdr(&ArgStr[2], MModImm);
  1290.           switch (AdrMode)
  1291.           {
  1292.             case ModImm:
  1293.               PutCode(0x17a);
  1294.               BAsmCode[CodeLen++] = 0x0c + (HReg << 4);
  1295.               TransferAdrRelocs(CodeLen);
  1296.               memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  1297.               CodeLen += AdrCnt;
  1298.               break;
  1299.           }
  1300.         }
  1301.         break;
  1302.     }
  1303.   }
  1304. }
  1305.  
  1306. static void DecodeMOVZS(Word code)
  1307. {
  1308.   Byte HReg;
  1309.  
  1310.   if (ChkArgCnt(2, 2)
  1311.    && ChkMinCPU(CPU80251))
  1312.   {
  1313.     DecodeAdr(&ArgStr[1], MModReg);
  1314.     switch (AdrMode)
  1315.     {
  1316.       case ModReg:
  1317.         if (OpSize != 1) WrError(ErrNum_InvAddrMode);
  1318.         else
  1319.         {
  1320.           HReg = AdrPart;
  1321.           OpSize--;
  1322.           DecodeAdr(&ArgStr[2], MModReg);
  1323.           switch (AdrMode)
  1324.           {
  1325.             case ModReg:
  1326.              PutCode(0x10a + code);
  1327.              BAsmCode[CodeLen++] = (HReg << 4) + AdrPart;
  1328.              break;
  1329.           }
  1330.         }
  1331.         break;
  1332.     }
  1333.   }
  1334. }
  1335.  
  1336. static void DecodeMOVX(Word Index)
  1337. {
  1338.   int z;
  1339.   UNUSED(Index);
  1340.  
  1341.   if (ChkArgCnt(2, 2))
  1342.   {
  1343.     z = 0;
  1344.     if ((!as_strcasecmp(ArgStr[2].str.p_str, "A")) || ((MomCPU >= CPU80251) && (!as_strcasecmp(ArgStr[2].str.p_str, "R11"))))
  1345.     {
  1346.       z = 0x10;
  1347.       strcpy(ArgStr[2].str.p_str, ArgStr[1].str.p_str);
  1348.       strmaxcpy(ArgStr[1].str.p_str, "A", STRINGSIZE);
  1349.     }
  1350.     if ((as_strcasecmp(ArgStr[1].str.p_str, "A")) && ((MomCPU < CPU80251) || (!as_strcasecmp(ArgStr[2].str.p_str, "R11")))) WrError(ErrNum_InvAddrMode);
  1351.     else if (!as_strcasecmp(ArgStr[2].str.p_str, "@DPTR"))
  1352.       PutCode(0xe0 + z);
  1353.     else
  1354.     {
  1355.       DecodeAdr(&ArgStr[2], MModIReg8);
  1356.       switch (AdrMode)
  1357.       {
  1358.         case ModIReg8:
  1359.           PutCode(0xe2 + AdrPart + z);
  1360.           break;
  1361.       }
  1362.     }
  1363.   }
  1364. }
  1365.  
  1366. static void DecodeStack(Word Index)
  1367. {
  1368.   int z;
  1369.  
  1370.   /* Index: PUSH=0 POP=1 PUSHW=2 */
  1371.  
  1372.   z = (Index & 1) << 4;
  1373.   if (ChkArgCnt(1, 1))
  1374.   {
  1375.     if (*ArgStr[1].str.p_str == '#')
  1376.       SetOpSize(Ord(Index == 2));
  1377.     DecodeAdr(&ArgStr[1], MModDir8 | MModReg | ((z == 0x10) ? 0 : MModImm));
  1378.     switch (AdrMode)
  1379.     {
  1380.       case ModDir8:
  1381.         PutCode(0xc0 + z);
  1382.         TransferAdrRelocs(CodeLen);
  1383.         BAsmCode[CodeLen++] = AdrVals[0];
  1384.         break;
  1385.       case ModReg:
  1386.         if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  1387.         {
  1388.           PutCode(0x1ca + z);
  1389.           BAsmCode[CodeLen++] = 0x08 + (AdrPart << 4) + OpSize + (Ord(OpSize == 2));
  1390.         }
  1391.         break;
  1392.       case ModImm:
  1393.         if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  1394.         {
  1395.           PutCode(0x1ca);
  1396.           BAsmCode[CodeLen++] = 0x02 + (OpSize << 2);
  1397.           TransferAdrRelocs(CodeLen);
  1398.           memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  1399.           CodeLen += AdrCnt;
  1400.         }
  1401.         break;
  1402.     }
  1403.   }
  1404. }
  1405.  
  1406. static void DecodeXCH(Word Index)
  1407. {
  1408.   Byte HReg;
  1409.   UNUSED(Index);
  1410.  
  1411.   if (ChkArgCnt(2, 2))
  1412.   {
  1413.     DecodeAdr(&ArgStr[1], MModAcc | MModReg | MModIReg8 | MModDir8);
  1414.     switch (AdrMode)
  1415.     {
  1416.       case ModAcc:
  1417.         DecodeAdr(&ArgStr[2], MModReg | MModIReg8 | MModDir8);
  1418.         switch (AdrMode)
  1419.         {
  1420.           case ModReg:
  1421.             if (AdrPart > 7) WrError(ErrNum_InvAddrMode);
  1422.             else
  1423.               PutCode(0xc8 + AdrPart);
  1424.             break;
  1425.           case ModIReg8:
  1426.             PutCode(0xc6 + AdrPart);
  1427.             break;
  1428.           case ModDir8:
  1429.             PutCode(0xc5);
  1430.             TransferAdrRelocs(CodeLen);
  1431.             BAsmCode[CodeLen++] = AdrVals[0];
  1432.             break;
  1433.         }
  1434.         break;
  1435.       case ModReg:
  1436.         if ((OpSize != 0) || (AdrPart > 7)) WrError(ErrNum_InvAddrMode);
  1437.         else
  1438.         {
  1439.           HReg = AdrPart;
  1440.           DecodeAdr(&ArgStr[2], MModAcc);
  1441.           switch (AdrMode)
  1442.           {
  1443.             case ModAcc:
  1444.               PutCode(0xc8 + HReg);
  1445.               break;
  1446.           }
  1447.         }
  1448.         break;
  1449.       case ModIReg8:
  1450.         HReg = AdrPart;
  1451.         DecodeAdr(&ArgStr[2], MModAcc);
  1452.         switch (AdrMode)
  1453.         {
  1454.           case ModAcc:
  1455.             PutCode(0xc6 + HReg);
  1456.             break;
  1457.         }
  1458.         break;
  1459.       case ModDir8:
  1460.         HReg = AdrVals[0]; SaveBackupAdrRelocs();
  1461.         DecodeAdr(&ArgStr[2], MModAcc);
  1462.         switch (AdrMode)
  1463.         {
  1464.           case ModAcc:
  1465.             PutCode(0xc5);
  1466.             TransferBackupAdrRelocs(CodeLen);
  1467.             BAsmCode[CodeLen++] = HReg;
  1468.             break;
  1469.         }
  1470.         break;
  1471.     }
  1472.   }
  1473. }
  1474.  
  1475. static void DecodeXCHD(Word Index)
  1476. {
  1477.   Byte HReg;
  1478.   UNUSED(Index);
  1479.  
  1480.   if (ChkArgCnt(2, 2))
  1481.   {
  1482.     DecodeAdr(&ArgStr[1], MModAcc | MModIReg8);
  1483.     switch (AdrMode)
  1484.     {
  1485.       case ModAcc:
  1486.         DecodeAdr(&ArgStr[2], MModIReg8);
  1487.         switch (AdrMode)
  1488.         {
  1489.           case ModIReg8:
  1490.             PutCode(0xd6 + AdrPart);
  1491.             break;
  1492.         }
  1493.         break;
  1494.       case ModIReg8:
  1495.         HReg = AdrPart;
  1496.         DecodeAdr(&ArgStr[2], MModAcc);
  1497.         switch (AdrMode)
  1498.         {
  1499.           case ModAcc:
  1500.             PutCode(0xd6 + HReg);
  1501.             break;
  1502.         }
  1503.         break;
  1504.     }
  1505.   }
  1506. }
  1507.  
  1508. #define RelocTypeABranch11 (11 | RelocFlagBig | RelocFlagPage | (5 << 8) | (3 << 12)) | (0 << 16)
  1509. #define RelocTypeABranch19 (19 | RelocFlagBig | RelocFlagPage | (5 << 8) | (3 << 12)) | (0 << 16)
  1510.  
  1511. static void DecodeABranch(Word Index)
  1512. {
  1513.   /* Index: AJMP = 0 ACALL = 1 */
  1514.  
  1515.   if (ChkArgCnt(1, 1))
  1516.   {
  1517.     tEvalResult EvalResult;
  1518.     LongInt AdrLong = EvalStrIntExpressionWithResult(&ArgStr[1], Int24, &EvalResult);
  1519.  
  1520.     if (EvalResult.OK)
  1521.     {
  1522.       ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  1523.       if (MomCPU == CPU80C390)
  1524.       {
  1525.         if (ChkSamePage(EProgCounter() + 3, AdrLong, 19, EvalResult.Flags))
  1526.         {
  1527.           PutCode(0x01 + (Index << 4) + (((AdrLong >> 16) & 7) << 5));
  1528.           BAsmCode[CodeLen++] = Hi(AdrLong);
  1529.           BAsmCode[CodeLen++] = Lo(AdrLong);
  1530.           TransferRelocs(ProgCounter() - 3, RelocTypeABranch19);
  1531.         }
  1532.       }
  1533.       else
  1534.       {
  1535.         if (!ChkSamePage(EProgCounter(), AdrLong, 11, EvalResult.Flags));
  1536.         else if (Chk504(EProgCounter())) WrError(ErrNum_NotOnThisAddress);
  1537.         else
  1538.         {
  1539.           PutCode(0x01 + (Index << 4) + ((Hi(AdrLong) & 7) << 5));
  1540.           BAsmCode[CodeLen++] = Lo(AdrLong);
  1541.           TransferRelocs(ProgCounter() - 2, RelocTypeABranch11);
  1542.         }
  1543.       }
  1544.     }
  1545.   }
  1546. }
  1547.  
  1548. static void DecodeLBranch(Word Index)
  1549. {
  1550.   /* Index: LJMP=0 LCALL=1 */
  1551.  
  1552.   if (!ChkArgCnt(1, 1));
  1553.   else if (!ChkMinCPU(CPU8051));
  1554.   else if (*ArgStr[1].str.p_str == '@')
  1555.   {
  1556.     DecodeAdr(&ArgStr[1], MModIReg);
  1557.     switch (AdrMode)
  1558.     {
  1559.       case ModIReg:
  1560.         if (AdrSize != 0) WrError(ErrNum_InvAddrMode);
  1561.         else
  1562.         {
  1563.           PutCode(0x189 + (Index << 4));
  1564.           BAsmCode[CodeLen++] = 0x04 + (AdrPart << 4);
  1565.         }
  1566.         break;
  1567.     }
  1568.   }
  1569.   else
  1570.   {
  1571.     tEvalResult EvalResult;
  1572.     LongInt AdrLong = EvalStrIntExpressionWithResult(&ArgStr[1], (MomCPU < CPU80C390) ? Int16 : Int24, &EvalResult);
  1573.  
  1574.     if (EvalResult.OK)
  1575.     {
  1576.       ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  1577.       if (MomCPU == CPU80C390)
  1578.       {
  1579.         PutCode(0x02 + (Index << 4));
  1580.         BAsmCode[CodeLen++] = (AdrLong >> 16) & 0xff;
  1581.         BAsmCode[CodeLen++] = (AdrLong >> 8) & 0xff;
  1582.         BAsmCode[CodeLen++] = AdrLong & 0xff;
  1583.         TransferRelocs(ProgCounter() + 1, RelocTypeB24);
  1584.       }
  1585.       else
  1586.       {
  1587.         if ((MomCPU >= CPU80251) && !ChkSamePage(EProgCounter() + 3, AdrLong, 16, EvalResult.Flags));
  1588.         else
  1589.         {
  1590.           PutCode(0x02 + (Index << 4));
  1591.           BAsmCode[CodeLen++] = (AdrLong >> 8) & 0xff;
  1592.           BAsmCode[CodeLen++] = AdrLong & 0xff;
  1593.           TransferRelocs(ProgCounter() + 1, RelocTypeB16);
  1594.         }
  1595.       }
  1596.     }
  1597.   }
  1598. }
  1599.  
  1600. static void DecodeEBranch(Word Index)
  1601. {
  1602.   /* Index: AJMP=0 ACALL=1 */
  1603.  
  1604.   if (!ChkArgCnt(1, 1));
  1605.   else if (!ChkMinCPU(CPU80251));
  1606.   else if (*ArgStr[1].str.p_str == '@')
  1607.   {
  1608.     DecodeAdr(&ArgStr[1], MModIReg);
  1609.     switch (AdrMode)
  1610.     {
  1611.       case ModIReg:
  1612.         if (AdrSize != 2) WrError(ErrNum_InvAddrMode);
  1613.         else
  1614.         {
  1615.           PutCode(0x189 + (Index << 4));
  1616.           BAsmCode[CodeLen++] = 0x08 + (AdrPart << 4);
  1617.         }
  1618.         break;
  1619.     }
  1620.   }
  1621.   else
  1622.   {
  1623.     tEvalResult EvalResult;
  1624.     LongInt AdrLong = EvalStrIntExpressionWithResult(&ArgStr[1], UInt24, &EvalResult);
  1625.  
  1626.     if (EvalResult.OK)
  1627.     {
  1628.       ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  1629.       PutCode(0x18a + (Index << 4));
  1630.       BAsmCode[CodeLen++] = (AdrLong >> 16) & 0xff;
  1631.       BAsmCode[CodeLen++] = (AdrLong >>  8) & 0xff;
  1632.       BAsmCode[CodeLen++] =  AdrLong        & 0xff;
  1633.     }
  1634.   }
  1635. }
  1636.  
  1637. static void DecodeJMP(Word Index)
  1638. {
  1639.   LongInt AdrLong, Dist;
  1640.   Boolean OK;
  1641.   UNUSED(Index);
  1642.  
  1643.   if (!ChkArgCnt(1, 1));
  1644.   else if (!as_strcasecmp(ArgStr[1].str.p_str, "@A+DPTR"))
  1645.     PutCode(0x73);
  1646.   else if (*ArgStr[1].str.p_str == '@')
  1647.   {
  1648.     DecodeAdr(&ArgStr[1], MModIReg);
  1649.     switch (AdrMode)
  1650.     {
  1651.       case ModIReg:
  1652.         PutCode(0x189);
  1653.         BAsmCode[CodeLen++] = 0x04 + (AdrSize << 1) + (AdrPart << 4);
  1654.         break;
  1655.     }
  1656.   }
  1657.   else
  1658.   {
  1659.     AdrLong = EvalStrIntExpression(&ArgStr[1], UInt24, &OK);
  1660.     if (OK)
  1661.     {
  1662.       Dist = AdrLong - (EProgCounter() + 2);
  1663.       if ((Dist<=127) && (Dist >= -128))
  1664.       {
  1665.         PutCode(0x80);
  1666.         BAsmCode[CodeLen++] = Dist & 0xff;
  1667.       }
  1668.       else if ((!Chk504(EProgCounter())) && ((AdrLong >> 11) == ((((long)EProgCounter()) + 2) >> 11)))
  1669.       {
  1670.         PutCode(0x01 + ((Hi(AdrLong) & 7) << 5));
  1671.         BAsmCode[CodeLen++] = Lo(AdrLong);
  1672.       }
  1673.       else if (MomCPU < CPU8051) WrError(ErrNum_JmpTargOnDiffPage);
  1674.       else if (((((long)EProgCounter()) + 3) >> 16) == (AdrLong >> 16))
  1675.       {
  1676.         PutCode(0x02);
  1677.         BAsmCode[CodeLen++] = Hi(AdrLong);
  1678.         BAsmCode[CodeLen++] = Lo(AdrLong);
  1679.       }
  1680.       else if (MomCPU < CPU80251) WrError(ErrNum_JmpTargOnDiffPage);
  1681.       else
  1682.       {
  1683.         PutCode(0x18a);
  1684.         BAsmCode[CodeLen++] = (AdrLong >> 16) & 0xff;
  1685.         BAsmCode[CodeLen++] = (AdrLong >>  8) & 0xff;
  1686.         BAsmCode[CodeLen++] =  AdrLong        & 0xff;
  1687.       }
  1688.     }
  1689.   }
  1690. }
  1691.  
  1692. static void DecodeCALL(Word Index)
  1693. {
  1694.   LongInt AdrLong;
  1695.   Boolean OK;
  1696.   tSymbolFlags Flags;
  1697.  
  1698.   UNUSED(Index);
  1699.  
  1700.   if (!ChkArgCnt(1, 1));
  1701.   else if (*ArgStr[1].str.p_str == '@')
  1702.   {
  1703.     DecodeAdr(&ArgStr[1], MModIReg);
  1704.     switch (AdrMode)
  1705.     {
  1706.       case ModIReg:
  1707.         PutCode(0x199);
  1708.         BAsmCode[CodeLen++] = 0x04 + (AdrSize << 1) + (AdrPart << 4);
  1709.         break;
  1710.     }
  1711.   }
  1712.   else
  1713.   {
  1714.     AdrLong = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt24, &OK, &Flags);
  1715.     if (OK)
  1716.     {
  1717.       if ((!Chk504(EProgCounter())) && ((AdrLong >> 11) == ((((long)EProgCounter()) + 2) >> 11)))
  1718.       {
  1719.         PutCode(0x11 + ((Hi(AdrLong) & 7) << 5));
  1720.         BAsmCode[CodeLen++] = Lo(AdrLong);
  1721.       }
  1722.       else if (MomCPU < CPU8051) WrError(ErrNum_JmpTargOnDiffPage);
  1723.       else if (ChkSamePage(AdrLong, EProgCounter() + 3, 16, Flags))
  1724.       {
  1725.         PutCode(0x12);
  1726.         BAsmCode[CodeLen++] = Hi(AdrLong);
  1727.         BAsmCode[CodeLen++] = Lo(AdrLong);
  1728.       }
  1729.     }
  1730.   }
  1731. }
  1732.  
  1733. static void DecodeDJNZ(Word Index)
  1734. {
  1735.   LongInt AdrLong;
  1736.   Boolean OK;
  1737.   tSymbolFlags Flags;
  1738.  
  1739.   UNUSED(Index);
  1740.  
  1741.   if (ChkArgCnt(2, 2))
  1742.   {
  1743.     AdrLong = EvalStrIntExpressionWithFlags(&ArgStr[2], UInt24, &OK, &Flags);
  1744.     SubPCRefReloc();
  1745.     if (OK)
  1746.     {
  1747.       DecodeAdr(&ArgStr[1], MModReg | MModDir8);
  1748.       switch (AdrMode)
  1749.       {
  1750.         case ModReg:
  1751.           if ((OpSize != 0) || (AdrPart > 7)) WrError(ErrNum_InvAddrMode);
  1752.           else
  1753.           {
  1754.             AdrLong -= EProgCounter() + 2 + Ord(NeedsPrefix(0xd8 + AdrPart));
  1755.             if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1756.             else
  1757.             {
  1758.               PutCode(0xd8 + AdrPart);
  1759.               BAsmCode[CodeLen++] = AdrLong & 0xff;
  1760.             }
  1761.           }
  1762.           break;
  1763.         case ModDir8:
  1764.           AdrLong -= EProgCounter() + 3 + Ord(NeedsPrefix(0xd5));
  1765.           if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1766.           else
  1767.           {
  1768.             PutCode(0xd5);
  1769.             TransferAdrRelocs(CodeLen);
  1770.             BAsmCode[CodeLen++] = AdrVals[0];
  1771.             BAsmCode[CodeLen++] = Lo(AdrLong);
  1772.           }
  1773.           break;
  1774.       }
  1775.     }
  1776.   }
  1777. }
  1778.  
  1779. static void DecodeCJNE(Word Index)
  1780. {
  1781.   LongInt AdrLong;
  1782.   Boolean OK;
  1783.   tSymbolFlags Flags;
  1784.   Byte HReg;
  1785.   UNUSED(Index);
  1786.  
  1787.   if (ChkArgCnt(3, 3))
  1788.   {
  1789.     AdrLong = EvalStrIntExpressionWithFlags(&ArgStr[3], UInt24, &OK, &Flags);
  1790.     SubPCRefReloc();
  1791.     if (OK)
  1792.     {
  1793.       DecodeAdr(&ArgStr[1], MModAcc | MModIReg8 | MModReg);
  1794.       switch (AdrMode)
  1795.       {
  1796.         case ModAcc:
  1797.           DecodeAdr(&ArgStr[2], MModDir8 | MModImm);
  1798.           switch (AdrMode)
  1799.           {
  1800.             case ModDir8:
  1801.               AdrLong -= EProgCounter() + 3 + Ord(NeedsPrefix(0xb5));
  1802.               if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1803.               else
  1804.               {
  1805.                 PutCode(0xb5);
  1806.                 TransferAdrRelocs(CodeLen);
  1807.                 BAsmCode[CodeLen++] = AdrVals[0];
  1808.                 BAsmCode[CodeLen++] = AdrLong & 0xff;
  1809.               }
  1810.               break;
  1811.             case ModImm:
  1812.               AdrLong -= EProgCounter() + 3 + Ord(NeedsPrefix(0xb5));
  1813.               if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1814.               else
  1815.               {
  1816.                 PutCode(0xb4);
  1817.                 TransferAdrRelocs(CodeLen);
  1818.                 BAsmCode[CodeLen++] = AdrVals[0];
  1819.                 BAsmCode[CodeLen++] = AdrLong & 0xff;
  1820.               }
  1821.               break;
  1822.           }
  1823.           break;
  1824.         case ModReg:
  1825.           if ((OpSize != 0) || (AdrPart > 7)) WrError(ErrNum_InvAddrMode);
  1826.           else
  1827.           {
  1828.             HReg = AdrPart;
  1829.             DecodeAdr(&ArgStr[2], MModImm);
  1830.             switch (AdrMode)
  1831.             {
  1832.               case ModImm:
  1833.                 AdrLong -= EProgCounter() + 3 + Ord(NeedsPrefix(0xb8 + HReg));
  1834.                 if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1835.                 else
  1836.                 {
  1837.                   PutCode(0xb8 + HReg);
  1838.                   TransferAdrRelocs(CodeLen);
  1839.                   BAsmCode[CodeLen++] = AdrVals[0];
  1840.                   BAsmCode[CodeLen++] = AdrLong & 0xff;
  1841.                 }
  1842.                 break;
  1843.             }
  1844.           }
  1845.           break;
  1846.         case ModIReg8:
  1847.           HReg = AdrPart; SetOpSize(0);
  1848.           DecodeAdr(&ArgStr[2], MModImm);
  1849.           switch (AdrMode)
  1850.           {
  1851.             case ModImm:
  1852.               AdrLong -= EProgCounter() + 3 + Ord(NeedsPrefix(0xb6 + HReg));
  1853.               if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1854.               else
  1855.               {
  1856.                 PutCode(0xb6 + HReg);
  1857.                 TransferAdrRelocs(CodeLen);
  1858.                 BAsmCode[CodeLen++] = AdrVals[0];
  1859.                 BAsmCode[CodeLen++] = AdrLong & 0xff;
  1860.               }
  1861.               break;
  1862.           }
  1863.           break;
  1864.       }
  1865.     }
  1866.   }
  1867. }
  1868.  
  1869. static void DecodeADD(Word Index)
  1870. {
  1871.   Byte HReg;
  1872.   UNUSED(Index);
  1873.  
  1874.   if (ChkArgCnt(2, 2))
  1875.   {
  1876.     DecodeAdr(&ArgStr[1], MModAcc | MModReg);
  1877.     switch (AdrMode)
  1878.     {
  1879.       case ModAcc:
  1880.         DecodeAdr(&ArgStr[2], MModImm | MModDir8 | MModDir16 | MModIReg8 | MModIReg | MModReg);
  1881.         switch (AdrMode)
  1882.         {
  1883.           case ModImm:
  1884.             PutCode(0x24);
  1885.             TransferAdrRelocs(CodeLen);
  1886.             BAsmCode[CodeLen++] = AdrVals[0];
  1887.             break;
  1888.           case ModDir8:
  1889.             PutCode(0x25);
  1890.             TransferAdrRelocs(CodeLen);
  1891.             BAsmCode[CodeLen++] = AdrVals[0];
  1892.             break;
  1893.           case ModDir16:
  1894.             PutCode(0x12e);
  1895.             BAsmCode[CodeLen++] = (AccReg << 4) + 3;
  1896.             memcpy(BAsmCode + CodeLen, AdrVals, 2);
  1897.             CodeLen += 2;
  1898.             break;
  1899.           case ModIReg8:
  1900.             PutCode(0x26 + AdrPart);
  1901.             break;
  1902.           case ModIReg:
  1903.             PutCode(0x12e);
  1904.             BAsmCode[CodeLen++] = 0x09 + AdrSize + (AdrPart << 4);
  1905.             BAsmCode[CodeLen++] = AccReg << 4;
  1906.             break;
  1907.           case ModReg:
  1908.             if ((AdrPart < 8) && (!SrcMode)) PutCode(0x28 + AdrPart);
  1909.             else if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  1910.             {
  1911.               PutCode(0x12c);
  1912.               BAsmCode[CodeLen++] = AdrPart + (AccReg << 4);
  1913.             }
  1914.             break;
  1915.         }
  1916.         break;
  1917.       case ModReg:
  1918.         if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  1919.         {
  1920.           HReg = AdrPart;
  1921.           DecodeAdr(&ArgStr[2], MModImm | MModReg | MModDir8 | MModDir16 | MModIReg8 | MModIReg);
  1922.           switch (AdrMode)
  1923.           {
  1924.             case ModImm:
  1925.               if ((OpSize == 0) && (HReg == AccReg))
  1926.               {
  1927.                 PutCode(0x24);
  1928.                 TransferAdrRelocs(CodeLen);
  1929.                 BAsmCode[CodeLen++] = AdrVals[0];
  1930.               }
  1931.               else
  1932.               {
  1933.                 PutCode(0x12e);
  1934.                 BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2);
  1935.                 memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  1936.                 CodeLen += AdrCnt;
  1937.               }
  1938.               break;
  1939.             case ModReg:
  1940.               PutCode(0x12c + OpSize);
  1941.               if (OpSize == 2) BAsmCode[CodeLen - 1]++;
  1942.               BAsmCode[CodeLen++] = (HReg << 4) + AdrPart;
  1943.               break;
  1944.             case ModDir8:
  1945.               if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  1946.               else if ((OpSize == 0) && (HReg == AccReg))
  1947.               {
  1948.                 PutCode(0x25);
  1949.                 TransferAdrRelocs(CodeLen);
  1950.                 BAsmCode[CodeLen++] = AdrVals[0];
  1951.               }
  1952.               else
  1953.               {
  1954.                 PutCode(0x12e);
  1955.                 BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2) + 1;
  1956.                 BAsmCode[CodeLen++] = AdrVals[0];
  1957.               }
  1958.               break;
  1959.             case ModDir16:
  1960.               if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  1961.               else
  1962.               {
  1963.                 PutCode(0x12e);
  1964.                 BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2) + 3;
  1965.                 memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  1966.                 CodeLen += AdrCnt;
  1967.               }
  1968.               break;
  1969.             case ModIReg8:
  1970.               if ((OpSize != 0) || (HReg != AccReg)) WrError(ErrNum_InvAddrMode);
  1971.               else PutCode(0x26 + AdrPart);
  1972.               break;
  1973.             case ModIReg:
  1974.               if (OpSize != 0) WrError(ErrNum_InvAddrMode);
  1975.               else
  1976.               {
  1977.                 PutCode(0x12e);
  1978.                 BAsmCode[CodeLen++] = 0x09 + AdrSize + (AdrPart << 4);
  1979.                 BAsmCode[CodeLen++] = HReg << 4;
  1980.               }
  1981.               break;
  1982.           }
  1983.         }
  1984.         break;
  1985.     }
  1986.   }
  1987. }
  1988.  
  1989. static void DecodeSUBCMP(Word Index)
  1990. {
  1991.   int z;
  1992.   Byte HReg;
  1993.  
  1994.   /* Index: SUB=0 CMP=1 */
  1995.  
  1996.   z = 0x90 + (Index << 5);
  1997.   if (ChkArgCnt(2, 2)
  1998.    && ChkMinCPU(CPU80251))
  1999.   {
  2000.     DecodeAdr(&ArgStr[1], MModReg);
  2001.     switch (AdrMode)
  2002.     {
  2003.       case ModReg:
  2004.         HReg = AdrPart;
  2005.         DecodeAdr(&ArgStr[2], MModImm | MModReg | MModDir8 | MModDir16 | MModIReg | (Index ? MModImmEx : 0));
  2006.         switch (AdrMode)
  2007.         {
  2008.           case ModImm:
  2009.             PutCode(0x10e + z);
  2010.             BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2);
  2011.             TransferAdrRelocs(CodeLen);
  2012.             memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  2013.             CodeLen += AdrCnt;
  2014.             break;
  2015.           case ModImmEx:
  2016.             PutCode(0x10e + z);
  2017.             BAsmCode[CodeLen++] = (HReg << 4) + 0x0c;
  2018.             TransferAdrRelocs(CodeLen);
  2019.             memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  2020.             CodeLen += AdrCnt;
  2021.             break;
  2022.           case ModReg:
  2023.             PutCode(0x10c + z + OpSize);
  2024.             if (OpSize == 2)
  2025.               BAsmCode[CodeLen - 1]++;
  2026.             BAsmCode[CodeLen++] = (HReg << 4) + AdrPart;
  2027.             break;
  2028.           case ModDir8:
  2029.             if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  2030.             else
  2031.             {
  2032.               PutCode(0x10e + z);
  2033.               BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2) + 1;
  2034.               TransferAdrRelocs(CodeLen);
  2035.               BAsmCode[CodeLen++] = AdrVals[0];
  2036.             }
  2037.             break;
  2038.           case ModDir16:
  2039.             if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  2040.             else
  2041.             {
  2042.               PutCode(0x10e + z);
  2043.               BAsmCode[CodeLen++] = (HReg << 4) + (OpSize << 2) + 3;
  2044.               memcpy(BAsmCode + CodeLen, AdrVals, AdrCnt);
  2045.               CodeLen += AdrCnt;
  2046.             }
  2047.             break;
  2048.           case ModIReg:
  2049.             if (OpSize != 0) WrError(ErrNum_InvAddrMode);
  2050.             else
  2051.             {
  2052.               PutCode(0x10e + z);
  2053.               BAsmCode[CodeLen++] = 0x09 + AdrSize + (AdrPart << 4);
  2054.               BAsmCode[CodeLen++] = HReg << 4;
  2055.             }
  2056.             break;
  2057.         }
  2058.         break;
  2059.     }
  2060.   }
  2061. }
  2062.  
  2063. static void DecodeADDCSUBB(Word Index)
  2064. {
  2065.   Byte HReg;
  2066.  
  2067.   /* Index: ADDC=0 SUBB=1 */
  2068.  
  2069.   if (ChkArgCnt(2, 2))
  2070.   {
  2071.     DecodeAdr(&ArgStr[1], MModAcc);
  2072.     switch (AdrMode)
  2073.     {
  2074.       case ModAcc:
  2075.         HReg = 0x30 + (Index*0x60);
  2076.         DecodeAdr(&ArgStr[2], MModReg | MModIReg8 | MModDir8 | MModImm);
  2077.         switch (AdrMode)
  2078.         {
  2079.           case ModReg:
  2080.             if (AdrPart > 7) WrError(ErrNum_InvAddrMode);
  2081.             else
  2082.               PutCode(HReg + 0x08 + AdrPart);
  2083.             break;
  2084.           case ModIReg8:
  2085.             PutCode(HReg + 0x06 + AdrPart);
  2086.             break;
  2087.           case ModDir8:
  2088.             PutCode(HReg + 0x05);
  2089.             TransferAdrRelocs(CodeLen);
  2090.             BAsmCode[CodeLen++] = AdrVals[0];
  2091.             break;
  2092.           case ModImm:
  2093.             PutCode(HReg + 0x04);
  2094.             TransferAdrRelocs(CodeLen);
  2095.             BAsmCode[CodeLen++] = AdrVals[0];
  2096.             break;
  2097.         }
  2098.         break;
  2099.     }
  2100.   }
  2101. }
  2102.  
  2103. static void DecodeINCDEC(Word Index)
  2104. {
  2105.   Byte HReg;
  2106.   int z;
  2107.   Boolean OK;
  2108.   tSymbolFlags Flags;
  2109.  
  2110.   /* Index: INC=0 DEC=1 */
  2111.  
  2112.   z = Index << 4;
  2113.   if (!ChkArgCnt(1, 2));
  2114.   else if ((ArgCnt == 2) && (*ArgStr[2].str.p_str != '#')) WrError(ErrNum_InvAddrMode);
  2115.   else
  2116.   {
  2117.     if (1 == ArgCnt)
  2118.     {
  2119.       HReg = 1;
  2120.       OK = True;
  2121.       Flags = eSymbolFlag_None;
  2122.     }
  2123.     else
  2124.       HReg = EvalStrIntExpressionOffsWithFlags(&ArgStr[2], 1, UInt3, &OK, &Flags);
  2125.     if (mFirstPassUnknown(Flags))
  2126.       HReg = 1;
  2127.     if (OK)
  2128.     {
  2129.       OK = True;
  2130.       if (HReg == 1)
  2131.         HReg = 0;
  2132.       else if (HReg == 2)
  2133.         HReg = 1;
  2134.       else if (HReg == 4)
  2135.         HReg = 2;
  2136.       else
  2137.         OK = False;
  2138.       if (!OK) WrError(ErrNum_OverRange);
  2139.       else if (!as_strcasecmp(ArgStr[1].str.p_str, "DPTR"))
  2140.       {
  2141.         if (Index == 1) WrError(ErrNum_InvAddrMode);
  2142.         else if (HReg != 0) WrError(ErrNum_OverRange);
  2143.         else
  2144.           PutCode(0xa3);
  2145.       }
  2146.       else
  2147.       {
  2148.         DecodeAdr(&ArgStr[1], MModAcc | MModReg | MModDir8 | MModIReg8);
  2149.         switch (AdrMode)
  2150.         {
  2151.           case ModAcc:
  2152.             if (HReg == 0)
  2153.               PutCode(0x04 + z);
  2154.             else if (MomCPU < CPU80251) WrError(ErrNum_OverRange);
  2155.             else
  2156.             {
  2157.               PutCode(0x10b + z);
  2158.               BAsmCode[CodeLen++] = (AccReg << 4) + HReg;
  2159.             }
  2160.             break;
  2161.           case ModReg:
  2162.             if ((OpSize == 0) && (AdrPart == AccReg) && (HReg == 0))
  2163.               PutCode(0x04 + z);
  2164.             else if ((AdrPart < 8) && (OpSize == 0) && (HReg == 0) && (!SrcMode))
  2165.               PutCode(0x08 + z + AdrPart);
  2166.             else if (ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported))
  2167.             {
  2168.               PutCode(0x10b + z);
  2169.               BAsmCode[CodeLen++] = (AdrPart << 4) + (OpSize << 2) + HReg;
  2170.               if (OpSize == 2)
  2171.                 BAsmCode[CodeLen - 1] += 4;
  2172.             }
  2173.             break;
  2174.           case ModDir8:
  2175.             if (HReg != 0) WrError(ErrNum_OverRange);
  2176.             else
  2177.             {
  2178.               PutCode(0x05 + z);
  2179.               TransferAdrRelocs(CodeLen);
  2180.               BAsmCode[CodeLen++] = AdrVals[0];
  2181.             }
  2182.             break;
  2183.           case ModIReg8:
  2184.             if (HReg != 0) WrError(ErrNum_OverRange);
  2185.             else
  2186.               PutCode(0x06 + z + AdrPart);
  2187.             break;
  2188.         }
  2189.       }
  2190.     }
  2191.   }
  2192. }
  2193.  
  2194. static void DecodeMULDIV(Word Index)
  2195. {
  2196.   int z;
  2197.   Byte HReg;
  2198.  
  2199.   /* Index: DIV=0 MUL=1 */
  2200.  
  2201.   z = Index << 5;
  2202.   if (!ChkArgCnt(1, 2));
  2203.   else if (ArgCnt == 1)
  2204.   {
  2205.     if (as_strcasecmp(ArgStr[1].str.p_str, "AB")) WrError(ErrNum_InvAddrMode);
  2206.     else
  2207.       PutCode(0x84 + z);
  2208.   }
  2209.   else
  2210.   {
  2211.     DecodeAdr(&ArgStr[1], MModReg);
  2212.     switch (AdrMode)
  2213.     {
  2214.       case ModReg:
  2215.         HReg = AdrPart;
  2216.         DecodeAdr(&ArgStr[2], MModReg);
  2217.         switch (AdrMode)
  2218.         {
  2219.           case ModReg:
  2220.             if (!ChkMinCPUExt(CPU80251, ErrNum_AddrModeNotSupported));
  2221.             else if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  2222.             else
  2223.             {
  2224.               PutCode(0x18c + z + OpSize);
  2225.               BAsmCode[CodeLen++] = (HReg << 4) + AdrPart;
  2226.             }
  2227.             break;
  2228.         }
  2229.         break;
  2230.     }
  2231.   }
  2232. }
  2233.  
  2234. static void DecodeBits(Word Index)
  2235. {
  2236.   LongInt AdrLong;
  2237.   int z;
  2238.  
  2239.   /* Index: CPL=0 CLR=1 SETB=2 */
  2240.  
  2241.   z = Index << 4;
  2242.   if (!ChkArgCnt(1, 1));
  2243.   else if (!as_strcasecmp(ArgStr[1].str.p_str, "A"))
  2244.   {
  2245.     if (z == 2) WrError(ErrNum_InvAddrMode);
  2246.     else
  2247.       PutCode(0xf4 - z);
  2248.   }
  2249.   else if (IsCarry(ArgStr[1].str.p_str))
  2250.     PutCode(0xb3 + z);
  2251.   else
  2252.     switch (DecodeBitAdr(&ArgStr[1], &AdrLong, True))
  2253.     {
  2254.       case ModBit51:
  2255.         PutCode(0xb2 + z);
  2256.         BAsmCode[CodeLen++] = AdrLong & 0xff;
  2257.         break;
  2258.       case ModBit251:
  2259.         PutCode(0x1a9);
  2260.         BAsmCode[CodeLen++] = 0xb0 + z + (AdrLong >> 24);
  2261.         BAsmCode[CodeLen++] = AdrLong & 0xff;
  2262.         break;
  2263.     }
  2264. }
  2265.  
  2266. static void DecodeShift(Word Index)
  2267. {
  2268.   int z;
  2269.  
  2270.   /* Index: SRA=0 SRL=1 SLL=3 */
  2271.  
  2272.   if (ChkArgCnt(1, 1)
  2273.    && ChkMinCPU(CPU80251))
  2274.   {
  2275.     z = Index << 4;
  2276.     DecodeAdr(&ArgStr[1], MModReg);
  2277.     switch (AdrMode)
  2278.     {
  2279.       case ModReg:
  2280.         if (OpSize == 2) WrError(ErrNum_InvAddrMode);
  2281.         else
  2282.         {
  2283.           PutCode(0x10e + z);
  2284.           BAsmCode[CodeLen++] = (AdrPart << 4) + (OpSize << 2);
  2285.         }
  2286.         break;
  2287.     }
  2288.   }
  2289. }
  2290.  
  2291. static void DecodeCond(Word Index)
  2292. {
  2293.   FixedOrder *FixedZ = CondOrders + Index;
  2294.  
  2295.   if (ChkArgCnt(1, 1)
  2296.    && ChkMinCPU(FixedZ->MinCPU))
  2297.   {
  2298.     tEvalResult EvalResult;
  2299.     LongInt AdrLong = EvalStrIntExpressionWithResult(&ArgStr[1], UInt24, &EvalResult);
  2300.  
  2301.     SubPCRefReloc();
  2302.     if (EvalResult.OK)
  2303.     {
  2304.       AdrLong -= EProgCounter() + 2 + Ord(NeedsPrefix(FixedZ->Code));
  2305.       if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(EvalResult.Flags)) WrError(ErrNum_JmpDistTooBig);
  2306.       else
  2307.       {
  2308.         ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  2309.         PutCode(FixedZ->Code);
  2310.         BAsmCode[CodeLen++] = AdrLong & 0xff;
  2311.       }
  2312.     }
  2313.   }
  2314. }
  2315.  
  2316. static void DecodeBCond(Word Index)
  2317. {
  2318.   FixedOrder *FixedZ = BCondOrders + Index;
  2319.   LongInt AdrLong, BitLong;
  2320.   tEvalResult EvalResult;
  2321.  
  2322.   if (ChkArgCnt(2, 2))
  2323.   {
  2324.     AdrLong = EvalStrIntExpressionWithResult(&ArgStr[2], UInt24, &EvalResult);
  2325.     SubPCRefReloc();
  2326.     if (EvalResult.OK)
  2327.     {
  2328.       ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  2329.       switch (DecodeBitAdr(&ArgStr[1], &BitLong, True))
  2330.       {
  2331.         case ModBit51:
  2332.           AdrLong -= EProgCounter() + 3 + Ord(NeedsPrefix(FixedZ->Code));
  2333.           if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(EvalResult.Flags)) WrError(ErrNum_JmpDistTooBig);
  2334.           else
  2335.           {
  2336.             PutCode(FixedZ->Code);
  2337.             BAsmCode[CodeLen++] = BitLong & 0xff;
  2338.             BAsmCode[CodeLen++] = AdrLong & 0xff;
  2339.           }
  2340.           break;
  2341.         case ModBit251:
  2342.           AdrLong -= EProgCounter() + 4 + Ord(NeedsPrefix(0x1a9));
  2343.           if (((AdrLong < -128) || (AdrLong > 127)) && !mSymbolQuestionable(EvalResult.Flags)) WrError(ErrNum_JmpDistTooBig);
  2344.           else
  2345.           {
  2346.             PutCode(0x1a9);
  2347.             BAsmCode[CodeLen++] = FixedZ->Code + (BitLong >> 24);
  2348.             BAsmCode[CodeLen++] = BitLong & 0xff;
  2349.             BAsmCode[CodeLen++] = AdrLong & 0xff;
  2350.           }
  2351.           break;
  2352.       }
  2353.     }
  2354.   }
  2355. }
  2356.  
  2357. static void DecodeAcc(Word Index)
  2358. {
  2359.   FixedOrder *FixedZ = AccOrders + Index;
  2360.  
  2361.   if (ChkArgCnt(1, 1)
  2362.    && ChkMinCPU(FixedZ->MinCPU))
  2363.   {
  2364.     DecodeAdr(&ArgStr[1], MModAcc);
  2365.     switch (AdrMode)
  2366.     {
  2367.       case ModAcc:
  2368.         PutCode(FixedZ->Code);
  2369.         break;
  2370.     }
  2371.   }
  2372. }
  2373.  
  2374. static void DecodeFixed(Word Index)
  2375. {
  2376.   FixedOrder *FixedZ = FixedOrders + Index;
  2377.  
  2378.   if (ChkArgCnt(0, 0)
  2379.    && ChkMinCPU(FixedZ->MinCPU))
  2380.     PutCode(FixedZ->Code);
  2381. }
  2382.  
  2383.  
  2384. static void DecodeSFR(Word is_sfrb)
  2385. {
  2386.   Word AdrByte;
  2387.   Boolean OK;
  2388.   tSymbolFlags Flags;
  2389.   as_addrspace_t DSeg;
  2390.  
  2391.   if (ChkArgCnt(1, 1))
  2392.   {
  2393.     AdrByte = EvalStrIntExpressionWithFlags(&ArgStr[1], (MomCPU >= CPU80251) ? UInt9 : UInt8, &OK, &Flags);
  2394.     if (OK && !mFirstPassUnknown(Flags))
  2395.     {
  2396.       PushLocHandle(-1);
  2397.       DSeg = (MomCPU >= CPU80251) ? SegIO : SegData;
  2398.       EnterIntSymbol(&LabPart, AdrByte, DSeg, False);
  2399.       if (MakeUseList)
  2400.       {
  2401.         if (AddChunk(SegChunks + DSeg, AdrByte, 1, False))
  2402.           WrError(ErrNum_Overlap);
  2403.       }
  2404.       if (is_sfrb)
  2405.       {
  2406.         Byte BitStart;
  2407.  
  2408.         if (AdrByte > 0x7f)
  2409.         {
  2410.           if ((AdrByte & 7) != 0) WrError(ErrNum_NotBitAddressable);
  2411.           BitStart = AdrByte;
  2412.         }
  2413.         else
  2414.         {
  2415.           if ((AdrByte & 0xe0) != 0x20) WrError(ErrNum_NotBitAddressable);
  2416.           BitStart = (AdrByte - 0x20) << 3;
  2417.         }
  2418.         if (MakeUseList)
  2419.           if (AddChunk(SegChunks + SegBData, BitStart, 8, False)) WrError(ErrNum_Overlap);
  2420.         as_snprintf(ListLine, STRINGSIZE, "=%~02.*u%s-%~02.*u%s",
  2421.                     ListRadixBase, (unsigned)BitStart, GetIntConstIntelSuffix(ListRadixBase),
  2422.                     ListRadixBase, (unsigned)BitStart + 7, GetIntConstIntelSuffix(ListRadixBase));
  2423.       }
  2424.       else
  2425.         as_snprintf(ListLine, STRINGSIZE, "=%~02.*u%s",
  2426.                     ListRadixBase, (unsigned)AdrByte, GetIntConstIntelSuffix(ListRadixBase));
  2427.       PopLocHandle();
  2428.     }
  2429.   }
  2430. }
  2431.  
  2432. static void DecodeBIT(Word Index)
  2433. {
  2434.   LongInt AdrLong;
  2435.   UNUSED(Index);
  2436.  
  2437.   if (!ChkArgCnt(1, 1));
  2438.   else if (MomCPU >= CPU80251)
  2439.   {
  2440.     if (DecodeBitAdr(&ArgStr[1], &AdrLong, False) == ModBit251)
  2441.     {
  2442.       PushLocHandle(-1);
  2443.       EnterIntSymbol(&LabPart, AdrLong, SegBData, False);
  2444.       PopLocHandle();
  2445.       *ListLine = '=';
  2446.       DissectBit_251(ListLine + 1, STRINGSIZE - 1, AdrLong);
  2447.     }
  2448.   }
  2449.   else
  2450.   {
  2451.     if (DecodeBitAdr(&ArgStr[1], &AdrLong, False) == ModBit51)
  2452.     {
  2453.       PushLocHandle(-1);
  2454.       EnterIntSymbol(&LabPart, AdrLong, SegBData, False);
  2455.       PopLocHandle();
  2456.       as_snprintf(ListLine, STRINGSIZE, "=%~02.*u%s",
  2457.                   ListRadixBase, (unsigned)AdrLong, GetIntConstIntelSuffix(ListRadixBase));
  2458.     }
  2459.   }
  2460. }
  2461.  
  2462. static void DecodePORT(Word Index)
  2463. {
  2464.   UNUSED(Index);
  2465.  
  2466.   if (ChkMinCPU(CPU80251))
  2467.     CodeEquate(SegIO, 0, 0x1ff);
  2468. }
  2469.  
  2470. /*-------------------------------------------------------------------------*/
  2471. /* dynamische Codetabellenverwaltung */
  2472.  
  2473. static void AddFixed(const char *NName, Word NCode, CPUVar NCPU)
  2474. {
  2475.   order_array_rsv_end(FixedOrders, FixedOrder);
  2476.   FixedOrders[InstrZ].Code = NCode;
  2477.   FixedOrders[InstrZ].MinCPU = NCPU;
  2478.   AddInstTable(InstTable, NName, InstrZ++, DecodeFixed);
  2479. }
  2480.  
  2481. static void AddAcc(const char *NName, Word NCode, CPUVar NCPU)
  2482. {
  2483.   order_array_rsv_end(AccOrders, FixedOrder);
  2484.   AccOrders[InstrZ].Code = NCode;
  2485.   AccOrders[InstrZ].MinCPU = NCPU;
  2486.   AddInstTable(InstTable, NName, InstrZ++, DecodeAcc);
  2487. }
  2488.  
  2489. static void AddCond(const char *NName, Word NCode, CPUVar NCPU)
  2490. {
  2491.   order_array_rsv_end(CondOrders, FixedOrder);
  2492.   CondOrders[InstrZ].Code = NCode;
  2493.   CondOrders[InstrZ].MinCPU = NCPU;
  2494.   AddInstTable(InstTable, NName, InstrZ++, DecodeCond);
  2495. }
  2496.  
  2497. static void AddBCond(const char *NName, Word NCode, CPUVar NCPU)
  2498. {
  2499.   order_array_rsv_end(BCondOrders, FixedOrder);
  2500.   BCondOrders[InstrZ].Code = NCode;
  2501.   BCondOrders[InstrZ].MinCPU = NCPU;
  2502.   AddInstTable(InstTable, NName, InstrZ++, DecodeBCond);
  2503. }
  2504.  
  2505. static void InitFields(void)
  2506. {
  2507.   InstTable = CreateInstTable(203);
  2508.   AddInstTable(InstTable, "MOV"  , 0, DecodeMOV);
  2509.   AddInstTable(InstTable, "ANL"  , 1, DecodeLogic);
  2510.   AddInstTable(InstTable, "ORL"  , 0, DecodeLogic);
  2511.   AddInstTable(InstTable, "XRL"  , 2, DecodeLogic);
  2512.   AddInstTable(InstTable, "MOVC" , 0, DecodeMOVC);
  2513.   AddInstTable(InstTable, "MOVH" , 0, DecodeMOVH);
  2514.   AddInstTable(InstTable, "MOVZ" , 0x00, DecodeMOVZS);
  2515.   AddInstTable(InstTable, "MOVS" , 0x10, DecodeMOVZS);
  2516.   AddInstTable(InstTable, "MOVX" , 0, DecodeMOVX);
  2517.   AddInstTable(InstTable, "POP"  , 1, DecodeStack);
  2518.   AddInstTable(InstTable, "PUSH" , 0, DecodeStack);
  2519.   AddInstTable(InstTable, "PUSHW", 2, DecodeStack);
  2520.   AddInstTable(InstTable, "XCH"  , 0, DecodeXCH);
  2521.   AddInstTable(InstTable, "XCHD" , 0, DecodeXCHD);
  2522.   AddInstTable(InstTable, "AJMP" , 0, DecodeABranch);
  2523.   AddInstTable(InstTable, "ACALL", 1, DecodeABranch);
  2524.   AddInstTable(InstTable, "LJMP" , 0, DecodeLBranch);
  2525.   AddInstTable(InstTable, "LCALL", 1, DecodeLBranch);
  2526.   AddInstTable(InstTable, "EJMP" , 0, DecodeEBranch);
  2527.   AddInstTable(InstTable, "ECALL", 1, DecodeEBranch);
  2528.   AddInstTable(InstTable, "JMP"  , 0, DecodeJMP);
  2529.   AddInstTable(InstTable, "CALL" , 0, DecodeCALL);
  2530.   AddInstTable(InstTable, "DJNZ" , 0, DecodeDJNZ);
  2531.   AddInstTable(InstTable, "CJNE" , 0, DecodeCJNE);
  2532.   AddInstTable(InstTable, "ADD"  , 0, DecodeADD);
  2533.   AddInstTable(InstTable, "SUB"  , 0, DecodeSUBCMP);
  2534.   AddInstTable(InstTable, "CMP"  , 1, DecodeSUBCMP);
  2535.   AddInstTable(InstTable, "ADDC" , 0, DecodeADDCSUBB);
  2536.   AddInstTable(InstTable, "SUBB" , 1, DecodeADDCSUBB);
  2537.   AddInstTable(InstTable, "INC"  , 0, DecodeINCDEC);
  2538.   AddInstTable(InstTable, "DEC"  , 1, DecodeINCDEC);
  2539.   AddInstTable(InstTable, "MUL"  , 1, DecodeMULDIV);
  2540.   AddInstTable(InstTable, "DIV"  , 0, DecodeMULDIV);
  2541.   AddInstTable(InstTable, "CLR"  , 1, DecodeBits);
  2542.   AddInstTable(InstTable, "CPL"  , 0, DecodeBits);
  2543.   AddInstTable(InstTable, "SETB" , 2, DecodeBits);
  2544.   AddInstTable(InstTable, "SRA"  , 0, DecodeShift);
  2545.   AddInstTable(InstTable, "SRL"  , 1, DecodeShift);
  2546.   AddInstTable(InstTable, "SLL"  , 3, DecodeShift);
  2547.   AddInstTable(InstTable, "SFR"  , 0, DecodeSFR);
  2548.   if (MomCPU <= CPU80C390)
  2549.     AddInstTable(InstTable, "SFRB" , 1, DecodeSFR);
  2550.   AddInstTable(InstTable, "BIT"  , 0, DecodeBIT);
  2551.   AddInstTable(InstTable, "PORT" , 0, DecodePORT);
  2552.  
  2553.   InstrZ = 0;
  2554.   AddFixed("NOP" , 0x0000, CPU87C750);
  2555.   AddFixed("RET" , 0x0022, CPU87C750);
  2556.   AddFixed("RETI", 0x0032, CPU87C750);
  2557.   AddFixed("ERET", 0x01aa, CPU80251);
  2558.   AddFixed("TRAP", 0x01b9, CPU80251);
  2559.  
  2560.   InstrZ = 0;
  2561.   AddAcc("DA"  , 0x00d4, CPU87C750);
  2562.   AddAcc("RL"  , 0x0023, CPU87C750);
  2563.   AddAcc("RLC" , 0x0033, CPU87C750);
  2564.   AddAcc("RR"  , 0x0003, CPU87C750);
  2565.   AddAcc("RRC" , 0x0013, CPU87C750);
  2566.   AddAcc("SWAP", 0x00c4, CPU87C750);
  2567.  
  2568.   InstrZ = 0;
  2569.   AddCond("JC"  , 0x0040, CPU87C750);
  2570.   AddCond("JE"  , 0x0168, CPU80251);
  2571.   AddCond("JG"  , 0x0138, CPU80251);
  2572.   AddCond("JLE" , 0x0128, CPU80251);
  2573.   AddCond("JNC" , 0x0050, CPU87C750);
  2574.   AddCond("JNE" , 0x0178, CPU80251);
  2575.   AddCond("JNZ" , 0x0070, CPU87C750);
  2576.   AddCond("JSG" , 0x0118, CPU80251);
  2577.   AddCond("JSGE", 0x0158, CPU80251);
  2578.   AddCond("JSL" , 0x0148, CPU80251);
  2579.   AddCond("JSLE", 0x0108, CPU80251);
  2580.   AddCond("JZ"  , 0x0060, CPU87C750);
  2581.   AddCond("SJMP", 0x0080, CPU87C750);
  2582.  
  2583.   InstrZ = 0;
  2584.   AddBCond("JB" , 0x0020, CPU87C750);
  2585.   AddBCond("JBC", 0x0010, CPU87C750);
  2586.   AddBCond("JNB", 0x0030, CPU87C750);
  2587.  
  2588.   AddInstTable(InstTable, "REG"  , 0, CodeREG);
  2589.   AddIntelPseudo(InstTable, eIntPseudoFlag_DynEndian);
  2590. }
  2591.  
  2592. static void DeinitFields(void)
  2593. {
  2594.   DestroyInstTable(InstTable);
  2595.   order_array_free(FixedOrders);
  2596.   order_array_free(AccOrders);
  2597.   order_array_free(CondOrders);
  2598.   order_array_free(BCondOrders);
  2599. }
  2600.  
  2601. /*-------------------------------------------------------------------------*/
  2602. /* Instruktionsdecoder */
  2603.  
  2604. static void MakeCode_51(void)
  2605. {
  2606.   OpSize = eSymbolSizeUnknown;
  2607.   MinOneIs0 = False;
  2608.  
  2609.   /* zu ignorierendes */
  2610.  
  2611.   if (*OpPart.str.p_str == '\0') return;
  2612.  
  2613.   /* suchen */
  2614.  
  2615.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  2616.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  2617. }
  2618.  
  2619. static Boolean IsDef_51(void)
  2620. {
  2621.   switch (*OpPart.str.p_str)
  2622.   {
  2623.     case 'B':
  2624.       return Memo("BIT");
  2625.     case 'S':
  2626.       if (Memo("SFR")) return True;
  2627.       if (MomCPU >= CPU80251) return False;
  2628.       return Memo("SFRB");
  2629.     case 'P':
  2630.       return (MomCPU >= CPU80251) ? Memo("PORT") : False;
  2631.     case 'R':
  2632.       return Memo("REG");
  2633.     default:
  2634.       return False;
  2635.   }
  2636. }
  2637.  
  2638. /*!------------------------------------------------------------------------
  2639.  * \fn     InternSymbol_51(char *pArg, TempResult *pResult)
  2640.  * \brief  handle built-in symbols on 80x51
  2641.  * \param  pArg source argument
  2642.  * \param  pResult destination buffer
  2643.  * ------------------------------------------------------------------------ */
  2644.  
  2645. static void InternSymbol_51(char *pArg, TempResult *pResult)
  2646. {
  2647.   tRegInt Erg;
  2648.   tSymbolSize Size;
  2649.  
  2650.   if (DecodeRegCore(pArg, &Erg, &Size))
  2651.   {
  2652.     pResult->Typ = TempReg;
  2653.     pResult->DataSize = (tSymbolSize)Size;
  2654.     pResult->Contents.RegDescr.Reg = Erg;
  2655.     pResult->Contents.RegDescr.Dissect = DissectReg_51;
  2656.     pResult->Contents.RegDescr.compare = NULL;
  2657.   }
  2658. }
  2659.  
  2660. static void SwitchTo_51(void)
  2661. {
  2662.   TurnWords = False;
  2663.   SetIntConstMode(eIntConstModeIntel);
  2664.  
  2665.   PCSymbol = "$";
  2666.   HeaderID = 0x31;
  2667.   NOPCode = 0x00;
  2668.   DivideChars = ",";
  2669.   HasAttrs = False;
  2670.  
  2671.   /* C251 is entirely different... */
  2672.  
  2673.   if (MomCPU >= CPU80251)
  2674.   {
  2675.     ValidSegs = (1 << SegCode) | (1 << SegIO);
  2676.     Grans[SegCode ] = 1; ListGrans[SegCode ] = 1; SegInits[SegCode ] = 0;
  2677.     SegLimits[SegCode ] = 0xffffffl;
  2678.     Grans[SegIO   ] = 1; ListGrans[SegIO   ] = 1; SegInits[SegIO   ] = 0;
  2679.     SegLimits[SegIO   ] = 0x1ff;
  2680.     DissectBit = DissectBit_251;
  2681.   }
  2682.  
  2683.   /* rest of the pack... */
  2684.  
  2685.   else
  2686.   {
  2687.     ValidSegs=(1 << SegCode) | (1 << SegData) | (1 << SegIData) | (1 << SegXData) | (1 << SegBData);
  2688.  
  2689.     Grans[SegCode ] = 1; ListGrans[SegCode ] = 1; SegInits[SegCode ] = 0;
  2690.     if (MomCPU == CPU80C390)
  2691.       SegLimits[SegCode ] = 0xffffff;
  2692.     else if (MomCPU == CPU87C750)
  2693.       SegLimits[SegCode ] = 0x7ff;
  2694.     else
  2695.       SegLimits[SegCode ] = 0xffff;
  2696.  
  2697.  
  2698.     Grans[SegXData] = 1; ListGrans[SegXData] = 1; SegInits[SegXData] = 0;
  2699.     if (MomCPU == CPU80C390)
  2700.       SegLimits[SegXData] = 0xffffff;
  2701.     else
  2702.       SegLimits[SegXData] = 0xffff;
  2703.  
  2704.     Grans[SegData ] = 1; ListGrans[SegData ] = 1; SegInits[SegData ] = 0x30;
  2705.     SegLimits[SegData ] = 0xff;
  2706.     Grans[SegIData] = 1; ListGrans[SegIData] = 1; SegInits[SegIData] = 0x80;
  2707.     SegLimits[SegIData] = 0xff;
  2708.     Grans[SegBData] = 1; ListGrans[SegBData] = 1; SegInits[SegBData] = 0;
  2709.     SegLimits[SegBData] = 0xff;
  2710.   }
  2711.  
  2712.   MakeCode = MakeCode_51;
  2713.   IsDef = IsDef_51;
  2714.   InternSymbol = InternSymbol_51;
  2715.   DissectReg = DissectReg_51;
  2716.  
  2717.   InitFields();
  2718.   SwitchFrom = DeinitFields;
  2719.   if (!onoff_test_and_set(e_onoff_reg_srcmode))
  2720.     SetFlag(&SrcMode, SrcModeSymName, False);
  2721.   AddONOFF(SrcModeCmdName, &SrcMode, SrcModeSymName, False);
  2722.   onoff_bigendian_add();
  2723. }
  2724.  
  2725. void code51_init(void)
  2726. {
  2727.   CPU87C750 = AddCPU("87C750", SwitchTo_51);
  2728.   CPU8051   = AddCPU("8051"  , SwitchTo_51);
  2729.   CPU8052   = AddCPU("8052"  , SwitchTo_51);
  2730.   CPU80C320 = AddCPU("80C320", SwitchTo_51);
  2731.   CPU80501  = AddCPU("80C501", SwitchTo_51);
  2732.   CPU80502  = AddCPU("80C502", SwitchTo_51);
  2733.   CPU80504  = AddCPU("80C504", SwitchTo_51);
  2734.   CPU80515  = AddCPU("80515" , SwitchTo_51);
  2735.   CPU80517  = AddCPU("80517" , SwitchTo_51);
  2736.   CPU80C390 = AddCPU("80C390", SwitchTo_51);
  2737.   CPU80251  = AddCPU("80C251", SwitchTo_51);
  2738.   CPU80251T = AddCPU("80C251T", SwitchTo_51);
  2739. }
  2740.