Subversion Repositories pentevo

Rev

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

  1. /* codez80.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Zilog Z80/180/380                                           */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <ctype.h>
  13. #include <string.h>
  14.  
  15. #include "nls.h"
  16. #include "strutil.h"
  17. #include "bpemu.h"
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmcode.h"
  22. #include "asmallg.h"
  23. #include "nlmessages.h"
  24. #include "as.rsc"
  25. #include "onoff_common.h"
  26. #include "asmitree.h"
  27. #include "codepseudo.h"
  28. #include "intpseudo.h"
  29. #include "codevars.h"
  30. #include "cpu2phys.h"
  31. #include "function.h"
  32. #include "onoff_common.h"
  33. #include "errmsg.h"
  34.  
  35. #include "codez80.h"
  36.  
  37. /*-------------------------------------------------------------------------*/
  38. /* Praefixtyp */
  39.  
  40. typedef enum
  41. {
  42.   Pref_IN_N, Pref_IN_W, Pref_IB_W, Pref_IW_W, Pref_IB_N,
  43.   Pref_IN_LW, Pref_IB_LW, Pref_IW_LW, Pref_IW_N
  44. } PrefType;
  45.  
  46. typedef enum
  47. {
  48.   ePrefixNone,
  49.   ePrefixW,   /* word processing */
  50.   ePrefixLW,  /* long word processing */
  51.   ePrefixIB,  /* one byte more in argument */
  52.   ePrefixIW   /* one word more in argument */
  53. } tOpPrefix;
  54.  
  55. typedef enum
  56. {
  57.   e_core_sharp,
  58.   e_core_z80,
  59.   e_core_z80u,
  60.   e_core_z180,
  61.   e_core_r2000,
  62.   e_core_ez80,
  63.   e_core_z380
  64. } cpu_core_t;
  65.  
  66. typedef enum
  67. {
  68.   e_core_mask_sharp = 1 << e_core_sharp,
  69.   e_core_mask_z80 = 1 << e_core_z80,
  70.   e_core_mask_z80u = 1 << e_core_z80u,
  71.   e_core_mask_z180 = 1 << e_core_z180,
  72.   e_core_mask_r2000 = 1 << e_core_r2000,
  73.   e_core_mask_ez80 = 1 << e_core_ez80,
  74.   e_core_mask_z380 = 1 << e_core_z380,
  75.   e_core_mask_no_sharp = e_core_mask_z80 | e_core_mask_z80u | e_core_mask_z180 | e_core_mask_r2000 | e_core_mask_ez80 | e_core_mask_z380,
  76.   e_core_mask_all = e_core_mask_sharp | e_core_mask_no_sharp,
  77.   e_core_mask_min_z180 = e_core_mask_z180 | e_core_mask_r2000 | e_core_mask_ez80 | e_core_mask_z380
  78. } cpu_core_mask_t;
  79.  
  80. typedef enum
  81. {
  82.   e_core_flag_none = 0,
  83.   e_core_flag_i_8bit = 1 << 0,
  84.   e_core_flag_no_xio = 1 << 1
  85. } cpu_core_flags_t;
  86.  
  87. typedef struct
  88. {
  89.   const char *p_name;
  90.   cpu_core_t core;
  91.   cpu_core_flags_t core_flags;
  92. } cpu_props_t;
  93.  
  94. #ifdef __cplusplus
  95. # include "codez80.hpp"
  96. #endif
  97.  
  98. #define LWordFlagName  "INLWORDMODE"
  99.  
  100. #define ModNone (-1)
  101. #define ModReg8 1
  102. #define ModReg16 2
  103. #define ModIndReg16 3
  104. #define ModImm 4
  105. #define ModAbs 5
  106. #define ModRef 6
  107. #define ModInt 7
  108. #define ModSPRel 8
  109. #define ModIndReg8 9
  110. #define ModSPAdd 10
  111. #define ModHLInc 11
  112. #define ModHLDec 12
  113. #define ModIOAbs 13
  114. #define ModImmIsAbs 14
  115. #define ModMB 15
  116.  
  117. #define MModReg8 (1 << ModReg8)
  118. #define MModReg16 (1 << ModReg16)
  119. #define MModIndReg16 (1 << ModIndReg16)
  120. #define MModImm (1 << ModImm)
  121. #define MModAbs (1 << ModAbs)
  122. #define MModRef (1 << ModRef)
  123. #define MModInt (1 << ModInt)
  124. #define MModSPRel (1 << ModSPRel)
  125. #define MModIndReg8 (1 << ModIndReg8)
  126. #define MModSPAdd (1 << ModSPAdd)
  127. #define MModHLInc (1 << ModHLInc)
  128. #define MModHLDec (1 << ModHLDec)
  129. #define MModIOAbs (1 << ModIOAbs)
  130. #define MModImmIsAbs (1 << ModImmIsAbs)
  131. #define MModMB (1 << ModMB)
  132.  
  133. /* These masks deliberately omit the (special)
  134.    Sharp/Gameboy addressing modes: */
  135.  
  136. #define MModNoImm (MModReg8 | MModReg16 | MModIndReg16 | MModAbs | MModRef | MModInt | MModSPRel)
  137. #define MModAll (MModReg8 | MModReg16 | MModIndReg16 | MModImm | MModAbs | MModRef | MModInt | MModSPRel)
  138.  
  139. #define IXPrefix 0xdd
  140. #define IYPrefix 0xfd
  141.  
  142. #define AccReg 7
  143. #define MReg 6
  144. #define HReg 4
  145. #define LReg 5
  146.  
  147. #define DEReg 1
  148. #define HLReg 2
  149. #define SPReg 3
  150.  
  151. /*-------------------------------------------------------------------------*/
  152. /* Instruktionsgruppendefinitionen */
  153.  
  154. typedef struct
  155. {
  156.   cpu_core_mask_t core_mask;
  157.   Word Code;
  158. } BaseOrder;
  159.  
  160. typedef struct
  161. {
  162.   const char *Name;
  163.   Byte Code;
  164. } Condition;
  165.  
  166. /*-------------------------------------------------------------------------*/
  167.  
  168. static Byte PrefixCnt;
  169. static Byte AdrPart, OpSize;
  170. static LongWord AdrVal;
  171. static LongWord adr_val_flags;
  172. static Byte AdrVals[4];
  173. static ShortInt AdrMode;
  174.  
  175. static BaseOrder *FixedOrders;
  176. static BaseOrder *AccOrders;
  177. static BaseOrder *HLOrders;
  178. static Condition *Conditions;
  179.  
  180. static const cpu_props_t *p_curr_cpu_props;
  181.  
  182. #define is_sharp() (p_curr_cpu_props->core == e_core_sharp)
  183. #define is_z80u() (p_curr_cpu_props->core == e_core_z80u)
  184. #define is_z180() (p_curr_cpu_props->core == e_core_z180)
  185. #define is_r2000() (p_curr_cpu_props->core == e_core_r2000)
  186. #define is_ez80() (p_curr_cpu_props->core == e_core_ez80)
  187. #define is_z380() (p_curr_cpu_props->core == e_core_z380)
  188.  
  189. static Boolean MayLW,             /* Instruktion erlaubt 32 Bit */
  190.                ExtFlag,           /* Prozessor im 4GByte-Modus ? */
  191.                LWordFlag;         /* 32-Bit-Verarbeitung ? */
  192.  
  193. static PrefType CurrPrefix,       /* mom. explizit erzeugter Praefix */
  194.                 LastPrefix;       /* von der letzten Anweisung generierter Praefix */
  195.  
  196. static LongInt Reg_CBAR,
  197.                Reg_BBR,
  198.                Reg_CBR,
  199.                Reg_ADL,
  200.                Reg_MBASE;
  201. static const char Reg8Names[] = "BCDEHL*A";
  202. static int Reg16Cnt;
  203. static const char Reg16Names[][3] = { "BC", "DE", "HL", "SP", "IX", "IY" };
  204.  
  205. /*--------------------------------------------------------------------------*/
  206. /* Praefix dazuaddieren */
  207.  
  208. static tOpPrefix DecodePrefix(const char *pArg)
  209. {
  210.   const char *pPrefNames[] = { "W", "LW", "IB", "IW", NULL };
  211.   tOpPrefix Result;
  212.  
  213.   for (Result = ePrefixW; pPrefNames[Result - 1]; Result++)
  214.     if (!as_strcasecmp(pArg, pPrefNames[Result - 1]))
  215.       return Result;
  216.   return ePrefixNone;
  217. }
  218.  
  219. static Boolean ExtendPrefix(PrefType *Dest, tOpPrefix AddPrefix)
  220. {
  221.   Byte SPart,IPart;
  222.  
  223.   switch (*Dest)
  224.   {
  225.     case Pref_IB_N:
  226.     case Pref_IB_W:
  227.     case Pref_IB_LW:
  228.       IPart = 1;
  229.       break;
  230.     case Pref_IW_N:
  231.     case Pref_IW_W:
  232.     case Pref_IW_LW:
  233.       IPart = 2;
  234.       break;
  235.     default:
  236.       IPart = 0;
  237.   }
  238.  
  239.   switch (*Dest)
  240.   {
  241.     case Pref_IN_W:
  242.     case Pref_IB_W:
  243.     case Pref_IW_W:
  244.       SPart = 1;
  245.       break;
  246.     case Pref_IN_LW:
  247.     case Pref_IB_LW:
  248.     case Pref_IW_LW:
  249.       SPart = 2;
  250.       break;
  251.     default:
  252.       SPart = 0;
  253.   }
  254.  
  255.   switch (AddPrefix)
  256.   {
  257.     case ePrefixW:
  258.       SPart = 1; break;
  259.     case ePrefixLW:
  260.       SPart = 2; break;
  261.     case ePrefixIB:
  262.       IPart = 1; break;
  263.     case ePrefixIW:
  264.       IPart = 2; break;
  265.     default:
  266.       return False;
  267.   }
  268.  
  269.   switch ((IPart << 4) | SPart)
  270.   {
  271.     case 0x00:
  272.       *Dest = Pref_IN_N;
  273.       break;
  274.     case 0x01:
  275.       *Dest = Pref_IN_W;
  276.       break;
  277.     case 0x02:
  278.       *Dest = Pref_IN_LW;
  279.       break;
  280.     case 0x10:
  281.       *Dest = Pref_IB_N;
  282.       break;
  283.     case 0x11:
  284.       *Dest = Pref_IB_W;
  285.       break;
  286.     case 0x12:
  287.       *Dest = Pref_IB_LW;
  288.       break;
  289.     case 0x20:
  290.       *Dest = Pref_IW_N;
  291.       break;
  292.     case 0x21:
  293.       *Dest = Pref_IW_W;
  294.       break;
  295.     case 0x22:
  296.       *Dest = Pref_IW_LW;
  297.       break;
  298.   }
  299.  
  300.   return True;
  301. }
  302.  
  303. /*--------------------------------------------------------------------------*/
  304. /* Code fuer Praefix bilden */
  305.  
  306. static void GetPrefixCode(PrefType inp, Byte *b1 ,Byte *b2)
  307. {
  308.   int z;
  309.  
  310.   z = ((int)inp) - 1;
  311.   *b1 = 0xdd + ((z & 4) << 3);
  312.   *b2 = 0xc0 + (z & 3);
  313. }
  314.  
  315. /*--------------------------------------------------------------------------*/
  316. /* DD-Praefix addieren, nur EINMAL pro Instruktion benutzen! */
  317.  
  318. static void ChangeDDPrefix(tOpPrefix Prefix)
  319. {
  320.   PrefType ActPrefix;
  321.   int z;
  322.  
  323.   ActPrefix = LastPrefix;
  324.   if (ExtendPrefix(&ActPrefix, Prefix))
  325.     if (LastPrefix != ActPrefix)
  326.     {
  327.       if (LastPrefix != Pref_IN_N) RetractWords(2);
  328.       for (z = PrefixCnt - 1; z >= 0; z--) BAsmCode[2 + z] = BAsmCode[z];
  329.       PrefixCnt += 2;
  330.       GetPrefixCode(ActPrefix, BAsmCode + 0, BAsmCode + 1);
  331.     }
  332. }
  333.  
  334. /*--------------------------------------------------------------------------*/
  335. /* IX/IY used ? */
  336.  
  337. static Boolean IndexPrefix(void)
  338. {
  339.   return   ((PrefixCnt > 0)
  340.          && ((BAsmCode[PrefixCnt - 1] == IXPrefix)
  341.           || (BAsmCode[PrefixCnt - 1] == IYPrefix)));
  342. }
  343.  
  344. /*--------------------------------------------------------------------------*/
  345. /* Wortgroesse ? */
  346.  
  347. static Boolean InLongMode(void)
  348. {
  349.   switch (LastPrefix)
  350.   {
  351.     case Pref_IN_W:
  352.     case Pref_IB_W:
  353.     case Pref_IW_W:
  354.       return False;
  355.     case Pref_IN_LW:
  356.     case Pref_IB_LW:
  357.     case Pref_IW_LW:
  358.       return MayLW;
  359.     default:
  360.       return LWordFlag && MayLW;
  361.   }
  362. }
  363.  
  364. /*!------------------------------------------------------------------------
  365.  * \fn     check_ez80_mpage(LongWord address, unsigned eval_flags, tSymbolSize op_size, const tStrComp *p_arg)
  366.  * \brief  check whether address is in current 64K Z80 mode page
  367.  * \param  address address to check
  368.  * \param  eval_flags result flags from address evaluation
  369.  * \param  op_size actual address size in code
  370.  * \param  p_arg related source argument
  371.  * ------------------------------------------------------------------------ */
  372.  
  373. static void check_ez80_mpage(LongWord address, unsigned eval_flags, tSymbolSize op_size, const tStrComp *p_arg)
  374. {
  375.   if ((op_size != eSymbolSize24Bit)
  376.    && !mFirstPassUnknownOrQuestionable(eval_flags)
  377.    && (((address >> 16) & 0xff) != (unsigned)Reg_MBASE))
  378.     WrStrErrorPos(ErrNum_InAccPage, p_arg);
  379. }
  380.  
  381. /*!------------------------------------------------------------------------
  382.  * \fn     EvalAbsAdrExpression(const tStrComp *pArg, tEvalResult *pEvalResult)
  383.  * \brief  evaluate absolute address, range is targent-dependant
  384.  * \param  pArg source argument
  385.  * \param  pEvalResult sideband params
  386.  * \return address value
  387.  * ------------------------------------------------------------------------ */
  388.  
  389. static LongWord EvalAbsAdrExpression(const tStrComp *pArg, tEvalResult *pEvalResult)
  390. {
  391.   if (ExtFlag)
  392.     return EvalStrIntExpressionWithResult(pArg, Int32, pEvalResult);
  393.   else if (is_ez80())
  394.   {
  395.     LongWord ret = EvalStrIntExpressionWithResult(pArg, UInt24, pEvalResult);
  396.  
  397.     if (pEvalResult->OK)
  398.       check_ez80_mpage(ret, pEvalResult->Flags, AttrPartOpSize[1], pArg);
  399.     return ret;
  400.   }
  401.   else
  402.     return EvalStrIntExpressionWithResult(pArg, UInt16, pEvalResult);
  403. }
  404.  
  405. /*==========================================================================*/
  406. /* Adressparser */
  407.  
  408. /*!------------------------------------------------------------------------
  409.  * \fn     DecodeReg8Core(const char *p_asc, Byte *p_ret)
  410.  * \brief  parse 8 bit register
  411.  * \param  p_asc source argument
  412.  * \param  p_ret return buffer
  413.  * \return true if valid register name
  414.  * ------------------------------------------------------------------------ */
  415.  
  416. static Boolean DecodeReg8Core(const char *p_asc, Byte *p_ret)
  417. {
  418.   const char *p_pos;
  419.  
  420.   switch (strlen(p_asc))
  421.   {
  422.     case 1:
  423.       p_pos = strchr(Reg8Names, as_toupper(p_asc[0]));
  424.       if (!p_pos)
  425.         return False;
  426.       *p_ret = p_pos - Reg8Names;
  427.       return (*p_ret != 6);
  428.     case 3:
  429.     {
  430.       char ix = toupper(p_asc[1]);
  431.  
  432.       if ((toupper(p_asc[0]) != 'I')
  433.        || ((ix != 'X') && (ix != 'Y')))
  434.         return False;
  435.       switch (toupper(p_asc[2]))
  436.       {
  437.         case 'L':
  438.           *p_ret = 5 | (((ix == 'X') ? IXPrefix : IYPrefix) & 0xf0);
  439.           return True;
  440.         case 'H':
  441.           /* do not allow IXH/IYH on Z380 */
  442.           if (is_z380())
  443.             return False;
  444.           else
  445.             goto ir_high;
  446.         case 'U':
  447.           /* do not allow IXU/IYU on eZ80 */
  448.           if (is_ez80())
  449.             return False;
  450.           else
  451.             goto ir_high;
  452.         ir_high:
  453.           *p_ret = 4 | (((ix == 'X') ? IXPrefix : IYPrefix) & 0xf0);
  454.           return True;
  455.         default:
  456.           return False;
  457.       }
  458.     }  
  459.     default:
  460.       return False;
  461.   }
  462. }
  463.  
  464. /*!------------------------------------------------------------------------
  465.  * \fn     DecodeReg16Core(const char *p_asc, Byte *p_ret)
  466.  * \brief  parse 16 bit register
  467.  * \param  p_asc source argument
  468.  * \param  p_ret return buffer
  469.  * \return true if valid register name
  470.  * ------------------------------------------------------------------------ */
  471.  
  472. static Boolean DecodeReg16Core(const char *p_asc, Byte *p_ret)
  473. {
  474.   int z;
  475.  
  476.   for (z = 0; z < Reg16Cnt; z++)
  477.     if (!as_strcasecmp(p_asc, Reg16Names[z]))
  478.     {
  479.       if (z <= 3)
  480.         *p_ret = z;
  481.       else
  482.         *p_ret = 2 /* = HL */ | (((z == 4) ? IXPrefix : IYPrefix) & 0xf0);
  483.       return True;
  484.     }
  485.   return False;
  486. }
  487.  
  488. /*!------------------------------------------------------------------------
  489.  * \fn     DecodeReg(const tStrComp *p_arg, Byte *p_ret, tSymbolSize *p_size, tSymbolSize req_size, Boolean must_be_reg)
  490.  * \brief  check whether argument is a CPU register or user-defined register alias
  491.  * \param  p_arg argument
  492.  * \param  p_value resulting register # if yes
  493.  * \param  p_size resulting register size if yes
  494.  * \param  req_size requested register size
  495.  * \param  must_be_reg expecting register or maybe not?
  496.  * \return reg eval result
  497.  * ------------------------------------------------------------------------ */
  498.  
  499. static Boolean chk_reg_size(tSymbolSize req_size, tSymbolSize act_size)
  500. {
  501.   return (req_size == eSymbolSizeUnknown)
  502.       || (req_size == act_size);
  503. }
  504.  
  505. static tRegEvalResult DecodeReg(const tStrComp *p_arg, Byte *p_ret, tSymbolSize *p_size, tSymbolSize req_size, Boolean must_be_reg)
  506. {
  507.   tRegEvalResult reg_eval_result;
  508.   tEvalResult eval_result;
  509.   tRegDescr reg_descr;
  510.  
  511.   if (DecodeReg8Core(p_arg->str.p_str, p_ret))
  512.   {
  513.     eval_result.DataSize = eSymbolSize8Bit;
  514.     reg_eval_result = eIsReg;
  515.   }
  516.   else if (DecodeReg16Core(p_arg->str.p_str, p_ret))
  517.   {
  518.     eval_result.DataSize = eSymbolSize16Bit;
  519.     reg_eval_result = eIsReg;
  520.   }
  521.   else
  522.   {
  523.     reg_eval_result = EvalStrRegExpressionAsOperand(p_arg, &reg_descr, &eval_result, eSymbolSizeUnknown, must_be_reg);
  524.     if (reg_eval_result == eIsReg)
  525.       *p_ret = reg_descr.Reg;
  526.   }
  527.  
  528.   if (reg_eval_result == eIsReg)
  529.   {
  530.     if (!chk_reg_size(req_size, eval_result.DataSize))
  531.     {
  532.       WrStrErrorPos(ErrNum_InvOpSize, p_arg);
  533.       reg_eval_result = must_be_reg ? eIsNoReg : eRegAbort;
  534.     }
  535.   }
  536.  
  537.   if (p_size) *p_size = eval_result.DataSize;
  538.   return reg_eval_result;
  539. }
  540.  
  541. static Boolean IsSym(char ch)
  542. {
  543.   return ((ch == '_')
  544.        || ((ch >= '0') && (ch <= '9'))
  545.        || ((ch >= 'A') && (ch <= 'Z'))
  546.        || ((ch >= 'a') && (ch <= 'z')));
  547. }
  548.  
  549. typedef struct
  550. {
  551.   as_eval_cb_data_t cb_data;
  552.   Byte addr_reg;
  553.   tSymbolSize addr_reg_size;
  554. } z80_eval_cb_data_t;
  555.  
  556. DECLARE_AS_EVAL_CB(z80_eval_cb)
  557. {
  558.   z80_eval_cb_data_t *p_z80_eval_cb_data = (z80_eval_cb_data_t*)p_data;
  559.   tSymbolSize this_reg_size;
  560.   Byte this_reg;
  561.  
  562.   /* special case for GameBoy/Sharp: FF00 always allowed, independent of radix: */
  563.  
  564.   if (!as_strcasecmp(p_arg->str.p_str, "FF00"))
  565.   {
  566.     as_tempres_set_int(p_res, 0xff00);
  567.     return e_eval_ok;
  568.   }
  569.  
  570.   switch (DecodeReg(p_arg, &this_reg, &this_reg_size, eSymbolSizeUnknown, False))
  571.   {
  572.     case eIsReg:
  573.       if ((p_z80_eval_cb_data->addr_reg != 0xff)
  574.        || !as_eval_cb_data_stack_plain_add(p_data->p_stack))
  575.       {
  576.         WrStrErrorPos(ErrNum_InvAddrMode, p_arg);
  577.         return e_eval_fail;
  578.       }
  579.       p_z80_eval_cb_data->addr_reg = this_reg;
  580.       p_z80_eval_cb_data->addr_reg_size = this_reg_size;
  581.       as_tempres_set_int(p_res, 0);
  582.       return e_eval_ok;
  583.     case eRegAbort:
  584.       return e_eval_fail;
  585.     default:
  586.        return e_eval_none;
  587.   }
  588. }
  589.  
  590. static void abs_2_adrvals(LongWord address)
  591. {
  592.   AdrVal = address;
  593.   AdrVals[0] = address & 0xff;
  594.   AdrVals[1] = (address >> 8) & 0xff;
  595.   AdrCnt = 2;
  596.  
  597.   /* Z380: prefix needed if address >=64K */
  598.  
  599.   if (ExtFlag && (address > 0xfffful))
  600.   {
  601.     AdrVals[AdrCnt++] = (address >> 16) & 0xff;
  602.     if (address <= 0xfffffful)
  603.       ChangeDDPrefix(ePrefixIB);
  604.     else
  605.     {
  606.       AdrVals[AdrCnt++] = ((address >> 24) & 0xff);
  607.       ChangeDDPrefix(ePrefixIW);
  608.     }
  609.   }
  610.  
  611.   /* eZ80: 24 bits if .IL mode */
  612.  
  613.   else if (is_ez80() && (AttrPartOpSize[1] == eSymbolSize24Bit))
  614.     AdrVals[AdrCnt++] = (address >> 16) & 0xff;
  615. }
  616.  
  617. static ShortInt DecodeAdr(const tStrComp *pArg, unsigned ModeMask)
  618. {
  619.   Integer AdrInt;
  620. #if 0
  621.   int z, l;
  622.   LongInt AdrLong;
  623. #endif
  624.   Boolean OK, is_indirect;
  625.   tEvalResult EvalResult;
  626.  
  627.   AdrMode = ModNone;
  628.   AdrCnt = 0;
  629.   AdrPart = 0;
  630.  
  631.   /* 0. Sonderregister */
  632.  
  633.   if (!as_strcasecmp(pArg->str.p_str, "R"))
  634.   {
  635.     AdrMode = ModRef;
  636.     goto found;
  637.   }
  638.  
  639.   if (!as_strcasecmp(pArg->str.p_str, "I"))
  640.   {
  641.     AdrMode = ModInt;
  642.     goto found;
  643.   }
  644.  
  645.   if (is_ez80() && !as_strcasecmp(pArg->str.p_str, "MB"))
  646.   {
  647.     AdrMode = ModMB;
  648.     goto found;
  649.   }
  650.  
  651.   /* 1. 8/16 bit registers ? */
  652.  
  653.   switch (DecodeReg(pArg, &AdrPart, &EvalResult.DataSize, eSymbolSizeUnknown, False))
  654.   {
  655.     case eRegAbort:
  656.       goto found;
  657.     case eIsReg:
  658.       if (AdrPart & 0xf0)
  659.         BAsmCode[PrefixCnt++] = (AdrPart & 0xf0) | 0x0d;
  660.       AdrPart &= (EvalResult.DataSize == eSymbolSize8Bit) ? 7 : 3;
  661.       AdrMode = (EvalResult.DataSize == eSymbolSize8Bit) ? ModReg8 : ModReg16;
  662.       goto found;
  663.     default:
  664.       break;
  665.   }
  666.  
  667.   /* 2. SP+d8 (Gameboy specific) */
  668.  
  669.   if ((ModeMask & MModSPAdd)
  670.    && (strlen(pArg->str.p_str) >= 4)
  671.    && !as_strncasecmp(pArg->str.p_str, "SP", 2)
  672.    && !IsSym(pArg->str.p_str[2]))
  673.   {
  674.     AdrVals[0] = EvalStrIntExpressionOffs(pArg, 2, SInt8, &OK);
  675.     if (OK)
  676.     {
  677.       AdrCnt = 1;
  678.       AdrMode = ModSPAdd;
  679.     }
  680.     goto found;
  681.   }
  682.  
  683.   /* all types of indirect expressions (...): */
  684.  
  685.   is_indirect = IsIndirect(pArg->str.p_str);
  686.   if (is_indirect || (ModeMask & MModImmIsAbs))
  687.   {
  688.     tStrComp arg;
  689.     tEvalResult disp_eval_result;
  690.     LongInt disp_acc;
  691.     z80_eval_cb_data_t z80_eval_cb_data;
  692.  
  693.     /* strip outer braces and spaces */
  694.  
  695.     StrCompRefRight(&arg, pArg, !!is_indirect);
  696.     StrCompShorten(&arg, !!is_indirect);
  697.     KillPrefBlanksStrCompRef(&arg);
  698.     KillPostBlanksStrComp(&arg);
  699.  
  700.     /* special cases: */
  701.  
  702.     if ((ModeMask & MModHLInc) && (!as_strcasecmp(arg.str.p_str, "HL+") || !as_strcasecmp(arg.str.p_str, "HLI")))
  703.     {
  704.       AdrMode = ModHLInc;
  705.       goto found;
  706.     }
  707.     if ((ModeMask & MModHLDec) && (!as_strcasecmp(arg.str.p_str, "HL-") || !as_strcasecmp(arg.str.p_str, "HLD")))
  708.     {
  709.       AdrMode = ModHLDec;
  710.       goto found;
  711.     }
  712.  
  713.     /* otherwise, walk through the components : */
  714.  
  715.     as_eval_cb_data_ini(&z80_eval_cb_data.cb_data, z80_eval_cb);
  716.     z80_eval_cb_data.addr_reg = 0xff;
  717.     z80_eval_cb_data.addr_reg_size = eSymbolSizeUnknown;
  718.     disp_acc = EvalStrIntExprWithResultAndCallback(&arg, Int32, &disp_eval_result, &z80_eval_cb_data.cb_data);
  719.     if (!disp_eval_result.OK)
  720.       goto found;
  721.  
  722.     /* now we have parsed the expression, see what we can do with it: */
  723.  
  724.     switch (z80_eval_cb_data.addr_reg)
  725.     {
  726.       /* no register: absolute */
  727.       case 0xff:
  728.       {
  729.         LongWord address = disp_acc;
  730.  
  731.         if (ModeMask & MModAbs)
  732.         {
  733.           /* no range checking if Z380 address range is 32 bits - disp_acc is only a 32 bit value */
  734.  
  735.           if (ExtFlag);
  736.           else if (is_ez80())
  737.           {
  738.             if (!mFirstPassUnknownOrQuestionable(disp_eval_result.Flags))
  739.             {
  740.               if (!ChkRangeByType(disp_acc, UInt24, pArg))
  741.                 return AdrMode;
  742.  
  743.               /* .SIL, .SIS: use MBASE as bits 16..24, ignore bits 16.24 from .SIL instruction: */
  744.  
  745.               if (AttrPartOpSize[0] != eSymbolSize24Bit)
  746.                 check_ez80_mpage(disp_acc, disp_eval_result.Flags, AttrPartOpSize[0], pArg);
  747.  
  748.               /* .LIS -> fetch 16 bits, use 0x00 as bits 16..24: */
  749.  
  750.               else if (AttrPartOpSize[1] != eSymbolSize24Bit)
  751.               {
  752.                 if (((disp_acc >> 16) & 0xff) != 0)
  753.                   WrStrErrorPos(ErrNum_InAccPage, pArg);
  754.               }
  755.  
  756.               /* .LIL: linear 24 bit address */
  757.             }
  758.           }
  759.           else
  760.           {
  761.             if (!mFirstPassUnknownOrQuestionable(disp_eval_result.Flags)
  762.              && !ChkRangeByType(disp_acc, UInt16, pArg))
  763.               return AdrMode;
  764.           }
  765.           ChkSpace(SegCode, disp_eval_result.AddrSpaceMask);
  766.           abs_2_adrvals(address);
  767.           AdrVal = address;
  768.           adr_val_flags = disp_eval_result.Flags;
  769.           AdrMode = ModAbs;
  770.           goto found;
  771.         }
  772.         else if (ModeMask & MModIOAbs)
  773.         {
  774.           if (!mFirstPassUnknownOrQuestionable(disp_eval_result.Flags) && !ChkRangeByType(disp_acc, UInt8, pArg))
  775.             return AdrMode;
  776.           ChkSpace(SegIO, disp_eval_result.AddrSpaceMask);
  777.           AdrVals[0] = address & 0xff;
  778.           AdrCnt = 1;
  779.           AdrMode = ModIOAbs;
  780.           goto found;
  781.         }
  782.         else
  783.           goto inv_mode;
  784.       }
  785.  
  786.       case 0:
  787.         if ((z80_eval_cb_data.addr_reg_size != eSymbolSize16Bit) || disp_acc) /* no (B), (BC+d) */
  788.           goto wrong;
  789.         else /* (BC) */
  790.         {
  791.           AdrMode = ModIndReg16;
  792.           AdrPart = 0;
  793.           goto found;
  794.         }
  795.  
  796.       case 1:
  797.         if (z80_eval_cb_data.addr_reg_size == eSymbolSize16Bit) /* (DE) */
  798.         {
  799.           if (disp_acc)
  800.             goto wrong;
  801.           AdrMode = ModIndReg16;
  802.           AdrPart = 1;
  803.           goto found;
  804.         }
  805.         else /* (C), (FF00+C) on Sharp/GB */
  806.         {
  807.           if (!disp_acc || (is_sharp() && (disp_acc == 0xff00)))
  808.           {
  809.             AdrMode = ModIndReg8;
  810.             goto found;
  811.           }
  812.           else
  813.             goto wrong;
  814.         }
  815.  
  816.       case 2:
  817.         if ((z80_eval_cb_data.addr_reg_size != eSymbolSize16Bit) || disp_acc) /* no (D), (HL+d) */
  818.           goto wrong;
  819.         else /* (HL) */
  820.         {
  821.           AdrMode = ModReg8; /* (HL) is M-Reg */
  822.           AdrPart = 6;
  823.           goto found;
  824.         }
  825.  
  826.       case (IXPrefix & 0xf0) | 2: /* (IX+d) */
  827.       case (IYPrefix & 0xf0) | 2: /* (IY+d) */
  828.       case 3: /* (SP+d) */
  829.         if (!mFirstPassUnknownOrQuestionable(disp_eval_result.Flags) && !ChkRangeByType(disp_acc, is_z380() ? SInt24 : SInt8, pArg))
  830.           return AdrMode;
  831.         if (z80_eval_cb_data.addr_reg == 3)
  832.           AdrMode = ModSPRel;
  833.         else
  834.         {
  835.           AdrMode = ModReg8;
  836.           AdrPart = 6;
  837.           BAsmCode[PrefixCnt++] = 0x0d | (z80_eval_cb_data.addr_reg & 0xf0);
  838.         }
  839.         AdrVals[0] = disp_acc & 0xff;
  840.         AdrCnt = 1;
  841.         if (((disp_acc < -0x80l) || (disp_acc > 0x7fl)) && is_z380())
  842.         {
  843.           AdrVals[AdrCnt++] = (disp_acc >> 8) & 0xff;
  844.           if ((disp_acc >= -0x8000l) && (disp_acc <= 0x7fffl))
  845.             ChangeDDPrefix(ePrefixIB);
  846.           else
  847.           {
  848.             AdrVals[AdrCnt++] = (disp_acc >> 16) & 0xff;
  849.             ChangeDDPrefix(ePrefixIW);
  850.           }
  851.         }
  852.         goto found;
  853.  
  854.       wrong:
  855.       default:
  856.         WrStrErrorPos(ErrNum_InvAddrMode, pArg);
  857.         return AdrMode;
  858.     }
  859.   }
  860.  
  861.   /* ...immediate */
  862.  
  863.   if (!(ModeMask & MModImm))
  864.     goto inv_mode;
  865.   switch (OpSize)
  866.   {
  867.     case 0xff:
  868.       if (ModeMask & MModImm)
  869.         WrError(ErrNum_UndefOpSizes);
  870.       else
  871.         AdrMode = ModImm;  /* will fail on test @ label found */
  872.       break;
  873.     case eSymbolSize8Bit:
  874.       AdrVals[0] = EvalStrIntExpression(pArg, Int8, &OK);
  875.       if (OK)
  876.       {
  877.         AdrMode = ModImm;
  878.         AdrCnt = 1;
  879.       }
  880.       break;
  881.     case eSymbolSize16Bit:
  882.       if (InLongMode())
  883.       {
  884.         LongWord ImmVal = EvalStrIntExpression(pArg, Int32, &OK);
  885.         if (OK)
  886.         {
  887.           AdrVals[0] = Lo(ImmVal);
  888.           AdrVals[1] = Hi(ImmVal);
  889.           AdrMode = ModImm;
  890.           AdrCnt = 2;
  891.           if (ImmVal <= 0xfffful);
  892.           else
  893.           {
  894.             AdrVals[AdrCnt++] = (ImmVal >> 16) & 0xff;
  895.             if (ImmVal <= 0xfffffful)
  896.               ChangeDDPrefix(ePrefixIB);
  897.             else
  898.             {
  899.               AdrVals[AdrCnt++] = (ImmVal >> 24) & 0xff;
  900.               ChangeDDPrefix(ePrefixIW);
  901.             }
  902.           }
  903.         }
  904.       }
  905.       else if (is_ez80() && AttrPartOpSize[1] == eSymbolSize24Bit)
  906.       {
  907.         LongWord ImmVal = EvalStrIntExpression(pArg, Int24, &OK);
  908.         if (OK)
  909.         {
  910.           AdrVals[0] = (ImmVal >>  0) & 0xff;
  911.           AdrVals[1] = (ImmVal >>  8) & 0xff;
  912.           AdrVals[2] = (ImmVal >> 16) & 0xff;
  913.           AdrMode = ModImm;
  914.           AdrCnt = 3;
  915.         }
  916.       }
  917.       else
  918.       {
  919.         AdrInt = EvalStrIntExpression(pArg, Int16, &OK);
  920.         if (OK)
  921.         {
  922.           AdrVals[0] = Lo(AdrInt);
  923.           AdrVals[1] = Hi(AdrInt);
  924.           AdrMode = ModImm;
  925.           AdrCnt = 2;
  926.         }
  927.       }
  928.       break;
  929.   }
  930.  
  931. found:
  932.   if ((AdrMode != ModNone) && !(ModeMask & (1 << AdrMode)))
  933.     goto inv_mode;
  934.   return AdrMode;
  935.  
  936. inv_mode:
  937.   WrStrErrorPos(ErrNum_InvAddrMode, pArg);
  938.   AdrMode = ModNone;
  939.   return AdrMode;
  940. }
  941.  
  942. /*!------------------------------------------------------------------------
  943.  * \fn     DecodeAdr_A(const tStrComp *p_arg)
  944.  * \brief  check whether argument is accumulator (including possible register aliases)
  945.  * \param  p_arg source argument
  946.  * \return True if it is
  947.  * ------------------------------------------------------------------------ */
  948.  
  949. static Boolean DecodeAdr_A(const tStrComp *p_arg)
  950. {
  951.   if (DecodeAdr(p_arg, MModReg8) != ModReg8)
  952.     return False;
  953.   if (AdrPart != AccReg)
  954.   {
  955.     WrStrErrorPos(ErrNum_InvAddrMode, p_arg);
  956.     return False;
  957.   }
  958.   else
  959.     return True;
  960. }
  961.  
  962. /*!------------------------------------------------------------------------
  963.  * \fn     DecodeAdr_HL(const tStrComp *p_arg)
  964.  * \brief  check whether argument is HL (including possible register aliases)
  965.  * \param  p_arg source argument
  966.  * \return True if it is
  967.  * ------------------------------------------------------------------------ */
  968.  
  969. static Boolean DecodeAdr_HL(const tStrComp *p_arg)
  970. {
  971.   if (DecodeAdr(p_arg, MModReg16) != ModReg16)
  972.     return False;
  973.   if ((AdrPart != HLReg) || (PrefixCnt > 0))
  974.   {
  975.     WrStrErrorPos(ErrNum_InvAddrMode, p_arg);
  976.     return False;
  977.   }
  978.   else
  979.     return True;
  980. }
  981.  
  982. /*!------------------------------------------------------------------------
  983.  * \fn     DecodeAdrWithF(const tStrComp *pArg, Boolean AllowF)
  984.  * \brief  Handle address expression, treating F as 8th register
  985.  * \param  pArg source argument
  986.  * \param  allow 'F' at all?
  987.  * ------------------------------------------------------------------------ */
  988.  
  989. static void DecodeAdrWithF(const tStrComp *pArg, Boolean AllowF)
  990. {
  991.   Boolean applies_to_cpu = is_z80u() || is_z180() || is_z380();
  992.  
  993.   if (applies_to_cpu
  994.    && AllowF
  995.    && !as_strcasecmp(pArg->str.p_str, "F"))
  996.   {
  997.     AdrMode = ModReg8;
  998.     AdrPart = 6;
  999.     return;
  1000.   }
  1001.  
  1002.   DecodeAdr(pArg, MModAll);
  1003.  
  1004.   /* if 110 denotes F, it cannot denote (HL) */
  1005.  
  1006.   if (applies_to_cpu
  1007.    && (AdrMode == ModReg8)
  1008.    && (AdrPart == 6))
  1009.   {
  1010.     AdrMode = ModNone;
  1011.     WrStrErrorPos(ErrNum_InvAddrMode, pArg);
  1012.   }
  1013. }
  1014.  
  1015. static Boolean ImmIs8(void)
  1016. {
  1017.   Word tmp;
  1018.  
  1019.   if (AdrCnt < 2)
  1020.     return True;
  1021.  
  1022.   tmp = (Word) AdrVals[AdrCnt - 2];
  1023.  
  1024.   return ((tmp <= 255) || (tmp >= 0xff80));
  1025. }
  1026.  
  1027. static Boolean ImmIsS8(void)
  1028. {
  1029.   Word tmp;
  1030.  
  1031.   if (AdrCnt < 2)
  1032.     return True;
  1033.  
  1034.   tmp = AdrVals[1];
  1035.   tmp = (tmp << 8) | AdrVals[0];
  1036.  
  1037.   return ((tmp <= 127) || (tmp >= 0xff80));
  1038. }
  1039.  
  1040. static void AppendVals(const Byte *pVals, unsigned ValLen)
  1041. {
  1042.   memcpy(BAsmCode + CodeLen, pVals, ValLen);
  1043.   CodeLen += ValLen;
  1044. }
  1045.  
  1046. static void AppendAdrVals(void)
  1047. {
  1048.   AppendVals(AdrVals, AdrCnt);
  1049. }
  1050.  
  1051. static Boolean ParPair(const char *Name1, const char *Name2)
  1052. {
  1053.   return (((!as_strcasecmp(ArgStr[1].str.p_str, Name1)) && (!as_strcasecmp(ArgStr[2].str.p_str, Name2))) ||
  1054.           ((!as_strcasecmp(ArgStr[1].str.p_str, Name2)) && (!as_strcasecmp(ArgStr[2].str.p_str, Name1))));
  1055. }
  1056.  
  1057. /*!------------------------------------------------------------------------
  1058.  * \fn     has_index_prefix(void)
  1059.  * \brief  Check if HL has been replaced by IX/IY via prefix
  1060.  * \return True if yes
  1061.  * ------------------------------------------------------------------------ */
  1062.  
  1063. static Boolean has_index_prefix(void)
  1064. {
  1065.   return (PrefixCnt > 0)
  1066.       && ((BAsmCode[PrefixCnt - 1] == IXPrefix)
  1067.        || (BAsmCode[PrefixCnt - 1] == IYPrefix));
  1068. }
  1069.  
  1070. /*!------------------------------------------------------------------------
  1071.  * \fn     store_prefix(prefix_store_t *p_store, Byte old_prefix_cnt)
  1072.  * \brief  check whether another (index) prefix was added, and store it
  1073.  * \param  p_store place to store
  1074.  * \param  old_prefix_cnt prefix cound before possible addition
  1075.  * ------------------------------------------------------------------------ */
  1076.  
  1077. typedef struct
  1078. {
  1079.   Byte cnt, value;
  1080.   Boolean present;
  1081. } prefix_store_t;
  1082.  
  1083. static void store_prefix(prefix_store_t *p_store, Byte old_prefix_cnt)
  1084. {
  1085.   p_store->cnt = PrefixCnt;
  1086.   p_store->present = p_store->cnt > old_prefix_cnt;
  1087.   p_store->value = p_store->present ? BAsmCode[p_store->cnt - 1] : 0x00;
  1088. }
  1089.  
  1090. /*!------------------------------------------------------------------------
  1091.  * \fn     remove_prefix(int byte_index)
  1092.  * \brief  remove a code prefix
  1093.  * \param  byte_index 0 -> remove last prefix
  1094.  *                    1 -> remove second last prefix
  1095.  * \return value of removed prefix
  1096.  * ------------------------------------------------------------------------ */
  1097.  
  1098. static Byte remove_prefix(int byte_index)
  1099. {
  1100.   Byte ret;
  1101.  
  1102.   if (PrefixCnt < (byte_index + 1))
  1103.     WrError(ErrNum_InternalError);
  1104.   ret = BAsmCode[PrefixCnt - 1 - byte_index];
  1105.   memmove(&BAsmCode[PrefixCnt - 1 - byte_index],
  1106.           &BAsmCode[PrefixCnt     - byte_index],
  1107.           byte_index);
  1108.   PrefixCnt--;
  1109.   return ret;
  1110. }
  1111.  
  1112. /*-------------------------------------------------------------------------*/
  1113. /* Bedingung entschluesseln */
  1114.  
  1115. static Boolean DecodeCondition(const char *Name, int *Erg)
  1116. {
  1117.   int z;
  1118.  
  1119.   for (z = 0; Conditions[z].Name; z++)
  1120.     if (!as_strcasecmp(Conditions[z].Name, Name))
  1121.     {
  1122.       *Erg = Conditions[z].Code;
  1123.       return True;
  1124.     }
  1125.   *Erg = 0;
  1126.   return False;
  1127. }
  1128.  
  1129. /*-------------------------------------------------------------------------*/
  1130. /* Sonderregister dekodieren */
  1131.  
  1132. static Boolean DecodeSFR(char *Inp, Byte *Erg)
  1133. {
  1134.   if (!as_strcasecmp(Inp, "SR"))
  1135.     *Erg = 1;
  1136.   else if (!as_strcasecmp(Inp, "XSR"))
  1137.     *Erg = 5;
  1138.   else if (!as_strcasecmp(Inp, "DSR"))
  1139.     *Erg = 6;
  1140.   else if (!as_strcasecmp(Inp, "YSR"))
  1141.     *Erg = 7;
  1142.   else
  1143.     return False;
  1144.   return True;
  1145. }
  1146.  
  1147. /*==========================================================================*/
  1148. /* Adressbereiche */
  1149.  
  1150. static LargeWord PortEnd(void)
  1151. {
  1152.   if (is_z380())
  1153.     return (LargeWord)IntTypeDefs[ExtFlag ? UInt32 : UInt16].Max;
  1154.   else if (is_ez80())
  1155.     return 0xffff;
  1156.   else
  1157.     return 0xff;
  1158. }
  1159.  
  1160. /*==========================================================================*/
  1161. /* instruction decoders */
  1162.  
  1163. /*!------------------------------------------------------------------------
  1164.  * \fn     chk_addr_ez80_z380(void)
  1165.  * \brief  check for eZ80/Z380 and report invalid addressing mode if not
  1166.  * \return True if condition given
  1167.  * ------------------------------------------------------------------------ */
  1168.  
  1169. static Boolean chk_addr_ez80_z380(void)
  1170. {
  1171.   Boolean ret = is_ez80() || is_z380();
  1172.  
  1173.   if (!ret)
  1174.   {
  1175.     char str[100];
  1176.  
  1177.     as_snprintf(str, sizeof(str), getmessage(Num_ErrMsgMinCPUSupported), "eZ80/Z380");
  1178.     WrXError(ErrNum_AddrModeNotSupported, str);
  1179.   }
  1180.   return ret;
  1181. }
  1182.  
  1183. /*!------------------------------------------------------------------------
  1184.  * \fn     Boolean chk_core_mask(cpu_core_mask_t core_mask)
  1185.  * \brief  check whether current core fulfills requirement
  1186.  * \param  core_mask bit mask of supported cores
  1187.  * \return True if yes
  1188.  * ------------------------------------------------------------------------ */
  1189.  
  1190. static Boolean chk_core_mask(cpu_core_mask_t core_mask)
  1191. {
  1192.   if (!((core_mask >> p_curr_cpu_props->core) & 1))
  1193.   {
  1194.     WrStrErrorPos(ErrNum_InstructionNotSupported, &OpPart);
  1195.     return False;
  1196.   }
  1197.   return True;
  1198. }
  1199.  
  1200. /*!------------------------------------------------------------------------
  1201.  * \fn     Boolean a_chk_core_mask_pos(cpu_core_mask_t core_mask, const tStrComp *p_arg)
  1202.  * \brief  check whether current core fulfills requirement for addressing mode
  1203.  * \param  core_mask bit mask of supported cores
  1204.  * \param  p_arg related source code argument
  1205.  * \return True if yes
  1206.  * ------------------------------------------------------------------------ */
  1207.  
  1208. static Boolean a_chk_core_mask_pos(cpu_core_mask_t core_mask, const tStrComp *p_arg)
  1209. {
  1210.   if (!((core_mask >> p_curr_cpu_props->core) & 1))
  1211.   {
  1212.     WrStrErrorPos(ErrNum_AddrModeNotSupported, p_arg);
  1213.     return False;
  1214.   }
  1215.   return True;
  1216. }
  1217.  
  1218. /*!------------------------------------------------------------------------
  1219.  * \fn     chk_no_core_flags(cpu_core_flags_t flags)
  1220.  * \brief  check that current target does NOT have certain properties
  1221.  * \param  flags flags that must not be set
  1222.  * ------------------------------------------------------------------------ */
  1223.  
  1224. static Boolean chk_no_core_flags(cpu_core_flags_t flags)
  1225. {
  1226.   if (p_curr_cpu_props->core_flags & flags)
  1227.   {
  1228.     WrStrErrorPos(ErrNum_InstructionNotSupported, &OpPart);
  1229.     return False;
  1230.   }
  1231.   return True;
  1232. }
  1233.  
  1234. /*!------------------------------------------------------------------------
  1235.  * \fn     append_to_prefixes(Word code)
  1236.  * \brief  append oe or two byte opcode to existing prefixes
  1237.  * \param  code code to append (2 byte if MSB != 0)
  1238.  * ------------------------------------------------------------------------ */
  1239.  
  1240. static void append_to_prefixes(Word code)
  1241. {
  1242.   if (Hi(code))
  1243.     BAsmCode[PrefixCnt++] = Hi(code);
  1244.   BAsmCode[PrefixCnt++] = Lo(code);
  1245. }
  1246.  
  1247. /*!------------------------------------------------------------------------
  1248.  * \fn     DecodeFixed(Word Index)
  1249.  * \brief  handle instructions without arguments
  1250.  * \param  Index * to instruction description
  1251.  * ------------------------------------------------------------------------ */
  1252.  
  1253. static void DecodeFixed(Word Index)
  1254. {
  1255.   BaseOrder *POrder = FixedOrders + Index;
  1256.  
  1257.   if (ChkArgCnt(0, 0)
  1258.    && chk_core_mask(POrder->core_mask))
  1259.   {
  1260.     append_to_prefixes(POrder->Code);
  1261.     CodeLen = PrefixCnt;
  1262.   }
  1263. }
  1264.  
  1265. /*!------------------------------------------------------------------------
  1266.  * \fn     decode_ez80_xio(Word code)
  1267.  * \brief  handle strin I/O instructions not present on all eZ80 variants
  1268.  * \param  code machine opcode
  1269.  * ------------------------------------------------------------------------ */
  1270.  
  1271. static void decode_ez80_xio(Word code)
  1272. {
  1273.   if (ChkArgCnt(0, 0)
  1274.    && chk_core_mask(e_core_mask_ez80)
  1275.    && chk_no_core_flags(e_core_flag_no_xio))
  1276.   {
  1277.     append_to_prefixes(code);
  1278.     CodeLen = PrefixCnt;
  1279.   }
  1280. }
  1281.  
  1282. /*!------------------------------------------------------------------------
  1283.  * \fn     DecodeAcc(Word Index)
  1284.  * \brief  handle instructions with accumulator as argument
  1285.  * \param  Index * to instruction description
  1286.  * ------------------------------------------------------------------------ */
  1287.  
  1288. static void DecodeAcc(Word Index)
  1289. {
  1290.   BaseOrder *POrder = AccOrders + Index;
  1291.  
  1292.   if (!ChkArgCnt(0, 1)
  1293.    || !chk_core_mask(POrder->core_mask))
  1294.     return;
  1295.  
  1296.   if (ArgCnt && !DecodeAdr_A(&ArgStr[1]))
  1297.     return;
  1298.  
  1299.   append_to_prefixes(POrder->Code);
  1300.   CodeLen = PrefixCnt;
  1301. }
  1302.  
  1303. /*!------------------------------------------------------------------------
  1304.  * \fn     DecodeHL(Word Index)
  1305.  * \brief  handle instructions with HL as argument
  1306.  * \param  Index * to instruction description
  1307.  * ------------------------------------------------------------------------ */
  1308.  
  1309. static void DecodeHL(Word Index)
  1310. {
  1311.   BaseOrder *POrder = HLOrders + Index;
  1312.  
  1313.   if (!ChkArgCnt(0, 1)
  1314.    || !chk_core_mask(POrder->core_mask))
  1315.     return;
  1316.  
  1317.   if (ArgCnt && !DecodeAdr_HL(&ArgStr[1]))
  1318.     return;
  1319.  
  1320.   append_to_prefixes(POrder->Code);
  1321.   CodeLen = PrefixCnt;
  1322. }
  1323.  
  1324. /*!------------------------------------------------------------------------
  1325.  * \fn     DecodeLD(Word IsLDW)
  1326.  * \brief  handle LD(W) instruction
  1327.  * \param  IsLDW LD or LDW?
  1328.  * ------------------------------------------------------------------------ */
  1329.  
  1330. static void DecodeLD(Word IsLDW)
  1331. {
  1332.   Byte AdrByte,HLen;
  1333.   int z;
  1334.   Byte HVals[5];
  1335.  
  1336.   if (ChkArgCnt(2, 2))
  1337.   {
  1338.     unsigned dest_mask;
  1339.  
  1340.     dest_mask = MModReg8 | MModReg16 | MModIndReg16 | MModAbs | MModSPRel;
  1341.     if (is_sharp())
  1342.       dest_mask |= MModIndReg8 | MModHLInc | MModHLDec;
  1343.     else
  1344.       dest_mask |= MModRef | MModInt | (is_ez80() ? MModMB : 0);
  1345.     DecodeAdr(&ArgStr[1], dest_mask);
  1346.     switch (AdrMode)
  1347.     {
  1348.       case ModReg8:
  1349.         if (AdrPart == AccReg) /* LD A, ... */
  1350.         {
  1351.           unsigned src_mask;
  1352.  
  1353.           OpSize = eSymbolSize8Bit;
  1354.           src_mask = MModReg8 | MModReg16 | MModIndReg16 | MModImm | MModAbs | MModSPRel;
  1355.           if (is_sharp())
  1356.             src_mask |= MModIndReg8 | MModHLInc | MModHLDec;
  1357.           else
  1358.             src_mask |= MModRef | MModInt | (is_ez80() ? MModMB : 0);
  1359.           DecodeAdr(&ArgStr[2], src_mask);
  1360.           switch (AdrMode)
  1361.           {
  1362.             case ModReg8: /* LD A, R8/RX8/(HL)/(XY+D) */
  1363.               BAsmCode[PrefixCnt] = 0x78 + AdrPart;
  1364.               memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1365.               CodeLen = PrefixCnt + 1 + AdrCnt;
  1366.               break;
  1367.             case ModIndReg8: /* LD A,(FF00+C) */
  1368.               BAsmCode[0] = 0xf2;
  1369.               CodeLen = 1;
  1370.               break;
  1371.             case ModHLInc: /* LD A,(HLI) */
  1372.               BAsmCode[0] = 0x2a;
  1373.               CodeLen = 1;
  1374.               break;
  1375.             case ModHLDec: /* LD A,(HLD) */
  1376.               BAsmCode[0] = 0x3a;
  1377.               CodeLen = 1;
  1378.               break;
  1379.             case ModIndReg16: /* LD A, (BC)/(DE) */
  1380.               BAsmCode[PrefixCnt++] = 0x0a + (AdrPart << 4);
  1381.               CodeLen = PrefixCnt;
  1382.               break;
  1383.             case ModImm: /* LD A, imm8 */
  1384.               BAsmCode[PrefixCnt++] = 0x3e;
  1385.               BAsmCode[PrefixCnt++] = AdrVals[0];
  1386.               CodeLen = PrefixCnt;
  1387.               break;
  1388.             case ModAbs: /* LD a, (adr) */
  1389.               if (is_sharp() && (AdrVals[1] == 0xff))
  1390.               {
  1391.                 BAsmCode[0] = 0xf0;
  1392.                 BAsmCode[1] = AdrVals[0];
  1393.                 CodeLen = 2;
  1394.               }
  1395.               else
  1396.               {
  1397.                 BAsmCode[PrefixCnt] = is_sharp() ? 0xfa : 0x3a;
  1398.                 memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1399.                 CodeLen = PrefixCnt + 1 + AdrCnt;
  1400.               }
  1401.               break;
  1402.             case ModRef: /* LD A, R */
  1403.               BAsmCode[PrefixCnt++] = 0xed;
  1404.               BAsmCode[PrefixCnt++] = 0x5f;
  1405.               CodeLen = PrefixCnt;
  1406.               break;
  1407.             case ModInt: /* LD A, I */
  1408.               BAsmCode[PrefixCnt++] = 0xed;
  1409.               BAsmCode[PrefixCnt++] = 0x57;
  1410.               CodeLen = PrefixCnt;
  1411.               break;
  1412.             case ModMB: /* LD A, MB */
  1413.               BAsmCode[PrefixCnt++] = 0xed;
  1414.               BAsmCode[PrefixCnt++] = 0x6e;
  1415.               CodeLen = PrefixCnt;
  1416.               break;
  1417.             default:
  1418.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  1419.           }
  1420.         }
  1421.         else if ((AdrPart != MReg) && !has_index_prefix()) /* LD R8, ... */
  1422.         {
  1423.           AdrByte = AdrPart; OpSize = 0; DecodeAdr(&ArgStr[2], MModReg8 | MModImm);
  1424.           switch (AdrMode)
  1425.           {
  1426.             case ModReg8: /* LD R8, R8/RX8/(HL)/(XY+D) */
  1427.               /* if (I(XY)+d) as source, cannot use H/L as target ! */
  1428.               if (((AdrByte == HReg) || (AdrByte == LReg)) && IndexPrefix() && (AdrCnt == 0)) WrError(ErrNum_InvAddrMode);
  1429.               /* LD x,x for x==B...E used as prefixes on eZ80: */
  1430.               else if ((AdrByte < 4) && (AdrPart == AdrByte) && is_ez80())
  1431.               {
  1432.                 WrError(ErrNum_ReplacedByNOP);
  1433.                 BAsmCode[PrefixCnt] = NOPCode;
  1434.                 CodeLen = PrefixCnt + 1;
  1435.               }
  1436.               else
  1437.               {
  1438.                 BAsmCode[PrefixCnt] = 0x40 + (AdrByte << 3) + AdrPart;
  1439.                 memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1440.                 CodeLen = PrefixCnt + 1 + AdrCnt;
  1441.               }
  1442.               break;
  1443.             case ModImm: /* LD R8, imm8 */
  1444.               BAsmCode[0] = 0x06 + (AdrByte << 3); BAsmCode[1] = AdrVals[0];
  1445.               CodeLen = 2;
  1446.               break;
  1447.             default:
  1448.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  1449.           }
  1450.         }
  1451.         else if ((AdrPart == HReg) || (AdrPart == LReg)) /* LD RX8, ... */
  1452.         {
  1453.           AdrByte = AdrPart; OpSize = 0; DecodeAdr(&ArgStr[2], MModAll);
  1454.           switch (AdrMode)
  1455.           {
  1456.             case ModReg8: /* LD RX8, R8/RX8 */
  1457.               if (AdrPart == 6) WrError(ErrNum_InvAddrMode);        /* stopped here */
  1458.               else if ((AdrPart >= 4) && (AdrPart <= 5) && (PrefixCnt != 2)) WrError(ErrNum_InvAddrMode);
  1459.               else if ((AdrPart >= 4) && (AdrPart <= 5) && (BAsmCode[0] != BAsmCode[1])) WrError(ErrNum_InvAddrMode);
  1460.               else
  1461.               {
  1462.                 if (PrefixCnt == 2) PrefixCnt--;
  1463.                 BAsmCode[PrefixCnt] = 0x40 + (AdrByte << 3) + AdrPart;
  1464.                 CodeLen = PrefixCnt + 1;
  1465.               }
  1466.               break;
  1467.             case ModImm: /* LD RX8,imm8 */
  1468.               BAsmCode[PrefixCnt]=0x06+(AdrByte << 3);
  1469.               BAsmCode[PrefixCnt+1]=AdrVals[0];
  1470.               CodeLen=PrefixCnt+2;
  1471.               break;
  1472.             default:
  1473.               if (AdrMode!=ModNone) WrError(ErrNum_InvAddrMode);
  1474.           }
  1475.         }
  1476.         else /* LD (HL)/(XY+d),... */
  1477.         {
  1478.           HLen = AdrCnt;
  1479.           memcpy(HVals, AdrVals, AdrCnt);
  1480.           z = PrefixCnt;
  1481.           if ((z == 0) && (IsLDW))
  1482.           {
  1483.             OpSize = 1;
  1484.             MayLW = True;
  1485.           }
  1486.           else
  1487.             OpSize = 0;
  1488.           DecodeAdr(&ArgStr[2], MModAll);
  1489.           switch (AdrMode)
  1490.           {
  1491.             case ModReg8: /* LD (HL)/(XY+D),R8 */
  1492.               if ((PrefixCnt != z) || (AdrPart == 6)) WrError(ErrNum_InvAddrMode);
  1493.               else
  1494.               {
  1495.                 BAsmCode[PrefixCnt] = 0x70 + AdrPart;
  1496.                 memcpy(BAsmCode + PrefixCnt + 1, HVals, HLen);
  1497.                 CodeLen=PrefixCnt + 1 + HLen;
  1498.               }
  1499.               break;
  1500.             case ModImm: /* LD (HL)/(XY+D),imm8:16:32 */
  1501.               if ((z == 0) && (IsLDW))
  1502.               {
  1503.                 if (chk_core_mask(e_core_mask_z380))
  1504.                 {
  1505.                   BAsmCode[PrefixCnt] = 0xed;
  1506.                   BAsmCode[PrefixCnt + 1] = 0x36;
  1507.                   memcpy(BAsmCode + PrefixCnt + 2, AdrVals, AdrCnt);
  1508.                   CodeLen = PrefixCnt + 2 + AdrCnt;
  1509.                 }
  1510.               }
  1511.               else
  1512.               {
  1513.                 BAsmCode[PrefixCnt] = 0x36;
  1514.                 memcpy(BAsmCode + 1 + PrefixCnt, HVals, HLen);
  1515.                 BAsmCode[PrefixCnt + 1 + HLen] = AdrVals[0];
  1516.                 CodeLen = PrefixCnt + 1 + HLen + AdrCnt;
  1517.               }
  1518.               break;
  1519.             case ModReg16: /* LD (HL)/(XY+D),R16/XY */
  1520.               if (!chk_addr_ez80_z380());
  1521.               else if (AdrPart == SPReg) WrError(ErrNum_InvAddrMode);
  1522.               else if (HLen == 0)
  1523.               {
  1524.                 if (PrefixCnt == z) /* LD (HL),R16 */
  1525.                 {
  1526.                   if ((AdrPart == 2) && is_z380())
  1527.                     AdrPart = 3;
  1528.                   BAsmCode[PrefixCnt] = is_ez80() ? 0xed : 0xfd;
  1529.                   BAsmCode[PrefixCnt + 1] = 0x0f + (AdrPart << 4);
  1530.                   CodeLen = PrefixCnt + 2;
  1531.                 }
  1532.                 else /* LD (HL),XY */
  1533.                 {
  1534.                   if (is_z380())
  1535.                   {
  1536.                     CodeLen = PrefixCnt + 1;
  1537.                     BAsmCode[PrefixCnt] = 0x31;
  1538.                     CodeLen = 1 + PrefixCnt;
  1539.                   }
  1540.                   else /* is_ez80() */
  1541.                   {
  1542.                     Byte index_prefix = remove_prefix(0);
  1543.                     CodeLen = PrefixCnt + 2;
  1544.                     BAsmCode[PrefixCnt] = 0xed;
  1545.                     BAsmCode[PrefixCnt + 1] = (index_prefix == IYPrefix) ? 0x3e : 0x3f;
  1546.                   }
  1547.                 }
  1548.               }
  1549.               else
  1550.               {
  1551.                 if (PrefixCnt == z) /* LD (XY+D),R16 */
  1552.                 {
  1553.                   if (is_z380())
  1554.                   {
  1555.                     if (AdrPart == HLReg)
  1556.                       AdrPart = 3;
  1557.                     BAsmCode[PrefixCnt] = 0xcb;
  1558.                     memcpy(BAsmCode + PrefixCnt + 1, HVals, HLen);
  1559.                     BAsmCode[PrefixCnt + 1 + HLen] = 0x0b + (AdrPart << 4);
  1560.                     CodeLen = PrefixCnt + 1 + HLen + 1;
  1561.                   }
  1562.                   else /* is_ez80() */
  1563.                   {
  1564.                     BAsmCode[PrefixCnt] = 0x0f | (AdrPart << 4);
  1565.                     memcpy(BAsmCode + PrefixCnt + 1, HVals, HLen);
  1566.                     CodeLen = PrefixCnt + 1 + HLen;
  1567.                   }
  1568.                 }
  1569.                 else /* LD (XY+D), IX/Y */
  1570.                 {
  1571.                   if (is_z380())
  1572.                   {
  1573.                     if (BAsmCode[0] == BAsmCode[1]) WrError(ErrNum_InvAddrMode);
  1574.                     else
  1575.                     {
  1576.                       (void)remove_prefix(0);
  1577.                       BAsmCode[PrefixCnt] = 0xcb;
  1578.                       memcpy(BAsmCode + PrefixCnt + 1, HVals, HLen);
  1579.                       BAsmCode[PrefixCnt + 1 + HLen] = 0x2b;
  1580.                       CodeLen = PrefixCnt + 1 + HLen + 1;
  1581.                     }
  1582.                   }
  1583.                   else /* is_ez80() */
  1584.                   {
  1585.                     Byte src_index_prefix = remove_prefix(0);
  1586.                     BAsmCode[PrefixCnt] = (src_index_prefix == IYPrefix) ? 0x3e : 0x3f;
  1587.                     if (BAsmCode[PrefixCnt - 1] == IYPrefix)
  1588.                       BAsmCode[PrefixCnt] ^= 0x01;
  1589.                     memcpy(BAsmCode + PrefixCnt + 1, HVals, HLen);
  1590.                     CodeLen = PrefixCnt + 1 + HLen;
  1591.                   }
  1592.                 }
  1593.               }
  1594.               break;
  1595.             default:
  1596.               if (AdrMode!=ModNone) WrError(ErrNum_InvAddrMode);
  1597.           }
  1598.         }
  1599.         break;
  1600.       case ModReg16:
  1601.         if (AdrPart == SPReg) /* LD SP,... */
  1602.         {
  1603.           OpSize = 1;
  1604.           MayLW = True;
  1605.           DecodeAdr(&ArgStr[2], MModAll);
  1606.           switch (AdrMode)
  1607.           {
  1608.             case ModReg16: /* LD SP,HL/XY */
  1609.               if (AdrPart != 2) WrError(ErrNum_InvAddrMode);
  1610.               else
  1611.               {
  1612.                 BAsmCode[PrefixCnt] = 0xf9;
  1613.                 CodeLen = PrefixCnt + 1;
  1614.               }
  1615.               break;
  1616.             case ModImm: /* LD SP,imm16:32 */
  1617.               BAsmCode[PrefixCnt] = 0x31;
  1618.               memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1619.               CodeLen = PrefixCnt + 1 + AdrCnt;
  1620.               break;
  1621.             case ModAbs: /* LD SP,(adr) */
  1622.               if (a_chk_core_mask_pos(e_core_mask_no_sharp, &ArgStr[2]))
  1623.               {
  1624.                 BAsmCode[PrefixCnt] = 0xed;
  1625.                 BAsmCode[PrefixCnt + 1] = 0x7b;
  1626.                 memcpy(BAsmCode + PrefixCnt + 2, AdrVals, AdrCnt);
  1627.                 CodeLen = PrefixCnt + 2 + AdrCnt;
  1628.               }
  1629.               break;
  1630.             default:
  1631.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  1632.           }
  1633.         }
  1634.         else if (!has_index_prefix()) /* LD R16,... */
  1635.         {
  1636.           unsigned ModeMask = MModAll;
  1637.           unsigned after_dest_prefixcnt = PrefixCnt;
  1638.  
  1639.           AdrByte = (AdrPart == 2) ? 3 : AdrPart;
  1640.           OpSize = 1;
  1641.           MayLW = True;
  1642.           if (is_sharp() && (AdrPart == 2))
  1643.             ModeMask |= MModSPAdd;
  1644.           DecodeAdr(&ArgStr[2], ModeMask);
  1645.           switch (AdrMode)
  1646.           {
  1647.             case ModInt: /* LD HL,I */
  1648.               if (AdrByte != 3) WrError(ErrNum_InvAddrMode);
  1649.               else if (is_z380())
  1650.               {
  1651.                 BAsmCode[0] = 0xdd;
  1652.                 BAsmCode[1] = 0x57;
  1653.                 CodeLen = 2;
  1654.               }
  1655.               else if (is_ez80())
  1656.               {
  1657.                 if (chk_no_core_flags(e_core_flag_i_8bit))
  1658.                 {
  1659.                   BAsmCode[0] = 0xed;
  1660.                   BAsmCode[1] = 0xd7;
  1661.                   CodeLen = 2;
  1662.                 }
  1663.               }
  1664.               break;
  1665.             case ModReg8:
  1666.               if (AdrPart != 6) WrError(ErrNum_InvAddrMode);
  1667.               else if (!is_z380() && !is_ez80()) WrError(ErrNum_InvAddrMode);
  1668.               else if (PrefixCnt == after_dest_prefixcnt) /* LD R16,(HL) */
  1669.               {
  1670.                 if (is_z380())
  1671.                 {
  1672.                   BAsmCode[0] = 0xdd;
  1673.                   BAsmCode[1] = 0x0f + (AdrByte << 4);
  1674.                   CodeLen = 2;
  1675.                 }
  1676.                 else /* if (is_ez80()) */
  1677.                 {
  1678.                   if (AdrByte == 3) AdrByte = 2;
  1679.                   BAsmCode[PrefixCnt] = 0xed;
  1680.                   BAsmCode[PrefixCnt + 1] = 0x07 | (AdrByte << 4);
  1681.                   CodeLen = PrefixCnt + 2;
  1682.                 }
  1683.               }
  1684.               else /* LD R16,(XY+d) */
  1685.               {
  1686.                 if (is_z380())
  1687.                 {
  1688.                   BAsmCode[PrefixCnt] = 0xcb;
  1689.                   memcpy(BAsmCode+PrefixCnt + 1, AdrVals, AdrCnt);
  1690.                   BAsmCode[PrefixCnt + 1 + AdrCnt] = 0x03 + (AdrByte << 4);
  1691.                   CodeLen = PrefixCnt + 1 + AdrCnt + 1;
  1692.                 }
  1693.                 else /* if (is_ez80()) */
  1694.                 {
  1695.                   if (AdrByte == 3) AdrByte = 2;
  1696.                   BAsmCode[PrefixCnt] = 0x07 | (AdrByte << 4);
  1697.                   memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1698.                   CodeLen = PrefixCnt + 1 + AdrCnt;
  1699.                 }
  1700.               }
  1701.               break;
  1702.             case ModReg16:
  1703.               if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  1704.               else if (!chk_core_mask(e_core_mask_z380));
  1705.               else if (PrefixCnt == 0) /* LD R16,R16 */
  1706.               {
  1707.                 if (AdrPart == 2)
  1708.                   AdrPart = 3;
  1709.                 else if (AdrPart == 0)
  1710.                   AdrPart = 2;
  1711.                 BAsmCode[0] = 0xcd + (AdrPart << 4);
  1712.                 BAsmCode[1] = 0x02 + (AdrByte << 4);
  1713.                 CodeLen = 2;
  1714.               }
  1715.               else /* LD R16,XY */
  1716.               {
  1717.                 BAsmCode[PrefixCnt] = 0x0b + (AdrByte << 4);
  1718.                 CodeLen=PrefixCnt + 1;
  1719.               }
  1720.               break;
  1721.             case ModIndReg16: /* LD R16,(R16) */
  1722.               if (chk_core_mask(e_core_mask_z380))
  1723.               {
  1724.                 CodeLen = 2;
  1725.                 BAsmCode[0] = 0xdd;
  1726.                 BAsmCode[1] = 0x0c + (AdrByte << 4) + AdrPart;
  1727.               }
  1728.               break;
  1729.             case ModImm: /* LD R16,imm */
  1730.               if (AdrByte == 3)
  1731.                 AdrByte = 2;
  1732.               CodeLen=PrefixCnt + 1 + AdrCnt;
  1733.               BAsmCode[PrefixCnt] = 0x01 + (AdrByte << 4);
  1734.               memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1735.               break;
  1736.             case ModAbs: /* LD R16,(adr) */
  1737.               if (!a_chk_core_mask_pos(e_core_mask_no_sharp, &ArgStr[2]));
  1738.               else if (AdrByte == 3)
  1739.               {
  1740.                 BAsmCode[PrefixCnt] = 0x2a;
  1741.                 memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1742.                 CodeLen = 1 + PrefixCnt + AdrCnt;
  1743.               }
  1744.               else
  1745.               {
  1746.                 BAsmCode[PrefixCnt] = 0xed;
  1747.                 BAsmCode[PrefixCnt+1] = 0x4b + (AdrByte << 4);
  1748.                 memcpy(BAsmCode + PrefixCnt + 2, AdrVals, AdrCnt);
  1749.                 CodeLen = PrefixCnt + 2 + AdrCnt;
  1750.               }
  1751.               break;
  1752.             case ModSPAdd:
  1753.               BAsmCode[0] = 0xf8;
  1754.               BAsmCode[1] = AdrVals[0];
  1755.               CodeLen = 2;
  1756.               break;
  1757.             case ModSPRel: /* LD R16,(SP+D) */
  1758.               if (chk_core_mask(e_core_mask_z380))
  1759.               {
  1760.                 BAsmCode[PrefixCnt] = 0xdd;
  1761.                 BAsmCode[PrefixCnt + 1] = 0xcb;
  1762.                 memcpy(BAsmCode + PrefixCnt + 2, AdrVals, AdrCnt);
  1763.                 BAsmCode[PrefixCnt + 2 + AdrCnt] = 0x01 + (AdrByte << 4);
  1764.                 CodeLen=PrefixCnt + 3 + AdrCnt;
  1765.               }
  1766.               break;
  1767.             default:
  1768.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  1769.           }
  1770.         }
  1771.         else /* LD XY,... */
  1772.         {
  1773.           OpSize = 1;
  1774.           MayLW = True;
  1775.           DecodeAdr(&ArgStr[2], MModAll);
  1776.           switch (AdrMode)
  1777.           {
  1778.             case ModReg8:
  1779.               if (AdrPart != 6) WrError(ErrNum_InvAddrMode);
  1780.               else if (!is_z380() && !is_ez80()) WrError(ErrNum_InvAddrMode);
  1781.               else if (AdrCnt == 0) /* LD XY,(HL) */
  1782.               {
  1783.                 if (is_z380())
  1784.                 {
  1785.                   BAsmCode[PrefixCnt] = 0x33;
  1786.                   CodeLen = PrefixCnt + 1;
  1787.                 }
  1788.                 else /* is_ez80() */
  1789.                 {
  1790.                   Byte index_prefix = remove_prefix(0);
  1791.                   BAsmCode[PrefixCnt] = 0xed;
  1792.                   BAsmCode[PrefixCnt + 1] = (index_prefix == IYPrefix) ? 0x31 : 0x37;
  1793.                   CodeLen = PrefixCnt + 2;
  1794.                 }
  1795.               }
  1796.               else /* LD XY,(XY+D) */
  1797.               {
  1798.                 if (is_z380())
  1799.                 {
  1800.                   if (BAsmCode[0] == BAsmCode[1]) WrError(ErrNum_InvAddrMode);
  1801.                   else
  1802.                   {
  1803.                     (void)remove_prefix(1);
  1804.                     BAsmCode[PrefixCnt] = 0xcb;
  1805.                     memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1806.                     BAsmCode[PrefixCnt + 1 + AdrCnt] = 0x23;
  1807.                     CodeLen = PrefixCnt + 1 + AdrCnt + 1;
  1808.                   }
  1809.                 }
  1810.                 else
  1811.                 {
  1812.                   Byte dest_index_prefix = remove_prefix(1);
  1813.                   BAsmCode[PrefixCnt] = (dest_index_prefix == IYPrefix) ? 0x31 : 0x37;
  1814.                   if (BAsmCode[PrefixCnt - 1] == IYPrefix)
  1815.                     BAsmCode[PrefixCnt] ^= 0x06;
  1816.                   memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1817.                   CodeLen = PrefixCnt + 1 + AdrCnt;
  1818.                 }
  1819.               }
  1820.               break;
  1821.             case ModReg16:
  1822.               if (!chk_core_mask(e_core_mask_z380));
  1823.               else if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  1824.               else if (PrefixCnt == 1) /* LD XY,R16 */
  1825.               {
  1826.                 if (AdrPart == 2) AdrPart = 3;
  1827.                 CodeLen = 1 + PrefixCnt;
  1828.                 BAsmCode[PrefixCnt] = 0x07 + (AdrPart << 4);
  1829.               }
  1830.               else if (BAsmCode[0] == BAsmCode[1]) WrError(ErrNum_InvAddrMode);
  1831.               else /* LD XY,XY */
  1832.               {
  1833.                 BAsmCode[--PrefixCnt] = 0x27;
  1834.                 CodeLen = 1 + PrefixCnt;
  1835.               }
  1836.               break;
  1837.             case ModIndReg16:
  1838.               if (chk_core_mask(e_core_mask_z380)) /* LD XY,(R16) */
  1839.               {
  1840.                 BAsmCode[PrefixCnt] = 0x03 + (AdrPart << 4);
  1841.                 CodeLen = PrefixCnt + 1;
  1842.               }
  1843.               break;
  1844.             case ModImm: /* LD XY,imm16:32 */
  1845.               BAsmCode[PrefixCnt] = 0x21;
  1846.               memcpy(BAsmCode+PrefixCnt + 1, AdrVals, AdrCnt);
  1847.               CodeLen = PrefixCnt + 1 + AdrCnt;
  1848.               break;
  1849.             case ModAbs: /* LD XY,(adr) */
  1850.               BAsmCode[PrefixCnt] = 0x2a;
  1851.               memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1852.               CodeLen = PrefixCnt + 1 + AdrCnt;
  1853.               break;
  1854.             case ModSPRel: /* LD XY,(SP+D) */
  1855.               if (chk_core_mask(e_core_mask_z380))
  1856.               {
  1857.                 BAsmCode[PrefixCnt] = 0xcb;
  1858.                 memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  1859.                 BAsmCode[PrefixCnt + 1 + AdrCnt] = 0x21;
  1860.                 CodeLen = PrefixCnt + 1 + AdrCnt + 1;
  1861.               }
  1862.               break;
  1863.             default:
  1864.               if (AdrMode!=ModNone) WrError(ErrNum_InvAddrMode);
  1865.           }
  1866.         }
  1867.         break;
  1868.       case ModIndReg8:
  1869.         DecodeAdr(&ArgStr[2], MModReg8);
  1870.         switch (AdrMode)
  1871.         {
  1872.           case ModReg8:
  1873.             if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  1874.             else
  1875.             {
  1876.               BAsmCode[0] = 0xe2;
  1877.               CodeLen = 1;
  1878.             }
  1879.             break;
  1880.           default:
  1881.             break;
  1882.         }
  1883.         break;
  1884.       case ModHLInc:
  1885.         DecodeAdr(&ArgStr[2], MModReg8);
  1886.         switch (AdrMode)
  1887.         {
  1888.           case ModReg8:
  1889.             if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  1890.             else
  1891.             {
  1892.               BAsmCode[0] = 0x22;
  1893.               CodeLen = 1;
  1894.             }
  1895.             break;
  1896.           default:
  1897.             break;
  1898.         }
  1899.         break;
  1900.       case ModHLDec:
  1901.         DecodeAdr(&ArgStr[2], MModReg8);
  1902.         switch (AdrMode)
  1903.         {
  1904.           case ModReg8:
  1905.             if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  1906.             else
  1907.             {
  1908.               BAsmCode[0] = 0x32;
  1909.               CodeLen = 1;
  1910.             }
  1911.             break;
  1912.           default:
  1913.             break;
  1914.         }
  1915.         break;
  1916.       case ModIndReg16:
  1917.         AdrByte = AdrPart;
  1918.         if (IsLDW)
  1919.         {
  1920.           OpSize = 1;
  1921.           MayLW = True;
  1922.         }
  1923.         else
  1924.           OpSize = 0;
  1925.         DecodeAdr(&ArgStr[2], MModAll);
  1926.         switch (AdrMode)
  1927.         {
  1928.           case ModReg8: /* LD (R16),A */
  1929.             if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  1930.             else
  1931.             {
  1932.               CodeLen = PrefixCnt + 1;
  1933.               BAsmCode[PrefixCnt] = 0x02 + (AdrByte << 4);
  1934.             }
  1935.             break;
  1936.           case ModReg16:
  1937.             if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  1938.             else if (!chk_core_mask(e_core_mask_z380));
  1939.             else if (PrefixCnt == 0) /* LD (R16),R16 */
  1940.             {
  1941.               if (AdrPart == 2)
  1942.                 AdrPart = 3;
  1943.               BAsmCode[0] = 0xfd;
  1944.               BAsmCode[1] = 0x0c + AdrByte + (AdrPart << 4);
  1945.               CodeLen = 2;
  1946.             }
  1947.             else /* LD (R16),XY */
  1948.             {
  1949.               CodeLen = PrefixCnt;
  1950.               BAsmCode[CodeLen++] = 0x01 + (AdrByte << 4);
  1951.             }
  1952.             break;
  1953.           case ModImm:
  1954.             if (!IsLDW) WrError(ErrNum_InvAddrMode);
  1955.             else if (chk_core_mask(e_core_mask_z380))
  1956.             {
  1957.               CodeLen = PrefixCnt;
  1958.               BAsmCode[CodeLen++] = 0xed;
  1959.               BAsmCode[CodeLen++] = 0x06 + (AdrByte << 4);
  1960.               AppendAdrVals();
  1961.             }
  1962.             break;
  1963.           default:
  1964.             if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  1965.         }
  1966.         break;
  1967.       case ModAbs:
  1968.         HLen = AdrCnt;
  1969.         memcpy(HVals, AdrVals, AdrCnt);
  1970.         OpSize = 0;
  1971.         DecodeAdr(&ArgStr[2], MModReg8 | MModReg16);
  1972.         switch (AdrMode)
  1973.         {
  1974.           case ModReg8: /* LD (adr),A */
  1975.             if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  1976.             else if (is_sharp() && (HVals[1] == 0xff))
  1977.             {
  1978.               BAsmCode[0] = 0xe0;
  1979.               BAsmCode[1] = HVals[0];
  1980.               CodeLen = 2;
  1981.             }
  1982.             else
  1983.             {
  1984.               CodeLen = PrefixCnt;
  1985.               BAsmCode[CodeLen++] = is_sharp() ? 0xea : 0x32;
  1986.               AppendVals(HVals, HLen);
  1987.             }
  1988.             break;
  1989.           case ModReg16:
  1990.             if ((AdrPart == 3) && is_sharp())
  1991.             {
  1992.               BAsmCode[0] = 0x08;
  1993.               CodeLen = 1;
  1994.             }
  1995.             else if (!a_chk_core_mask_pos(e_core_mask_no_sharp, &ArgStr[1]));
  1996.             else if (AdrPart == 2) /* LD (adr),HL/XY */
  1997.             {
  1998.               CodeLen = PrefixCnt;
  1999.               BAsmCode[CodeLen++] = 0x22;
  2000.               AppendVals(HVals, HLen);
  2001.             }
  2002.             else /* LD (adr),R16 */
  2003.             {
  2004.               CodeLen = PrefixCnt;
  2005.               BAsmCode[CodeLen++] = 0xed;
  2006.               BAsmCode[CodeLen++] = 0x43 + (AdrPart << 4);
  2007.               AppendVals(HVals, HLen);
  2008.             }
  2009.             break;
  2010.           default:
  2011.             if (AdrMode!=ModNone) WrError(ErrNum_InvAddrMode);
  2012.         }
  2013.         break;
  2014.       case ModInt:
  2015.         switch (DecodeAdr(&ArgStr[2], MModReg8 | MModReg16))
  2016.         {
  2017.           case ModReg8: /* LD I,A */
  2018.             if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  2019.             else
  2020.             {
  2021.               CodeLen = 2;
  2022.               BAsmCode[0] = 0xed;
  2023.               BAsmCode[1] = 0x47;
  2024.             }
  2025.             break;
  2026.           case ModReg16: /* LD I,HL */
  2027.             if ((AdrPart != HLReg) || PrefixCnt) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  2028.             else if (is_z380())
  2029.             {
  2030.               CodeLen = 2;
  2031.               BAsmCode[0] = 0xdd;
  2032.               BAsmCode[1] = 0x47;
  2033.             }
  2034.             else if (is_ez80())
  2035.             {
  2036.               if (chk_no_core_flags(e_core_flag_i_8bit))
  2037.               {
  2038.                 CodeLen = 2;
  2039.                 BAsmCode[0] = 0xed;
  2040.                 BAsmCode[1] = 0xc7;
  2041.               }
  2042.             }
  2043.             else
  2044.               WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  2045.             break;
  2046.           default:
  2047.             break;
  2048.         }
  2049.         break;
  2050.       case ModRef:
  2051.         if (DecodeAdr_A(&ArgStr[2])) /* LD R,A */
  2052.         {
  2053.           CodeLen = 2;
  2054.           BAsmCode[0] = 0xed;
  2055.           BAsmCode[1] = 0x4f;
  2056.         }
  2057.         else WrError(ErrNum_InvAddrMode);
  2058.         break;
  2059.       case ModMB:
  2060.         if (DecodeAdr_A(&ArgStr[2])) /* LD MB,A */
  2061.         {
  2062.           CodeLen = 2;
  2063.           BAsmCode[0] = 0xed;
  2064.           BAsmCode[1] = 0x6d;
  2065.         }
  2066.         else WrError(ErrNum_InvAddrMode);
  2067.         break;
  2068.       case ModSPRel:
  2069.         if (chk_core_mask(e_core_mask_z380))
  2070.         {
  2071.           HLen = AdrCnt;
  2072.           memcpy(HVals, AdrVals, AdrCnt);
  2073.           OpSize = 0;
  2074.           DecodeAdr(&ArgStr[2], MModAll);
  2075.           switch (AdrMode)
  2076.           {
  2077.             case ModReg16:
  2078.               if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  2079.               else if (PrefixCnt == 0) /* LD (SP+D),R16 */
  2080.               {
  2081.                 if (AdrPart == 2)
  2082.                   AdrPart = 3;
  2083.                 CodeLen = PrefixCnt;
  2084.                 BAsmCode[CodeLen++] = 0xdd;
  2085.                 BAsmCode[CodeLen++] = 0xcb;
  2086.                 AppendVals(HVals, HLen);
  2087.                 BAsmCode[CodeLen++] = 0x09 + (AdrPart << 4);
  2088.               }
  2089.               else /* LD (SP+D),XY */
  2090.               {
  2091.                 CodeLen = PrefixCnt;
  2092.                 BAsmCode[CodeLen++] = 0xcb;
  2093.                 AppendVals(HVals, HLen);
  2094.                 BAsmCode[CodeLen++] = 0x29;
  2095.               }
  2096.               break;
  2097.             default:
  2098.               if (AdrMode!=ModNone) WrError(ErrNum_InvAddrMode);
  2099.           }
  2100.         }
  2101.         break;
  2102.       default:
  2103.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2104.     }  /* outer switch */
  2105.   }
  2106. }
  2107.  
  2108. /*!------------------------------------------------------------------------
  2109.  * \fn     DecodeLDHL(Word Code)
  2110.  * \brief  decode LDHL instruction (Sharp cores only)
  2111.  * ------------------------------------------------------------------------ */
  2112.  
  2113. static void DecodeLDHL(Word Code)
  2114. {
  2115.   Boolean OK;
  2116.  
  2117.   UNUSED(Code);
  2118.  
  2119.   if (!ChkArgCnt(2, 2)
  2120.    || !chk_core_mask(e_core_mask_sharp))
  2121.     return;
  2122.   DecodeAdr(&ArgStr[1], MModReg16);
  2123.   if (AdrMode != ModReg16)
  2124.     return;
  2125.   if (AdrPart != 3)
  2126.   {
  2127.     WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2128.     return;    
  2129.   }
  2130.   BAsmCode[1] = EvalStrIntExpression(&ArgStr[2], SInt8, &OK);
  2131.   if (OK)
  2132.   {
  2133.     BAsmCode[0] = 0xf8;
  2134.     CodeLen = 2;
  2135.   }
  2136. }
  2137.  
  2138. /*!------------------------------------------------------------------------
  2139.  * \fn     DecodeLDH(Word code)
  2140.  * \brief  Decode LDH instruction (Sharp cores only)
  2141.  * ------------------------------------------------------------------------ */
  2142.  
  2143. static Boolean ChkAbsUpperPage(Byte *p_dest)
  2144. {
  2145.   /* allow just lower byte (00..ff) or full address (ff00..ffff): */
  2146.  
  2147.   if ((AdrCnt == 2) && ((AdrVals[1] == 0x00) || (AdrVals[1] == 0xff)))
  2148.   {
  2149.     *p_dest = AdrVals[0];
  2150.     return True;
  2151.   }
  2152.   else
  2153.     return False;
  2154. }
  2155.  
  2156. static void DecodeLDH(Word code)
  2157. {
  2158.   UNUSED(code);
  2159.  
  2160.   if (!ChkArgCnt(2, 2)
  2161.    || !chk_core_mask(e_core_mask_sharp))
  2162.     return;
  2163.  
  2164.   OpSize = 0;
  2165.   switch (DecodeAdr(&ArgStr[1], MModReg8 | MModIndReg8 | MModAbs))
  2166.   {
  2167.     case ModReg8:
  2168.       if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2169.       else switch (DecodeAdr(&ArgStr[2], MModIndReg8 | MModAbs))
  2170.       {
  2171.         case ModIndReg8:
  2172.           BAsmCode[0] = 0xf2;
  2173.           CodeLen = 1;
  2174.           break;
  2175.         case ModAbs:
  2176.           if (ChkAbsUpperPage(&BAsmCode[1]))
  2177.           {
  2178.             BAsmCode[0] = 0xf0;
  2179.             CodeLen = 2;
  2180.           }
  2181.           break;
  2182.         default:
  2183.           break;
  2184.       }
  2185.       break;
  2186.     case ModIndReg8:
  2187.       if (DecodeAdr_A(&ArgStr[2]))
  2188.       {
  2189.         BAsmCode[0] = 0xe2;
  2190.         CodeLen = 1;
  2191.       }
  2192.       break;
  2193.     case ModAbs:
  2194.       if (ChkAbsUpperPage(&BAsmCode[1]))
  2195.       {
  2196.         if (DecodeAdr_A(&ArgStr[2]))
  2197.         {
  2198.           BAsmCode[0] = 0xe0;
  2199.           CodeLen = 2;
  2200.         }
  2201.       }
  2202.       break;
  2203.     default:
  2204.       break;
  2205.   }
  2206. }
  2207.  
  2208. /*!------------------------------------------------------------------------
  2209.  * \fn     DecodeLDX(Word Code)
  2210.  * \brief  decode LDX instruction (Sharp cores only)
  2211.  * ------------------------------------------------------------------------ */
  2212.  
  2213. static void DecodeLDX(Word Code)
  2214. {
  2215.   UNUSED(Code);
  2216.  
  2217.   if (!ChkArgCnt(2, 2)
  2218.    || !chk_core_mask(e_core_mask_sharp))
  2219.     return;
  2220.   DecodeAdr(&ArgStr[1], MModReg8 | MModAbs);
  2221.   switch (AdrMode)
  2222.   {
  2223.     case ModReg8:
  2224.       if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  2225.       else
  2226.       {
  2227.         DecodeAdr(&ArgStr[2], MModAbs);
  2228.         if (AdrMode == ModAbs)
  2229.         {
  2230.           BAsmCode[0] = 0xfa;
  2231.           memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  2232.           CodeLen = 1 + AdrCnt;
  2233.         }
  2234.       }
  2235.       break;
  2236.     case ModAbs:
  2237.       memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  2238.       DecodeAdr(&ArgStr[2], MModReg8);
  2239.       if (AdrMode == ModReg8)
  2240.       {
  2241.         if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  2242.         else
  2243.         {
  2244.           BAsmCode[0] = 0xea;
  2245.           CodeLen = 3;
  2246.         }
  2247.       }
  2248.       break;
  2249.     default:
  2250.       break;
  2251.   }
  2252. }
  2253.  
  2254. static void DecodeALU8(Word Code)
  2255. {
  2256.   switch (ArgCnt)
  2257.   {
  2258.     case 1:
  2259.       AdrMode = ModReg8;
  2260.       AdrPart = AccReg;
  2261.       AdrCnt = 0;
  2262.       break;
  2263.     case 2:
  2264.       DecodeAdr(&ArgStr[1], MModReg8 | (is_z380() ? MModReg16 : 0));
  2265.       break;
  2266.     default:
  2267.       (void)ChkArgCnt(1, 2);
  2268.       return;
  2269.   }
  2270.  
  2271.   switch (AdrMode)
  2272.   {
  2273.     case ModReg16:
  2274.       if (Code != 2) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2275.       else if (AdrPart == HLReg)
  2276.       {
  2277.         OpSize = 1;
  2278.         if (DecodeAdr(&ArgStr[ArgCnt], MModAbs) == ModAbs)
  2279.         {
  2280.           CodeLen = PrefixCnt;
  2281.           BAsmCode[CodeLen++] = 0xed;
  2282.           BAsmCode[CodeLen++] = 0xd6;
  2283.           AppendAdrVals();
  2284.         }
  2285.       }
  2286.       else if (AdrPart == SPReg)
  2287.       {
  2288.         OpSize = 1;
  2289.         if (DecodeAdr(&ArgStr[ArgCnt], MModImm) == ModImm)
  2290.         {
  2291.           CodeLen = 0;
  2292.           BAsmCode[CodeLen++] = 0xed;
  2293.           BAsmCode[CodeLen++] = 0x92;
  2294.           AppendAdrVals();
  2295.           break;
  2296.         }
  2297.       }
  2298.       else
  2299.         WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2300.       break;
  2301.     case ModReg8:
  2302.       if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2303.       else
  2304.       {
  2305.         OpSize = 0;
  2306.         switch (DecodeAdr(&ArgStr[ArgCnt], MModReg8 | MModImm))
  2307.         {
  2308.           case ModReg8:
  2309.             CodeLen = PrefixCnt + 1 + AdrCnt;
  2310.             BAsmCode[PrefixCnt] = 0x80 + (Code << 3) + AdrPart;
  2311.             memcpy(BAsmCode + PrefixCnt + 1, AdrVals, AdrCnt);
  2312.             break;
  2313.           case ModImm:
  2314.             if (!ImmIs8()) WrStrErrorPos(ErrNum_OverRange, &ArgStr[ArgCnt]);
  2315.             else
  2316.             {
  2317.               CodeLen = 2;
  2318.               BAsmCode[0] = 0xc6 + (Code << 3);
  2319.               BAsmCode[1] = AdrVals[0];
  2320.             }
  2321.             break;
  2322.           default:
  2323.             break;
  2324.         }
  2325.         break;
  2326.       default:
  2327.         break;
  2328.     }
  2329.   }
  2330. }
  2331.  
  2332. static void DecodeALU16(Word Code)
  2333. {
  2334.   if (ChkArgCnt(1, 2)
  2335.    && chk_core_mask(e_core_mask_z380)
  2336.    && ((ArgCnt == 1) || DecodeAdr_HL(&ArgStr[1])))
  2337.   {
  2338.     OpSize = 1; DecodeAdr(&ArgStr[ArgCnt], MModAll);
  2339.     switch (AdrMode)
  2340.     {
  2341.       case ModReg16:
  2342.         if (PrefixCnt > 0)      /* wenn Register, dann nie DDIR! */
  2343.         {
  2344.           BAsmCode[PrefixCnt] = 0x87 + (Code << 3);
  2345.           CodeLen = 1 + PrefixCnt;
  2346.         }
  2347.         else if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  2348.         else
  2349.         {
  2350.           if (AdrPart == 2)
  2351.             AdrPart = 3;
  2352.           BAsmCode[0] = 0xed;
  2353.           BAsmCode[1] = 0x84 + (Code << 3) + AdrPart;
  2354.           CodeLen = 2;
  2355.         }
  2356.         break;
  2357.       case ModReg8:
  2358.         if ((AdrPart != 6) || (AdrCnt == 0)) WrError(ErrNum_InvAddrMode);
  2359.         else
  2360.         {
  2361.           CodeLen = PrefixCnt;
  2362.           BAsmCode[CodeLen++] = 0xc6 + (Code << 3);
  2363.           AppendAdrVals();
  2364.         }
  2365.         break;
  2366.       case ModImm:
  2367.         CodeLen = 0;
  2368.         BAsmCode[CodeLen++] = 0xed;
  2369.         BAsmCode[CodeLen++] = 0x86 + (Code << 3);
  2370.         AppendAdrVals();
  2371.         break;
  2372.       default:
  2373.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2374.     }
  2375.   }
  2376. }
  2377.  
  2378. static void DecodeADD(Word Index)
  2379. {
  2380.   UNUSED(Index);
  2381.  
  2382.   if (ChkArgCnt(2, 2))
  2383.   {
  2384.     Byte raw_prefix_cnt = PrefixCnt;
  2385.  
  2386.     DecodeAdr(&ArgStr[1], MModNoImm);
  2387.     switch (AdrMode)
  2388.     {
  2389.       case ModReg8:
  2390.         if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2391.         else
  2392.         {
  2393.           OpSize = 0; DecodeAdr(&ArgStr[2], MModReg8 | MModImm);
  2394.           switch (AdrMode)
  2395.           {
  2396.             case ModReg8:
  2397.               CodeLen = PrefixCnt;
  2398.               BAsmCode[CodeLen++] = 0x80 + AdrPart;
  2399.               AppendAdrVals();
  2400.               break;
  2401.             case ModImm:
  2402.               CodeLen = PrefixCnt;
  2403.               BAsmCode[CodeLen++] = 0xc6;
  2404.               AppendAdrVals();
  2405.               break;
  2406.             default:
  2407.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2408.           }
  2409.         }
  2410.         break;
  2411.       case ModReg16:
  2412.         if (AdrPart == 3) /* SP */
  2413.         {
  2414.           OpSize = is_z380() ? 1 : 0;
  2415.           DecodeAdr(&ArgStr[2], MModAll);
  2416.           switch (AdrMode)
  2417.           {
  2418.             case ModImm:
  2419.               if (is_z380())
  2420.               {
  2421.                 BAsmCode[0] = 0xed; BAsmCode[1] = 0x82;
  2422.                 memcpy(BAsmCode + 2, AdrVals, AdrCnt);
  2423.                 CodeLen = 2 + AdrCnt;
  2424.                 break;
  2425.               }
  2426.               else if (is_r2000())
  2427.               {
  2428.                 BAsmCode[0] = 0x27; BAsmCode[1] = 0[AdrVals];
  2429.                 CodeLen = 2;
  2430.               }
  2431.               else if (is_sharp())
  2432.               {
  2433.                 if (!ImmIsS8()) WrStrErrorPos(ErrNum_OverRange, &ArgStr[2]);
  2434.                 else
  2435.                 {
  2436.                   BAsmCode[0] = 0xe8;
  2437.                   BAsmCode[1] = 0[AdrVals];
  2438.                   CodeLen = 2;
  2439.                 }
  2440.               }
  2441.               else
  2442.                 WrStrErrorPos(ErrNum_InstructionNotSupported, &OpPart);
  2443.               break;
  2444.             default:
  2445.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2446.           }
  2447.         }
  2448.         else if (AdrPart != 2) WrError(ErrNum_InvAddrMode);
  2449.         else
  2450.         {
  2451.           prefix_store_t dest_prefix;
  2452.           store_prefix(&dest_prefix, raw_prefix_cnt);
  2453.  
  2454.           OpSize = 1; DecodeAdr(&ArgStr[2], MModAll);
  2455.           switch (AdrMode)
  2456.           {
  2457.             case ModReg16:
  2458.             {
  2459.               prefix_store_t src_prefix;
  2460.               store_prefix(&src_prefix, dest_prefix.cnt);
  2461.  
  2462.               if ((AdrPart == 2) && ((dest_prefix.present != src_prefix.present) || (dest_prefix.value != src_prefix.value))) WrError(ErrNum_InvAddrMode);
  2463.               else
  2464.               {
  2465.                 if (dest_prefix.present && src_prefix.present)
  2466.                   PrefixCnt--;
  2467.                 CodeLen = PrefixCnt;
  2468.                 BAsmCode[CodeLen++] = 0x09 + (AdrPart << 4);
  2469.               }
  2470.               break;
  2471.             }
  2472.             case ModAbs:
  2473.               if (dest_prefix.present) WrError(ErrNum_InvAddrMode);
  2474.               else if (chk_core_mask(e_core_mask_z380))
  2475.               {
  2476.                 CodeLen = PrefixCnt;
  2477.                 BAsmCode[CodeLen++] = 0xed;
  2478.                 BAsmCode[CodeLen++] = 0xc2;
  2479.                 AppendAdrVals();
  2480.               }
  2481.               break;
  2482.             default:
  2483.               if (AdrMode!=ModNone) WrError(ErrNum_InvAddrMode);
  2484.           }
  2485.         }
  2486.         break;
  2487.       default:
  2488.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2489.     }
  2490.   }
  2491. }
  2492.  
  2493. static void DecodeADDW(Word Index)
  2494. {
  2495.   UNUSED(Index);
  2496.  
  2497.   if (ChkArgCnt(1, 2)
  2498.    && chk_core_mask(e_core_mask_z380)
  2499.    && ((ArgCnt == 1) || DecodeAdr_HL(&ArgStr[1])))
  2500.   {
  2501.     OpSize = 1; DecodeAdr(&ArgStr[ArgCnt], MModAll);
  2502.     switch (AdrMode)
  2503.     {
  2504.       case ModReg16:
  2505.         if (PrefixCnt > 0)      /* wenn Register, dann nie DDIR! */
  2506.         {
  2507.           BAsmCode[PrefixCnt] = 0x87;
  2508.           CodeLen = 1 + PrefixCnt;
  2509.         }
  2510.         else if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  2511.         else
  2512.         {
  2513.           if (AdrPart == 2)
  2514.             AdrPart = 3;
  2515.           BAsmCode[0] = 0xed;
  2516.           BAsmCode[1] = 0x84 + AdrPart;
  2517.           CodeLen = 2;
  2518.         }
  2519.         break;
  2520.       case ModReg8:
  2521.         if ((AdrPart != 6) || (AdrCnt == 0)) WrError(ErrNum_InvAddrMode);
  2522.         else
  2523.         {
  2524.           CodeLen = PrefixCnt;
  2525.           BAsmCode[CodeLen++] = 0xc6;
  2526.           AppendAdrVals();
  2527.         }
  2528.         break;
  2529.       case ModImm:
  2530.         BAsmCode[0] = 0xed;
  2531.         BAsmCode[1] = 0x86;
  2532.         memcpy(BAsmCode + 2, AdrVals, AdrCnt);
  2533.         CodeLen = 2 + AdrCnt;
  2534.         break;
  2535.       default:
  2536.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2537.     }
  2538.   }
  2539. }
  2540.  
  2541. static void DecodeADC_SBC(Word IsSBC)
  2542. {
  2543.   if (ChkArgCnt(2, 2))
  2544.   {
  2545.     DecodeAdr(&ArgStr[1], MModReg8 | (is_sharp() ? 0 : MModReg16));
  2546.     switch (AdrMode)
  2547.     {
  2548.       case ModReg8:
  2549.         if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2550.         else
  2551.         {
  2552.           OpSize = 0; DecodeAdr(&ArgStr[2], MModReg8 | MModImm);
  2553.           switch (AdrMode)
  2554.           {
  2555.             case ModReg8:
  2556.               CodeLen = PrefixCnt;
  2557.               BAsmCode[CodeLen++] = 0x88 + AdrPart;
  2558.               AppendAdrVals();
  2559.               break;
  2560.             case ModImm:
  2561.               CodeLen = PrefixCnt;
  2562.               BAsmCode[CodeLen++] = 0xce;
  2563.               AppendAdrVals();
  2564.               break;
  2565.             default:
  2566.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2567.           }
  2568.           if ((IsSBC) && (CodeLen != 0))
  2569.             BAsmCode[PrefixCnt] += 0x10;
  2570.         }
  2571.         break;
  2572.       case ModReg16:
  2573.         if ((AdrPart != 2) || has_index_prefix()) WrError(ErrNum_InvAddrMode);
  2574.         else
  2575.         {
  2576.           OpSize = 1; DecodeAdr(&ArgStr[2], MModAll);
  2577.           switch (AdrMode)
  2578.           {
  2579.             case ModReg16:
  2580.               if (has_index_prefix()) WrError(ErrNum_InvAddrMode);
  2581.               else
  2582.               {
  2583.                 CodeLen = PrefixCnt + 2;
  2584.                 BAsmCode[PrefixCnt] = 0xed;
  2585.                 BAsmCode[PrefixCnt + 1] = 0x42 + (AdrPart << 4);
  2586.                 if (!IsSBC)
  2587.                   BAsmCode[PrefixCnt + 1] += 8;
  2588.               }
  2589.               break;
  2590.             default:
  2591.               if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2592.           }
  2593.         }
  2594.         break;
  2595.       default:
  2596.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2597.     }
  2598.   }
  2599. }
  2600.  
  2601. static void DecodeADCW_SBCW(Word Code)
  2602. {
  2603.   if (ChkArgCnt(1, 2)
  2604.    && chk_core_mask(e_core_mask_z380)
  2605.    && ((ArgCnt == 1) || DecodeAdr_HL(&ArgStr[1])))
  2606.   {
  2607.     OpSize = 1; DecodeAdr(&ArgStr[ArgCnt], MModAll);
  2608.     switch (AdrMode)
  2609.     {
  2610.       case ModReg16:
  2611.         if (PrefixCnt > 0)      /* wenn Register, dann nie DDIR! */
  2612.         {
  2613.           BAsmCode[PrefixCnt] = 0x8f + Code;
  2614.           CodeLen = 1 + PrefixCnt;
  2615.         }
  2616.         else if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  2617.         else
  2618.         {
  2619.           if (AdrPart == 2)
  2620.             AdrPart = 3;
  2621.           BAsmCode[0] = 0xed;
  2622.           BAsmCode[1] = 0x8c + Code + AdrPart;
  2623.           CodeLen = 2;
  2624.         }
  2625.         break;
  2626.       case ModReg8:
  2627.         if ((AdrPart != 6) || (AdrCnt == 0)) WrError(ErrNum_InvAddrMode);
  2628.         else
  2629.         {
  2630.           CodeLen = PrefixCnt;
  2631.           BAsmCode[CodeLen++] = 0xce + Code; /* ANSI :-0 */
  2632.           AppendAdrVals();
  2633.         }
  2634.         break;
  2635.       case ModImm:
  2636.         CodeLen = 0;
  2637.         BAsmCode[CodeLen++] = 0xed;
  2638.         BAsmCode[CodeLen++] = 0x8e + Code;
  2639.         AppendAdrVals();
  2640.         break;
  2641.       default:
  2642.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2643.     }
  2644.   }
  2645. }
  2646.  
  2647. static void DecodeINC_DEC(Word Index)
  2648. {
  2649.   Word IsDEC = (Index & 1), IsWord = (Index & 2);
  2650.  
  2651.   if (ChkArgCnt(1, 1))
  2652.   {
  2653.     DecodeAdr(&ArgStr[1], MModReg8 | MModReg16);
  2654.     switch (AdrMode)
  2655.     {
  2656.       case ModReg8:
  2657.         if (IsWord) WrError(ErrNum_InvAddrMode);
  2658.         else
  2659.         {
  2660.           CodeLen = PrefixCnt;
  2661.           BAsmCode[CodeLen++] = 0x04 + (AdrPart << 3) + IsDEC;
  2662.           AppendAdrVals();
  2663.         }
  2664.         break;
  2665.       case ModReg16:
  2666.         CodeLen = PrefixCnt;
  2667.         BAsmCode[CodeLen++] = 0x03 + (AdrPart << 4) + (IsDEC << 3);
  2668.         break;
  2669.       default:
  2670.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2671.     }
  2672.   }
  2673. }
  2674.  
  2675. static void DecodeShift8(Word Code)
  2676. {
  2677.   Byte reg_num = 0;
  2678.   int mem_arg_index;
  2679.  
  2680.   if (!ChkArgCnt(1, is_z80u() ? 2 : 1))
  2681.     return;
  2682.   if ((Code == 6) && !chk_core_mask(e_core_mask_z80u)) /* SLI(A)/SL1/SLS undok. Z80 */
  2683.     return;
  2684.  
  2685.   /* dual arg (Z80 undoc): which is the extra destination register? This must be a 'simple' register (A,B,C,D,E,H,L): */
  2686.  
  2687.   if (ArgCnt >= 2)
  2688.   {
  2689.     if (DecodeReg8Core(ArgStr[1].str.p_str, &reg_num) && !(reg_num & 0xc0))
  2690.       mem_arg_index = 2;
  2691.     else if (DecodeReg8Core(ArgStr[2].str.p_str, &reg_num) && !(reg_num & 0xc0))
  2692.       mem_arg_index = 1;
  2693.     else
  2694.     {
  2695.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  2696.       return;
  2697.     }
  2698.   }
  2699.  
  2700.   /* single arg (documented version): */
  2701.  
  2702.   else
  2703.     mem_arg_index = 1;
  2704.  
  2705.   /* now decode the 'official argument': */
  2706.  
  2707.   OpSize = 0;
  2708.   DecodeAdr(&ArgStr[mem_arg_index], MModReg8);
  2709.   if (AdrMode != ModReg8)
  2710.     return;
  2711.  
  2712.   /* forbid IXL..IYU: */
  2713.  
  2714.   if ((PrefixCnt > 0) && (AdrPart != 6))
  2715.   {
  2716.     WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[mem_arg_index]);
  2717.     return;
  2718.   }
  2719.  
  2720.   /* replace AdrPart for undocumented version.  Addressing mode must be IXd/IYd: */
  2721.  
  2722.   if (ArgCnt >= 2)
  2723.   {
  2724.     if ((AdrPart != 6) || (PrefixCnt != 1))
  2725.     {
  2726.       WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[mem_arg_index]);
  2727.       return;
  2728.     }
  2729.     AdrPart = reg_num;
  2730.   }
  2731.  
  2732.   /* assemble instruction: */
  2733.  
  2734.   CodeLen = PrefixCnt;
  2735.   BAsmCode[CodeLen++] = 0xcb;
  2736.   AppendAdrVals();
  2737.   BAsmCode[CodeLen++] = (Code << 3) | AdrPart;
  2738. }
  2739.  
  2740. static void DecodeShift16(Word Code)
  2741. {
  2742.   if (!ChkArgCnt(1, 1));
  2743.   else if (chk_core_mask(e_core_mask_z380))
  2744.   {
  2745.     OpSize = 1; DecodeAdr(&ArgStr[1], MModNoImm);
  2746.     switch (AdrMode)
  2747.     {
  2748.       case ModReg16:
  2749.         if (PrefixCnt > 0)
  2750.         {
  2751.           BAsmCode[2] = 0x04 + (Code << 3) + ((BAsmCode[0] >> 5) & 1);
  2752.           BAsmCode[0] = 0xed;
  2753.           BAsmCode[1] = 0xcb;
  2754.           CodeLen = 3;
  2755.         }
  2756.         else if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  2757.         else
  2758.         {
  2759.           if (AdrPart == 2)
  2760.             AdrPart = 3;
  2761.           BAsmCode[0] = 0xed;
  2762.           BAsmCode[1] = 0xcb;
  2763.           BAsmCode[2] = (Code << 3) + AdrPart;
  2764.           CodeLen = 3;
  2765.         }
  2766.         break;
  2767.       case ModReg8:
  2768.         if (AdrPart != 6) WrError(ErrNum_InvAddrMode);
  2769.         else
  2770.         {
  2771.           if (AdrCnt == 0)
  2772.           {
  2773.             BAsmCode[0] = 0xed;
  2774.             PrefixCnt = 1;
  2775.           }
  2776.           CodeLen = PrefixCnt;
  2777.           BAsmCode[CodeLen++] = 0xcb;
  2778.           AppendAdrVals();
  2779.           BAsmCode[CodeLen++] = 0x02 + (Code << 3);
  2780.         }
  2781.         break;
  2782.       default:
  2783.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2784.     }
  2785.   }
  2786. }
  2787.  
  2788. static void DecodeBit(Word Code)
  2789. {
  2790.   Byte reg_num = 0;
  2791.   int mem_arg_index, bit_arg_index;
  2792.   Boolean ok;
  2793.  
  2794.   /* extra undocumented dest register is not allowed for BIT */
  2795.  
  2796.   if (!ChkArgCnt(1, (is_z80u() && (Code != 0)) ? 3 : 2))
  2797.     return;
  2798.  
  2799.   /* triple arg (Z80 undoc): which is the extra destination register? This must be a 'simple' register (A,B,C,D,E,H,L): */
  2800.  
  2801.   if (ArgCnt >= 3)
  2802.   {
  2803.     if (DecodeReg8Core(ArgStr[1].str.p_str, &reg_num) && !(reg_num & 0xc0))
  2804.     {
  2805.       mem_arg_index = 3;
  2806.       bit_arg_index = 2;
  2807.     }
  2808.     else if (DecodeReg8Core(ArgStr[3].str.p_str, &reg_num) && !(reg_num & 0xc0))
  2809.     {
  2810.       mem_arg_index = 2;
  2811.       bit_arg_index = 1;
  2812.     }
  2813.     else
  2814.     {
  2815.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  2816.       return;
  2817.     }
  2818.   }
  2819.  
  2820.   /* single arg (documented version): */
  2821.  
  2822.   else
  2823.   {
  2824.     mem_arg_index = 2;
  2825.     bit_arg_index = 1;
  2826.   }
  2827.  
  2828.   /* now decode the 'official arguments': */
  2829.  
  2830.   OpSize = 0;
  2831.   DecodeAdr(&ArgStr[mem_arg_index], MModReg8);
  2832.   if (AdrMode != ModReg8)
  2833.     return;
  2834.  
  2835.   /* forbid IXL..IYU: */
  2836.  
  2837.   if ((PrefixCnt > 0) && (AdrPart != 6))
  2838.   {
  2839.     WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[mem_arg_index]);
  2840.     return;
  2841.   }
  2842.  
  2843.   /* parse bit # and form machine code: */
  2844.  
  2845.   Code = ((Code + 1) << 6) | (EvalStrIntExpression(&ArgStr[bit_arg_index], UInt3, &ok) << 3);
  2846.   if (!ok)
  2847.     return;
  2848.  
  2849.   /* replace AdrPart for undocumented version.  Addressing mode must be IXd/IYd: */
  2850.  
  2851.   if (ArgCnt >= 3)
  2852.   {
  2853.     if ((AdrPart != 6) || (PrefixCnt != 1))
  2854.     {
  2855.       WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[mem_arg_index]);
  2856.       return;
  2857.     }
  2858.     AdrPart = reg_num;
  2859.   }
  2860.  
  2861.   /* assemble instruction: */
  2862.  
  2863.   CodeLen = PrefixCnt;
  2864.   BAsmCode[CodeLen++] = 0xcb;
  2865.   AppendAdrVals();
  2866.   BAsmCode[CodeLen++] = Code | AdrPart;
  2867. }
  2868.  
  2869. static void DecodeMLT(Word Index)
  2870. {
  2871.   UNUSED(Index);
  2872.  
  2873.   if (!ChkArgCnt(1, 1));
  2874.   else if (chk_core_mask(e_core_mask_min_z180))
  2875.   {
  2876.     DecodeAdr(&ArgStr[1], MModAll);
  2877.     if ((AdrMode != ModReg16) || has_index_prefix()) WrError(ErrNum_InvAddrMode);
  2878.     else
  2879.     {
  2880.       BAsmCode[PrefixCnt] = 0xed;
  2881.       BAsmCode[PrefixCnt + 1] = 0x4c + (AdrPart << 4);
  2882.       CodeLen = PrefixCnt + 2;
  2883.     }
  2884.   }
  2885. }
  2886.  
  2887. static void DecodeMULT_DIV(Word Code)
  2888. {
  2889.   const tStrComp *pSrcArg;
  2890.  
  2891.   if (!chk_core_mask(e_core_mask_z380)
  2892.    || !ChkArgCnt(1, 2))
  2893.     return;
  2894.  
  2895.   if (2 == ArgCnt)
  2896.   {
  2897.     if (!DecodeAdr_HL(&ArgStr[1]))
  2898.       return;
  2899.   }
  2900.  
  2901.   OpSize = 1;
  2902.   pSrcArg = &ArgStr[ArgCnt];
  2903.   switch (DecodeAdr(pSrcArg, MModReg8 | MModReg16 | MModImm))
  2904.   {
  2905.     case ModReg8:
  2906.       if ((AdrPart != 6) || (PrefixCnt == 0)) WrStrErrorPos(ErrNum_InvAddrMode, pSrcArg);
  2907.       else
  2908.       {
  2909.         CodeLen = PrefixCnt;
  2910.         BAsmCode[CodeLen++] = 0xcb;
  2911.         AppendAdrVals();
  2912.         BAsmCode[CodeLen++] = 0x92 | Code;
  2913.       }
  2914.       break;
  2915.     case ModReg16:
  2916.       if (AdrPart == SPReg) WrStrErrorPos(ErrNum_InvAddrMode, pSrcArg);
  2917.       else if (PrefixCnt == 0)
  2918.       {
  2919.         if (AdrPart == 2)
  2920.           AdrPart = 3;
  2921.         BAsmCode[0] = 0xed;
  2922.         BAsmCode[1] = 0xcb;
  2923.         BAsmCode[2] = 0x90 + AdrPart + Code;
  2924.         CodeLen = 3;
  2925.       }
  2926.       else
  2927.       {
  2928.         BAsmCode[2] = 0x94 + ((BAsmCode[0] >> 5) & 1) + Code;
  2929.         BAsmCode[0] = 0xed;
  2930.         BAsmCode[1] = 0xcb;
  2931.         CodeLen = 3;
  2932.       }
  2933.       break;
  2934.     case ModImm:
  2935.       CodeLen = 0;
  2936.       BAsmCode[CodeLen++] = 0xed;
  2937.       BAsmCode[CodeLen++] = 0xcb;
  2938.       BAsmCode[CodeLen++] = 0x97 + Code;
  2939.       AppendAdrVals();
  2940.       break;
  2941.     default:
  2942.       break;
  2943.   }
  2944. }
  2945.  
  2946. static void DecodeTST(Word Index)
  2947. {
  2948.   UNUSED(Index);
  2949.  
  2950.   if (!ChkArgCnt(1, 2));
  2951.   else if (chk_core_mask(e_core_mask_min_z180))
  2952.   {
  2953.     if (ArgCnt == 2)
  2954.     {
  2955.       if (DecodeAdr(&ArgStr[1], MModReg8) != ModReg8)
  2956.         return;
  2957.       if (AdrPart != AccReg)
  2958.       {
  2959.         WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2960.         return;
  2961.       }
  2962.     }
  2963.     OpSize = eSymbolSize8Bit;
  2964.     DecodeAdr(&ArgStr[ArgCnt], MModAll);
  2965.     switch (AdrMode)
  2966.     {
  2967.       case ModReg8:
  2968.         if (has_index_prefix()) WrError(ErrNum_InvAddrMode);
  2969.         else
  2970.         {
  2971.           BAsmCode[PrefixCnt] = 0xed;
  2972.           BAsmCode[PrefixCnt + 1] = 4 + (AdrPart << 3);
  2973.           CodeLen = PrefixCnt + 2;
  2974.         }
  2975.         break;
  2976.       case ModImm:
  2977.         BAsmCode[PrefixCnt] = 0xed;
  2978.         BAsmCode[PrefixCnt + 1] = 0x64;
  2979.         BAsmCode[PrefixCnt + 2] = AdrVals[0];
  2980.         CodeLen = PrefixCnt + 3;
  2981.         break;
  2982.       default:
  2983.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  2984.     }
  2985.   }
  2986. }
  2987.  
  2988. static void DecodeSWAP(Word Index)
  2989. {
  2990.   UNUSED(Index);
  2991.  
  2992.   if (!ChkArgCnt(1, 1));
  2993.   else if (chk_core_mask(e_core_mask_z380 | e_core_mask_sharp))
  2994.   {
  2995.     DecodeAdr(&ArgStr[1], is_z380() ? MModReg16 : MModReg8);
  2996.     switch (AdrMode)
  2997.     {
  2998.       case ModReg16:
  2999.         if (AdrPart == 3) WrError(ErrNum_InvAddrMode);
  3000.         else if (PrefixCnt == 0)
  3001.         {
  3002.           if (AdrPart == 2)
  3003.             AdrPart = 3;
  3004.           BAsmCode[0] = 0xed;
  3005.           BAsmCode[1] = 0x0e + (AdrPart << 4); /*?*/
  3006.           CodeLen = 2;
  3007.         }
  3008.         else
  3009.         {
  3010.           BAsmCode[PrefixCnt] = 0x3e;
  3011.           CodeLen = PrefixCnt + 1;
  3012.         }
  3013.         break;
  3014.       case ModReg8:
  3015.         BAsmCode[0] = 0xcb;
  3016.         BAsmCode[1] = 0x30 | AdrPart;
  3017.         CodeLen = 2;
  3018.         break;
  3019.       default:
  3020.         break;
  3021.     }
  3022.   }
  3023. }
  3024.  
  3025. /*!------------------------------------------------------------------------
  3026.  * \fn     DecodePUSH_POP(Word Code)
  3027.  * \brief  handle PUSH/POP instructions
  3028.  * \param  Code machine code (4 = PUSH family, 0 = POP family)
  3029.  * ------------------------------------------------------------------------ */
  3030.  
  3031. static void DecodePUSH_POP(Word Code)
  3032. {
  3033.   if (!ChkArgCnt(1, 1));
  3034.   else if (!as_strcasecmp(ArgStr[1].str.p_str, "SR"))
  3035.   {
  3036.     if (chk_core_mask(e_core_mask_z380))
  3037.     {
  3038.       CodeLen = 2;
  3039.       BAsmCode[0] = 0xed;
  3040.       BAsmCode[1] = 0xc1 + Code;
  3041.     }
  3042.   }
  3043.   else
  3044.   {
  3045.     OpSize = 1; MayLW = True;
  3046.     if (!as_strcasecmp(ArgStr[1].str.p_str, "AF"))
  3047.     {
  3048.       AdrPart = SPReg;
  3049.       AdrMode = ModReg16;
  3050.     }
  3051.     else
  3052.       DecodeAdr(&ArgStr[1], MModReg16 | (((Code == 4) && is_z380()) ? MModImm : 0));
  3053.     switch (AdrMode)
  3054.     {
  3055.       case ModReg16:
  3056.         CodeLen = 1 + PrefixCnt;
  3057.         BAsmCode[PrefixCnt] = 0xc1 + (AdrPart << 4) + Code;
  3058.         break;
  3059.       case ModImm:
  3060.         CodeLen = PrefixCnt;
  3061.         BAsmCode[CodeLen++] = 0xfd;
  3062.         BAsmCode[CodeLen++] = 0xf5;
  3063.         AppendAdrVals();
  3064.         break;
  3065.       default:
  3066.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  3067.     }
  3068.   }
  3069. }
  3070.  
  3071. static void DecodeEX(Word Index)
  3072. {
  3073.   Boolean OK;
  3074.   Byte AdrByte;
  3075.  
  3076.   UNUSED(Index);
  3077.  
  3078.   /* No EX at all on GBZ80 */
  3079.  
  3080.   if (!chk_core_mask(e_core_mask_no_sharp))
  3081.     return;
  3082.  
  3083.   /* work around the parser problem related to the ' character */
  3084.  
  3085.   if (!as_strncasecmp(ArgStr[2].str.p_str, "AF\'", 3))
  3086.     ArgStr[2].str.p_str[3] = '\0';
  3087.  
  3088.   if (!ChkArgCnt(2, 2));
  3089.   else if (ParPair("AF", "AF\'"))
  3090.   {
  3091.     BAsmCode[0] = 0x08;
  3092.     CodeLen = 1;
  3093.   }
  3094.   else if (ParPair("AF", "AF`"))
  3095.   {
  3096.     BAsmCode[0] = 0x08;
  3097.     CodeLen = 1;
  3098.   }
  3099.   else
  3100.   {
  3101.     if ((ArgStr[2].str.p_str[0]) && (ArgStr[2].str.p_str[strlen(ArgStr[2].str.p_str) - 1] == '\''))
  3102.     {
  3103.       OK = True;
  3104.       ArgStr[2].str.p_str[strlen(ArgStr[2].str.p_str) - 1] = '\0';
  3105.     }
  3106.     else
  3107.       OK = False;
  3108.  
  3109.     DecodeAdr(&ArgStr[1], MModReg8 | MModReg16 | MModSPRel | MModIndReg16);
  3110.     switch (AdrMode)
  3111.     {
  3112.       case ModReg8:
  3113.         if (AdrPart == 6)
  3114.         {
  3115.           if (PrefixCnt) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  3116.           else if (DecodeAdr_A(&ArgStr[2]) && chk_core_mask(e_core_mask_z380)) /* (HL),A */
  3117.           {
  3118.             BAsmCode[0] = 0xed;
  3119.             BAsmCode[1] = 0x37;
  3120.             CodeLen = 2;
  3121.           }
  3122.         }
  3123.         else
  3124.         {
  3125.           AdrByte = AdrPart;
  3126.           DecodeAdr(&ArgStr[2], MModReg8);
  3127.           switch (AdrMode)
  3128.           {
  3129.             case ModReg8:
  3130.               if (AdrPart == 6)
  3131.               {
  3132.                 if ((AdrByte != AccReg) || PrefixCnt) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]); /* A<->(HL) */
  3133.                 else if (chk_core_mask(e_core_mask_z380))
  3134.                 {
  3135.                   BAsmCode[0] = 0xed;
  3136.                   BAsmCode[1] = 0x37;
  3137.                   CodeLen = 2;
  3138.                 }
  3139.               }
  3140.               else if (!chk_core_mask(e_core_mask_z380));
  3141.               else if ((AdrByte == AccReg) && !OK)
  3142.               {
  3143.                 BAsmCode[0] = 0xed;
  3144.                 BAsmCode[1] = 0x07 + (AdrPart << 3);
  3145.                 CodeLen = 2;
  3146.               }
  3147.               else if ((AdrPart == AccReg) && !OK)
  3148.               {
  3149.                 BAsmCode[0] = 0xed;
  3150.                 BAsmCode[1] = 0x07 + (AdrByte << 3);
  3151.                 CodeLen = 2;
  3152.               }
  3153.               else if (OK && (AdrPart == AdrByte))
  3154.               {
  3155.                 BAsmCode[0] = 0xcb;
  3156.                 BAsmCode[1] = 0x30 + AdrPart;
  3157.                 CodeLen = 2;
  3158.               }
  3159.               else WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3160.               break;
  3161.             default:
  3162.               break;
  3163.           }
  3164.         }
  3165.         break;
  3166.       case ModReg16:
  3167.         if (AdrPart == 3) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  3168.         else if (PrefixCnt == 0) /* EX R16,... */
  3169.         {
  3170.           AdrByte = (AdrPart == HLReg) ? SPReg : AdrPart;
  3171.           DecodeAdr(&ArgStr[2], MModReg16 | ((AdrPart == HLReg) ? MModSPRel : 0));
  3172.           switch (AdrMode)
  3173.           {
  3174.             case ModReg16:
  3175.               /* For DE <-> IX/IY, use the DD/FD prefix and DE<->HL on Z80, but the newer coding on Z380 */
  3176.  
  3177.               if (((AdrByte == DEReg) && (AdrPart == HLReg) && (!PrefixCnt || !is_z380())) /* DE <-> HL */
  3178.                || ((AdrByte == SPReg) && (AdrPart == DEReg) && (!PrefixCnt || !is_z380())))
  3179.               {
  3180.                 BAsmCode[PrefixCnt] = 0xeb;
  3181.                 CodeLen = PrefixCnt + 1;
  3182.               }
  3183.               else if (AdrPart == 3) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3184.               else if (!chk_core_mask(e_core_mask_z380));
  3185.               else if (OK)
  3186.               {
  3187.                 if (AdrPart == 2)
  3188.                   AdrPart = 3;
  3189.                 if ((PrefixCnt != 0) || (AdrPart != AdrByte)) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3190.                 else
  3191.                 {
  3192.                   BAsmCode[0] = 0xed;
  3193.                   BAsmCode[1] = 0xcb;
  3194.                   BAsmCode[2] = 0x30 + AdrByte;
  3195.                   CodeLen = 3;
  3196.                 }
  3197.               }
  3198.               else if (PrefixCnt == 0)
  3199.               {
  3200.                 if (AdrByte == 0)
  3201.                 {
  3202.                   if (AdrPart == 2)
  3203.                     AdrPart = 3;
  3204.                   BAsmCode[0] = 0xed;
  3205.                   BAsmCode[1] = 0x01 + (AdrPart << 2);
  3206.                   CodeLen = 2;
  3207.                 }
  3208.                 else if (AdrPart == 0)
  3209.                 {
  3210.                   BAsmCode[0] = 0xed;
  3211.                   BAsmCode[1] = 0x01 + (AdrByte << 2);
  3212.                   CodeLen = 2;
  3213.                 }
  3214.               }
  3215.               else
  3216.               {
  3217.                 if (AdrPart == 2)
  3218.                   AdrPart = 3;
  3219.                 BAsmCode[1] = 0x03 + ((BAsmCode[0] >> 2) & 8) + (AdrByte << 4);
  3220.                 BAsmCode[0] = 0xed;
  3221.                 CodeLen = 2;
  3222.               }
  3223.               break;
  3224.             case ModSPRel:
  3225.               if ((AdrCnt == 1) && !AdrVals[0]) /* HL <-> (SP) */
  3226.               {
  3227.                 BAsmCode[PrefixCnt] = 0xe3;
  3228.                 CodeLen = PrefixCnt + 1;
  3229.               }
  3230.               else
  3231.                 WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3232.               break;
  3233.             default:
  3234.               break;
  3235.           }
  3236.         }
  3237.         else /* EX XY,... */
  3238.         {
  3239.           DecodeAdr(&ArgStr[2], MModReg16 | MModSPRel);
  3240.           switch (AdrMode)
  3241.           {
  3242.             case ModReg16:
  3243.               if (AdrPart == 3) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3244.               else if (!chk_core_mask(e_core_mask_z380));
  3245.               else if (OK)
  3246.               {
  3247.                 if ((PrefixCnt != 2) || (BAsmCode[0] != BAsmCode[1])) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3248.                 else
  3249.                 {
  3250.                   BAsmCode[2] = ((BAsmCode[0] >> 5) & 1)+0x34;
  3251.                   BAsmCode[0] = 0xed;
  3252.                   BAsmCode[1] = 0xcb;
  3253.                   CodeLen = 3;
  3254.                 }
  3255.               }
  3256.               else if (PrefixCnt == 1)
  3257.               {
  3258.                 if (AdrPart == 2)
  3259.                   AdrPart = 3;
  3260.                 BAsmCode[1] = ((BAsmCode[0] >> 2) & 8) + 3 + (AdrPart << 4);
  3261.                 BAsmCode[0] = 0xed;
  3262.                 CodeLen = 2;
  3263.               }
  3264.               else if (BAsmCode[0] == BAsmCode[1]) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3265.               else
  3266.               {
  3267.                 BAsmCode[0] = 0xed;
  3268.                 BAsmCode[1] = 0x2b;
  3269.                 CodeLen = 2;
  3270.               }
  3271.               break;
  3272.             case ModSPRel:
  3273.               if ((AdrCnt == 1) && !AdrVals[0]) /* IX/IX <-> (SP) */
  3274.               {
  3275.                 BAsmCode[PrefixCnt] = 0xe3;
  3276.                 CodeLen = PrefixCnt + 1;
  3277.               }
  3278.               else
  3279.                 WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3280.               break;
  3281.             default:
  3282.               break;
  3283.           }
  3284.         }
  3285.         break;
  3286.       case ModSPRel:
  3287.         if ((AdrCnt != 1) || AdrVals[0]) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  3288.         else switch (DecodeAdr(&ArgStr[2], MModReg16))
  3289.         {
  3290.           case ModReg16: /* (SP) <-> HL/IX/IX */
  3291.             if (AdrPart != HLReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  3292.             else
  3293.             {
  3294.               BAsmCode[PrefixCnt] = 0xe3;
  3295.               CodeLen = PrefixCnt + 1;
  3296.             }
  3297.             break;
  3298.           default:
  3299.             break;
  3300.         }
  3301.         break;
  3302.       default:
  3303.         break;
  3304.     }
  3305.   }
  3306. }
  3307.  
  3308. static void DecodeTSTI(Word Code)
  3309. {
  3310.   UNUSED(Code);
  3311.  
  3312.   if (chk_core_mask(e_core_mask_z80u)
  3313.    && ChkArgCnt(0, 0))
  3314.   {
  3315.     BAsmCode[0] = 0xed;
  3316.     BAsmCode[1] = 0x70;
  3317.     CodeLen = 2;
  3318.   }
  3319. }
  3320.  
  3321. static void DecodeIN_OUT(Word IsOUT)
  3322. {
  3323.   if ((ArgCnt == 1) && !IsOUT)
  3324.   {
  3325.     if (chk_core_mask(e_core_mask_z80u)
  3326.      && (DecodeAdr(&ArgStr[1], MModIndReg8) == ModIndReg8))
  3327.     {
  3328.       BAsmCode[0] = 0xed;
  3329.       BAsmCode[1] = 0x70;
  3330.       CodeLen = 2;
  3331.     }
  3332.   }
  3333.   else if (ChkArgCnt(2, 2) && chk_core_mask(e_core_mask_no_sharp))
  3334.   {
  3335.     const tStrComp *pPortArg = IsOUT ? &ArgStr[1] : &ArgStr[2],
  3336.                    *pRegArg = IsOUT ? &ArgStr[2] : &ArgStr[1];
  3337.  
  3338.     /* allow absolute I/O address also without (...) */
  3339.  
  3340.     OpSize = 0;
  3341.     switch (DecodeAdr(pPortArg, (is_ez80() ? MModIndReg16 : 0) | MModIndReg8 | MModIOAbs | MModImm))
  3342.     {
  3343.       case ModIndReg16:
  3344.         if (0 != AdrPart) WrStrErrorPos(ErrNum_InvAddrMode, pPortArg);
  3345.         else if (ModReg8 == DecodeAdr(pRegArg, MModReg8))
  3346.         {
  3347.           CodeLen = 2;
  3348.           BAsmCode[0] = 0xed;
  3349.           BAsmCode[1] = 0x40 | (AdrPart << 3) | !!IsOUT;
  3350.         }
  3351.         break;
  3352.       case ModIndReg8:
  3353.         DecodeAdrWithF(pRegArg, !IsOUT);
  3354.         switch (AdrMode)
  3355.         {
  3356.           case ModReg8:
  3357.             if (PrefixCnt != 0) WrError(ErrNum_InvAddrMode);
  3358.             else
  3359.             {
  3360.               CodeLen = 2;
  3361.               BAsmCode[0] = 0xed;
  3362.               BAsmCode[1] = 0x40 + (AdrPart << 3);
  3363.               if (IsOUT)
  3364.                 BAsmCode[1]++;
  3365.             }
  3366.             break;
  3367.           case ModImm:
  3368.             if (!IsOUT) WrError(ErrNum_InvAddrMode);
  3369.             else if (is_z80u() && (AdrVals[0] == 0))
  3370.             {
  3371.               BAsmCode[0] = 0xed;
  3372.               BAsmCode[1] = 0x71;
  3373.               CodeLen = 2;
  3374.             }
  3375.             else if (chk_core_mask(e_core_mask_z380))
  3376.             {
  3377.               BAsmCode[0] = 0xed;
  3378.               BAsmCode[1] = 0x71;
  3379.               BAsmCode[2] = AdrVals[0];
  3380.               CodeLen = 3;
  3381.             }
  3382.             break;
  3383.           default:
  3384.             if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  3385.         }
  3386.         break;
  3387.       case ModIOAbs:
  3388.       case ModImm:
  3389.         if (DecodeAdr_A(pRegArg))
  3390.         {
  3391.           CodeLen = 2;
  3392.           BAsmCode[0] = IsOUT ? 0xd3 : 0xdb;
  3393.           BAsmCode[1] = AdrVals[0];
  3394.         }
  3395.         break;
  3396.       default:
  3397.         break;
  3398.     }
  3399.   }
  3400. }
  3401.  
  3402. static void DecodeINW_OUTW(Word IsOUTW)
  3403. {
  3404.   const tStrComp *pPortArg, *pRegArg;
  3405.  
  3406.   if (!ChkArgCnt(2, 2) || !chk_core_mask(e_core_mask_z380))
  3407.     return;
  3408.  
  3409.   pPortArg = IsOUTW ? &ArgStr[1] : &ArgStr[2];
  3410.   pRegArg  = IsOUTW ? &ArgStr[2] : &ArgStr[1];
  3411.  
  3412.   if (DecodeAdr(pPortArg, MModIndReg8) != ModIndReg8)
  3413.     return;
  3414.  
  3415.   OpSize = 1;
  3416.   switch (DecodeAdr(pRegArg, MModReg16 | (IsOUTW ? MModImm : 0)))
  3417.   {
  3418.     case ModReg16:
  3419.       if ((AdrPart == 3) || (PrefixCnt > 0)) WrError(ErrNum_InvAddrMode);
  3420.       else
  3421.       {
  3422.         switch (AdrPart)
  3423.         {
  3424.           case 1: AdrPart = 2; break;
  3425.           case 2: AdrPart = 7; break;
  3426.         }
  3427.         BAsmCode[0] = 0xdd;
  3428.         BAsmCode[1] = 0x40 + (AdrPart << 3);
  3429.         if (IsOUTW)
  3430.           BAsmCode[1]++;
  3431.         CodeLen = 2;
  3432.       }
  3433.       break;
  3434.     case ModImm:
  3435.       CodeLen = 0;
  3436.       BAsmCode[CodeLen++] = 0xfd;
  3437.       BAsmCode[CodeLen++] = 0x79;
  3438.       AppendAdrVals();
  3439.       break;
  3440.     default:
  3441.       break;
  3442.   }
  3443. }
  3444.  
  3445. /*!------------------------------------------------------------------------
  3446.  * \fn     DecodeIN0_OUT0(Word IsOUT0)
  3447.  * \brief  Handle IN0/OUT0 instructions on Z180++
  3448.  * \param  IsOUT0 1 for OUT0, 0 for IN0
  3449.  * ------------------------------------------------------------------------ */
  3450.  
  3451. static void DecodeIN0_OUT0(Word IsOUT0)
  3452. {
  3453.   /* 'IN0 (C)' better should not be allowed at all, because it was a copy'n'waste from
  3454.      the undocumented Z80 'IN (C)' which should better have been named 'IN F,(C)'.  But
  3455.      I will leave it in for upward compatibility, and not implicitly assume A as register: */
  3456.  
  3457.   if (ChkArgCnt(IsOUT0 ? 2 : 1, 2)
  3458.    && chk_core_mask(e_core_mask_min_z180))
  3459.   {
  3460.     Boolean OK;
  3461.     const tStrComp *pRegArg, *pPortArg;
  3462.  
  3463.     if (IsOUT0)
  3464.     {
  3465.       pRegArg = (ArgCnt == 2) ? &ArgStr[2] : NULL;
  3466.       pPortArg = &ArgStr[1];
  3467.     }
  3468.     else
  3469.     {
  3470.       pRegArg = (ArgCnt == 2) ? &ArgStr[1] : NULL;
  3471.       pPortArg = &ArgStr[ArgCnt];
  3472.     }
  3473.     OpSize = 0;
  3474.     if (!pRegArg)
  3475.     {
  3476.       AdrPart = 6;
  3477.       OK = True;
  3478.     }
  3479.     else
  3480.     {
  3481.       DecodeAdrWithF(pRegArg, !IsOUT0);
  3482.       if ((AdrMode == ModReg8) && (PrefixCnt == 0)) OK = True;
  3483.       else
  3484.       {
  3485.         OK = False;
  3486.         if (AdrMode != ModNone) WrStrErrorPos(ErrNum_InvAddrMode, pRegArg);
  3487.       }
  3488.     }
  3489.     if (OK)
  3490.     {
  3491.       BAsmCode[2] = EvalStrIntExpression(pPortArg, UInt8, &OK);
  3492.       if (OK)
  3493.       {
  3494.         BAsmCode[0] = 0xed;
  3495.         BAsmCode[1] = AdrPart << 3;
  3496.         if (IsOUT0)
  3497.           BAsmCode[1]++;
  3498.         CodeLen = 3;
  3499.       }
  3500.     }
  3501.   }
  3502. }
  3503.  
  3504. static void DecodeINA_INAW_OUTA_OUTAW(Word Code)
  3505. {
  3506.   Word IsIn = Code & 8;
  3507.   LongWord AdrLong;
  3508.   tStrComp *pRegArg, *pPortArg;
  3509.   tEvalResult EvalResult;
  3510.  
  3511.   if (!ChkArgCnt(2, 2) || !chk_core_mask(e_core_mask_z380))
  3512.     return;
  3513.  
  3514.   pRegArg = IsIn ? &ArgStr[1] : &ArgStr[2];
  3515.   pPortArg = IsIn ? &ArgStr[2] : &ArgStr[1];
  3516.  
  3517.   OpSize = Code & 1;
  3518.   if (!(OpSize ? DecodeAdr_HL(pRegArg) : DecodeAdr_A(pRegArg)))
  3519.     return;
  3520.  
  3521.   AdrLong = EvalStrIntExpressionWithResult(pPortArg, ExtFlag ? Int32 : UInt8, &EvalResult);
  3522.   if (EvalResult.OK)
  3523.   {
  3524.     ChkSpace(SegIO, EvalResult.AddrSpaceMask);
  3525.     if (AdrLong > 0xfffffful)
  3526.       ChangeDDPrefix(ePrefixIW);
  3527.     else if (AdrLong > 0xfffful)
  3528.       ChangeDDPrefix(ePrefixIB);
  3529.     CodeLen = PrefixCnt;
  3530.     BAsmCode[CodeLen++] = 0xed + (OpSize << 4);
  3531.     BAsmCode[CodeLen++] = 0xd3 + IsIn;
  3532.     BAsmCode[CodeLen++] = AdrLong & 0xff;
  3533.     BAsmCode[CodeLen++] = (AdrLong >> 8) & 0xff;
  3534.     if (AdrLong > 0xfffful)
  3535.       BAsmCode[CodeLen++] = (AdrLong >> 16) & 0xff;
  3536.     if (AdrLong > 0xfffffful)
  3537.       BAsmCode[CodeLen++] = (AdrLong >> 24) & 0xff;
  3538.   }
  3539. }
  3540.  
  3541. static void DecodeTSTIO(Word Code)
  3542. {
  3543.   UNUSED(Code);
  3544.  
  3545.   if (ChkArgCnt(1, 1)
  3546.    && chk_core_mask(e_core_mask_min_z180))
  3547.   {
  3548.     Boolean OK;
  3549.  
  3550.     BAsmCode[2] = EvalStrIntExpression(&ArgStr[1], Int8, &OK);
  3551.     if (OK)
  3552.     {
  3553.       BAsmCode[0] = 0xed;
  3554.       BAsmCode[1] = 0x74;
  3555.       CodeLen = 3;
  3556.     }
  3557.   }
  3558. }
  3559.  
  3560. static void DecodeRET(Word Code)
  3561. {
  3562.   int Cond;
  3563.  
  3564.   UNUSED(Code);
  3565.  
  3566.   /* TODO: allow only no and .L as eZ80 attribute */
  3567.  
  3568.   if (ArgCnt == 0)
  3569.   {
  3570.     CodeLen = PrefixCnt + 1;
  3571.     BAsmCode[PrefixCnt] = 0xc9;
  3572.   }
  3573.   else if (!ChkArgCnt(0, 1));
  3574.   else if (!DecodeCondition(ArgStr[1].str.p_str, &Cond)) WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  3575.   else
  3576.   {
  3577.     CodeLen = PrefixCnt + 1;
  3578.     BAsmCode[PrefixCnt] = 0xc0 + (Cond << 3);
  3579.   }
  3580. }
  3581.  
  3582. static void encode_jp_core(Byte condition)
  3583. {
  3584.   BAsmCode[PrefixCnt] = 0xc2 + condition;
  3585.   CodeLen = PrefixCnt + 1;
  3586.   AppendAdrVals();
  3587. }
  3588.  
  3589. static IntType get_jr_dist(LongWord dest, LongInt *p_dist)
  3590. {
  3591.   *p_dist = dest - (EProgCounter() + 2);
  3592.   if (RangeCheck(*p_dist, SInt8))
  3593.     return SInt8;
  3594.   if (is_z380())
  3595.   {
  3596.     *p_dist -= 2;
  3597.     if (RangeCheck(*p_dist, SInt16))
  3598.       return SInt16;
  3599.     (*p_dist)--;
  3600.     if (RangeCheck(*p_dist, SInt24))
  3601.       return SInt24;
  3602.   }
  3603.   return UInt0;
  3604. }
  3605.  
  3606. static void DecodeJP(Word Code)
  3607. {
  3608.   int Cond;
  3609.   Boolean check_jr = False;
  3610.  
  3611.   UNUSED(Code);
  3612.  
  3613.   switch (ArgCnt)
  3614.   {
  3615.     case 1:
  3616.       Cond = 1;
  3617.       check_jr = True;
  3618.       break;
  3619.     case 2:
  3620.       if (!DecodeCondition(ArgStr[1].str.p_str, &Cond))
  3621.       {
  3622.         WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  3623.         return;
  3624.       }
  3625.       check_jr = (Cond <= 3);
  3626.       Cond <<= 3;
  3627.       break;
  3628.     default:
  3629.       (void)ChkArgCnt(1, 2);
  3630.       return;
  3631.   }
  3632.  
  3633.   switch (DecodeAdr(&ArgStr[ArgCnt], MModImmIsAbs | MModAbs | ((Cond == 1) ? MModReg8 : 0)))
  3634.   {
  3635.     case ModReg8:
  3636.       if ((AdrPart != 6) || ((AdrCnt > 0) && AdrVals[0])) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[ArgCnt]);
  3637.       else
  3638.       {
  3639.         BAsmCode[PrefixCnt] = 0xe9;
  3640.         CodeLen = PrefixCnt + 1;
  3641.       }
  3642.       break;
  3643.     case ModAbs:
  3644.     {
  3645.       LongInt dist;
  3646.  
  3647.       /* JP.SIL nnnn, JP.LIS nnnn are illegal on eZ80: */
  3648.  
  3649.       if (is_ez80()
  3650.        && (((AttrPartOpSize[0] == eSymbolSize16Bit) && (AttrPartOpSize[1] == eSymbolSize24Bit))
  3651.         || ((AttrPartOpSize[0] == eSymbolSize24Bit) && (AttrPartOpSize[1] == eSymbolSize16Bit))))
  3652.       {
  3653.         WrStrErrorPos(ErrNum_UndefAttr, &AttrPart);
  3654.         return;
  3655.       }
  3656.  
  3657.       if (check_jr
  3658.        && (get_jr_dist(AdrVal, &dist) != UInt0)
  3659.        && !mFirstPassUnknownOrQuestionable(adr_val_flags))
  3660.         WrStrErrorPos(ErrNum_RelJumpPossible, &ArgStr[ArgCnt]);
  3661.       encode_jp_core(Cond);
  3662.       break;
  3663.     }
  3664.   }
  3665. }
  3666.  
  3667. static void DecodeCALL(Word Code)
  3668. {
  3669.   Boolean OK;
  3670.   int Condition;
  3671.  
  3672.   UNUSED(Code);
  3673.  
  3674.   switch (ArgCnt)
  3675.   {
  3676.     case 1:
  3677.       Condition = 9;
  3678.       OK = True;
  3679.       break;
  3680.     case 2:
  3681.       OK = DecodeCondition(ArgStr[1].str.p_str, &Condition);
  3682.       if (OK)
  3683.         Condition <<= 3;
  3684.       else
  3685.         WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  3686.       break;
  3687.     default:
  3688.       (void)ChkArgCnt(1, 2);
  3689.       OK = False;
  3690.   }
  3691.  
  3692.   if (OK)
  3693.   {
  3694.     LongWord AdrLong;
  3695.     tEvalResult EvalResult;
  3696.  
  3697.     AdrLong = EvalAbsAdrExpression(&ArgStr[ArgCnt], &EvalResult);
  3698.     if (EvalResult.OK)
  3699.     {
  3700.       if (is_z380() && (AdrLong > 0xfffffful))
  3701.       {
  3702.         ChangeDDPrefix(ePrefixIW);
  3703.         CodeLen = PrefixCnt;
  3704.         BAsmCode[CodeLen++] = 0xc4 + Condition;
  3705.         BAsmCode[CodeLen++] = Lo(AdrLong);
  3706.         BAsmCode[CodeLen++] = Hi(AdrLong);
  3707.         BAsmCode[CodeLen++] = Hi(AdrLong >> 8);
  3708.         BAsmCode[CodeLen++] = Hi(AdrLong >> 16);
  3709.       }
  3710.       else if (is_z380() && (AdrLong > 0xfffful))
  3711.       {
  3712.         ChangeDDPrefix(ePrefixIB);
  3713.         CodeLen = PrefixCnt;
  3714.         BAsmCode[CodeLen++] = 0xc4 + Condition;
  3715.         BAsmCode[CodeLen++] = Lo(AdrLong);
  3716.         BAsmCode[CodeLen++] = Hi(AdrLong);
  3717.         BAsmCode[CodeLen++] = Hi(AdrLong >> 8);
  3718.       }
  3719.       else
  3720.       {
  3721.         CodeLen = PrefixCnt;
  3722.         BAsmCode[CodeLen++] = 0xc4 + Condition;
  3723.         BAsmCode[CodeLen++] = Lo(AdrLong);
  3724.         BAsmCode[CodeLen++] = Hi(AdrLong);
  3725.         if (is_ez80() && (AttrPartOpSize[1] == eSymbolSize24Bit))
  3726.           BAsmCode[CodeLen++] = Hi(AdrLong >> 8);
  3727.       }
  3728.     }
  3729.   }
  3730. }
  3731.  
  3732. static void encode_jr_core(IntType dist_size, Byte condition, LongInt dist)
  3733. {
  3734.   switch (dist_size)
  3735.   {
  3736.     case SInt8:
  3737.       CodeLen = 2;
  3738.       BAsmCode[0] = condition << 3;
  3739.       BAsmCode[1] = dist & 0xff;
  3740.       break;
  3741.     case SInt16:
  3742.       CodeLen = 4;
  3743.       BAsmCode[0] = 0xdd;
  3744.       BAsmCode[1] = condition << 3;
  3745.       BAsmCode[2] = dist & 0xff;
  3746.       BAsmCode[3] = (dist >> 8) & 0xff;
  3747.       break;
  3748.     case SInt24:
  3749.       CodeLen = 5;
  3750.       BAsmCode[0] = 0xfd;
  3751.       BAsmCode[1] = condition << 3;
  3752.       BAsmCode[2] = dist & 0xff;
  3753.       BAsmCode[3] = (dist >> 8) & 0xff;
  3754.       BAsmCode[4] = (dist >> 16) & 0xff;
  3755.       break;
  3756.     default:
  3757.       break;
  3758.   }
  3759. }
  3760.  
  3761. static void DecodeJR(Word Code)
  3762. {
  3763.   Boolean OK;
  3764.   int Condition;
  3765.   LongWord dest;
  3766.   tEvalResult EvalResult;
  3767.   LongInt dist;
  3768.   IntType dist_type;
  3769.  
  3770.   UNUSED(Code);
  3771.  
  3772.   switch (ArgCnt)
  3773.   {
  3774.     case 1:
  3775.       Condition = 3;
  3776.       OK = True;
  3777.       break;
  3778.     case 2:
  3779.       OK = DecodeCondition(ArgStr[1].str.p_str, &Condition);
  3780.       if (OK && (Condition > 3))
  3781.         OK = False;
  3782.       if (OK)
  3783.         Condition += 4;
  3784.       else
  3785.         WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  3786.       break;
  3787.     default:
  3788.       (void)ChkArgCnt(1, 2);
  3789.       OK = False;
  3790.   }
  3791.   if (!OK)
  3792.     return;
  3793.  
  3794.   dest = EvalAbsAdrExpression(&ArgStr[ArgCnt], &EvalResult);
  3795.   if (!EvalResult.OK)
  3796.     return;
  3797.  
  3798.   dist_type = get_jr_dist(dest, &dist);
  3799.   if (dist_type == UInt0)
  3800.   {
  3801.     if (mFirstPassUnknownOrQuestionable(EvalResult.Flags))
  3802.       dist_type = is_z380() ? SInt24 : SInt8;
  3803.     else
  3804.     {
  3805.       WrStrErrorPos(ErrNum_JmpDistTooBig, &ArgStr[ArgCnt]);
  3806.       return;
  3807.     }
  3808.   }
  3809.    
  3810.   encode_jr_core(dist_type, Condition, dist);
  3811. }
  3812.  
  3813. static void DecodeJ(Word Code)
  3814. {
  3815.   int condition;
  3816.  
  3817.   UNUSED(Code);
  3818.  
  3819.   switch (ArgCnt)
  3820.   {
  3821.     case 1:
  3822.       condition = 0xff;
  3823.       break;
  3824.     case 2:
  3825.       if (!DecodeCondition(ArgStr[1].str.p_str, &condition))
  3826.       {
  3827.         WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  3828.         return;
  3829.       }
  3830.       break;
  3831.     default:
  3832.       (void)ChkArgCnt(1, 2);
  3833.       return;
  3834.   }
  3835.  
  3836.   switch (DecodeAdr(&ArgStr[ArgCnt], MModImmIsAbs | MModAbs | ((condition == 0xff) ? MModReg8 : 0)))
  3837.   {
  3838.     case ModReg8:
  3839.       if ((AdrPart != 6) || ((AdrCnt > 0) && AdrVals[0])) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[ArgCnt]);
  3840.       else
  3841.       {
  3842.         BAsmCode[PrefixCnt] = 0xe9;
  3843.         CodeLen = PrefixCnt + 1;
  3844.       }
  3845.       break;
  3846.     case ModAbs:
  3847.       if ((condition <= 3) || (condition == 0xff))
  3848.       {
  3849.         LongInt dist;
  3850.         IntType dist_type = get_jr_dist(AdrVal, &dist);
  3851.  
  3852.         if (dist_type != UInt0)
  3853.         {
  3854.           encode_jr_core(dist_type, (condition == 0xff) ? 3 : (condition + 4), dist);
  3855.           return;
  3856.         }
  3857.       }
  3858.       encode_jp_core((condition == 0xff) ? 1 : (condition << 3));
  3859.       break;
  3860.     default:
  3861.       break;
  3862.   }
  3863. }
  3864.  
  3865. static void DecodeCALR(Word Code)
  3866. {
  3867.   Boolean OK;
  3868.   int Condition;
  3869.  
  3870.   UNUSED(Code);
  3871.  
  3872.   switch (ArgCnt)
  3873.   {
  3874.     case 1:
  3875.       Condition = 9;
  3876.       OK = True;
  3877.       break;
  3878.     case 2:
  3879.       OK = DecodeCondition(ArgStr[1].str.p_str, &Condition);
  3880.       if (OK)
  3881.         Condition <<= 3;
  3882.       else
  3883.         WrStrErrorPos(ErrNum_UndefCond, &ArgStr[1]);
  3884.       break;
  3885.     default:
  3886.       (void)ChkArgCnt(1, 2);
  3887.       OK = False;
  3888.   }
  3889.  
  3890.   if (OK)
  3891.   {
  3892.     if (chk_core_mask(e_core_mask_z380))
  3893.     {
  3894.       LongInt AdrLInt;
  3895.       tEvalResult EvalResult;
  3896.  
  3897.       AdrLInt = EvalAbsAdrExpression(&ArgStr[ArgCnt], &EvalResult);
  3898.       if (EvalResult.OK)
  3899.       {
  3900.         AdrLInt -= EProgCounter() + 3;
  3901.         if ((AdrLInt <= 0x7fl) && (AdrLInt >= -0x80l))
  3902.         {
  3903.           CodeLen = 3;
  3904.           BAsmCode[0] = 0xed;
  3905.           BAsmCode[1] = 0xc4 | Condition;
  3906.           BAsmCode[2] = AdrLInt & 0xff;
  3907.         }
  3908.         else
  3909.         {
  3910.           AdrLInt--;
  3911.           if ((AdrLInt <= 0x7fffl) && (AdrLInt >= -0x8000l))
  3912.           {
  3913.             CodeLen = 4;
  3914.             BAsmCode[0] = 0xdd;
  3915.             BAsmCode[1] = 0xc4 + Condition;
  3916.             BAsmCode[2] = AdrLInt & 0xff;
  3917.             BAsmCode[3] = (AdrLInt >> 8) & 0xff;
  3918.           }
  3919.           else
  3920.           {
  3921.             AdrLInt--;
  3922.             if ((AdrLInt <= 0x7fffffl) && (AdrLInt >= -0x800000l))
  3923.             {
  3924.               CodeLen = 5;
  3925.               BAsmCode[0] = 0xfd;
  3926.               BAsmCode[1] = 0xc4 + Condition;
  3927.               BAsmCode[2] = AdrLInt & 0xff;
  3928.               BAsmCode[3] = (AdrLInt >> 8) & 0xff;
  3929.               BAsmCode[4] = (AdrLInt >> 16) & 0xff;
  3930.             }
  3931.             else WrError(ErrNum_JmpDistTooBig);
  3932.           }
  3933.         }
  3934.       }
  3935.     }
  3936.   }
  3937. }
  3938.  
  3939. static void DecodeDJNZ(Word Code)
  3940. {
  3941.   UNUSED(Code);
  3942.  
  3943.   if (ChkArgCnt(1, 1) && chk_core_mask(e_core_mask_no_sharp))
  3944.   {
  3945.     tEvalResult EvalResult;
  3946.     LongInt AdrLInt;
  3947.  
  3948.     AdrLInt = EvalAbsAdrExpression(&ArgStr[1], &EvalResult);
  3949.     if (EvalResult.OK)
  3950.     {
  3951.       AdrLInt -= EProgCounter() + 2;
  3952.       if ((AdrLInt <= 0x7fl) & (AdrLInt >= -0x80l))
  3953.       {
  3954.         CodeLen = 2;
  3955.         BAsmCode[0] = 0x10;
  3956.         BAsmCode[1] = Lo(AdrLInt);
  3957.       }
  3958.       else if (!is_z380()) WrError(ErrNum_JmpDistTooBig);
  3959.       else
  3960.       {
  3961.         AdrLInt -= 2;
  3962.         if ((AdrLInt <= 0x7fffl) && (AdrLInt >= -0x8000l))
  3963.         {
  3964.           CodeLen = 4;
  3965.           BAsmCode[0] = 0xdd;
  3966.           BAsmCode[1] = 0x10;
  3967.           BAsmCode[2] = AdrLInt & 0xff;
  3968.           BAsmCode[3] = (AdrLInt >> 8) & 0xff;
  3969.         }
  3970.         else
  3971.         {
  3972.           AdrLInt--;
  3973.           if ((AdrLInt <= 0x7fffffl) && (AdrLInt >= -0x800000l))
  3974.           {
  3975.             CodeLen = 5;
  3976.             BAsmCode[0] = 0xfd;
  3977.             BAsmCode[1] = 0x10;
  3978.             BAsmCode[2] = AdrLInt & 0xff;
  3979.             BAsmCode[3] = (AdrLInt >> 8) & 0xff;
  3980.             BAsmCode[4] = (AdrLInt >> 16) & 0xff;
  3981.           }
  3982.           else WrError(ErrNum_JmpDistTooBig);
  3983.         }
  3984.       }
  3985.     }
  3986.   }
  3987. }
  3988.  
  3989. static void DecodeRST(Word Code)
  3990. {
  3991.   UNUSED(Code);
  3992.  
  3993.   if (ChkArgCnt(1, 1))
  3994.   {
  3995.     Boolean OK;
  3996.     tSymbolFlags Flags;
  3997.     Byte AdrByte;
  3998.     int SaveRadixBase = RadixBase;
  3999.  
  4000. #if 0
  4001.     /* some people like to regard the RST argument as a literal
  4002.        and leave away the 'h' to mark 38 as a hex number... */
  4003.     RadixBase = 16;
  4004. #endif
  4005.  
  4006.     AdrByte = EvalStrIntExpressionWithFlags(&ArgStr[1], Int8, &OK, &Flags);
  4007.     RadixBase = SaveRadixBase;
  4008.  
  4009.     if (mFirstPassUnknown(Flags))
  4010.       AdrByte = AdrByte & 0x38;
  4011.     if (OK)
  4012.     {
  4013.       if ((AdrByte > 0x38) || (AdrByte & 7)) WrError(ErrNum_NotFromThisAddress);
  4014.       else
  4015.       {
  4016.         CodeLen = PrefixCnt + 1;
  4017.         BAsmCode[PrefixCnt] = 0xc7 + AdrByte;
  4018.       }
  4019.     }
  4020.   }
  4021. }
  4022.  
  4023. static void DecodeEI_DI(Word Code)
  4024. {
  4025.   if (ArgCnt == 0)
  4026.   {
  4027.     BAsmCode[0] = 0xf3 + Code;
  4028.     CodeLen = 1;
  4029.   }
  4030.   else if (ChkArgCnt(1, 1)
  4031.         && chk_core_mask(e_core_mask_z380))
  4032.   {
  4033.     Boolean OK;
  4034.  
  4035.     BAsmCode[2] = EvalStrIntExpression(&ArgStr[1], UInt8, &OK);
  4036.     if (OK)
  4037.     {
  4038.       BAsmCode[0] = 0xdd;
  4039.       BAsmCode[1] = 0xf3 + Code;
  4040.       CodeLen = 3;
  4041.     }
  4042.   }
  4043. }
  4044.  
  4045. static void DecodeIM(Word Code)
  4046. {
  4047.   UNUSED(Code);
  4048.  
  4049.   if (ChkArgCnt(1, 1)
  4050.    && chk_core_mask(e_core_mask_no_sharp))
  4051.   {
  4052.     Byte AdrByte;
  4053.     Boolean OK;
  4054.  
  4055.     AdrByte = EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  4056.     if (OK)
  4057.     {
  4058.       if (AdrByte > 3) WrError(ErrNum_OverRange);
  4059.       else if ((AdrByte == 3) && (!chk_core_mask(e_core_mask_z380)));
  4060.       else
  4061.       {
  4062.         if (AdrByte == 3)
  4063.           AdrByte = 1;
  4064.         else if (AdrByte >= 1)
  4065.           AdrByte++;
  4066.         CodeLen = 2;
  4067.         BAsmCode[0] = 0xed;
  4068.         BAsmCode[1] = 0x46 + (AdrByte << 3);
  4069.       }
  4070.     }
  4071.   }
  4072. }
  4073.  
  4074. static void DecodeLDCTL(Word Code)
  4075. {
  4076.   Byte AdrByte;
  4077.  
  4078.   UNUSED(Code);
  4079.  
  4080.   OpSize = 0;
  4081.   if (!ChkArgCnt(2, 2));
  4082.   else if (!chk_core_mask(e_core_mask_z380));
  4083.   else if (DecodeSFR(ArgStr[1].str.p_str, &AdrByte))
  4084.   {
  4085.     DecodeAdr(&ArgStr[2], MModAll);
  4086.     switch (AdrMode)
  4087.     {
  4088.       case ModReg8:
  4089.         if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  4090.         else
  4091.         {
  4092.           BAsmCode[0] = 0xcd + ((AdrByte & 3) << 4);
  4093.           BAsmCode[1] = 0xc8 + ((AdrByte & 4) << 2);
  4094.           CodeLen = 2;
  4095.         }
  4096.         break;
  4097.       case ModReg16:
  4098.         if ((AdrByte != 1) || (AdrPart != 2) || (PrefixCnt != 0)) WrError(ErrNum_InvAddrMode);
  4099.         else
  4100.         {
  4101.           BAsmCode[0] = 0xed;
  4102.           BAsmCode[1] = 0xc8;
  4103.           CodeLen = 2;
  4104.         }
  4105.         break;
  4106.       case ModImm:
  4107.         BAsmCode[0] = 0xcd +((AdrByte & 3) << 4);
  4108.         BAsmCode[1] = 0xca +((AdrByte & 4) << 2);
  4109.         BAsmCode[2] = AdrVals[0];
  4110.         CodeLen = 3;
  4111.         break;
  4112.       default:
  4113.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  4114.     }
  4115.   }
  4116.   else if (DecodeSFR(ArgStr[2].str.p_str, &AdrByte))
  4117.   {
  4118.     DecodeAdr(&ArgStr[1], MModAll);
  4119.     switch (AdrMode)
  4120.     {
  4121.       case ModReg8:
  4122.         if ((AdrPart != 7) || (AdrByte == 1)) WrError(ErrNum_InvAddrMode);
  4123.         else
  4124.         {
  4125.           BAsmCode[0] = 0xcd + ((AdrByte & 3) << 4);
  4126.           BAsmCode[1] = 0xd0;
  4127.           CodeLen = 2;
  4128.         }
  4129.         break;
  4130.       case ModReg16:
  4131.         if ((AdrByte != 1) || (AdrPart != 2) || (PrefixCnt != 0)) WrError(ErrNum_InvAddrMode);
  4132.         else
  4133.         {
  4134.           BAsmCode[0] = 0xed;
  4135.           BAsmCode[1] = 0xc0;
  4136.           CodeLen = 2;
  4137.         }
  4138.         break;
  4139.       default:
  4140.         if (AdrMode != ModNone) WrError(ErrNum_InvAddrMode);
  4141.     }
  4142.   }
  4143.   else
  4144.     WrError(ErrNum_InvAddrMode);
  4145. }
  4146.  
  4147. static void DecodeRESC_SETC(Word Code)
  4148. {
  4149.   if (ChkArgCnt(1, 1)
  4150.    && chk_core_mask(e_core_mask_z380))
  4151.   {
  4152.     Byte AdrByte = 0xff;
  4153.  
  4154.     NLS_UpString(ArgStr[1].str.p_str);
  4155.     if (!strcmp(ArgStr[1].str.p_str, "LW")) AdrByte = 1;
  4156.     else if (!strcmp(ArgStr[1].str.p_str, "LCK")) AdrByte = 2;
  4157.     else if (!strcmp(ArgStr[1].str.p_str, "XM")) AdrByte = 3;
  4158.     else WrError(ErrNum_InvCtrlReg);
  4159.     if (AdrByte != 0xff)
  4160.     {
  4161.       CodeLen = 2;
  4162.       BAsmCode[0] = 0xcd + (AdrByte << 4);
  4163.       BAsmCode[1] = 0xf7 + Code;
  4164.     }
  4165.   }
  4166. }
  4167.  
  4168. static void DecodeDDIR(Word Code)
  4169. {
  4170.   UNUSED(Code);
  4171.  
  4172.   if (ChkArgCnt(1, 2)
  4173.    && chk_core_mask(e_core_mask_z380))
  4174.   {
  4175.     Boolean OK;
  4176.     int z;
  4177.  
  4178.     OK = True;
  4179.     for (z = 1; z <= ArgCnt; z++)
  4180.     {
  4181.       if (OK)
  4182.       {
  4183.         OK = ExtendPrefix(&CurrPrefix, DecodePrefix(ArgStr[z].str.p_str));
  4184.         if (!OK) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[z]);
  4185.       }
  4186.     }
  4187.     if (OK)
  4188.     {
  4189.       GetPrefixCode(CurrPrefix, BAsmCode + 0, BAsmCode + 1);
  4190.       CodeLen = 2;
  4191.     }
  4192.   }
  4193. }
  4194.  
  4195. /*!------------------------------------------------------------------------
  4196.  * \fn     CodeLEA(Word Code)
  4197.  * \brief  handle LEA instruction
  4198.  * ------------------------------------------------------------------------ */
  4199.  
  4200. static void CodeLEA(Word Code)
  4201. {
  4202.   Byte dest_reg, ini_prefix_cnt = PrefixCnt,
  4203.        dest_prefix, src_prefix;
  4204.  
  4205.   UNUSED(Code);
  4206.  
  4207.   if (!is_ez80())
  4208.   {
  4209.     char Str[100];
  4210.     as_snprintf(Str, sizeof(Str), "%seZ80%s", getmessage(Num_ErrMsgOnlyCPUSupported1), getmessage(Num_ErrMsgOnlyCPUSupported2));
  4211.     WrXError(ErrNum_InstructionNotSupported, Str);
  4212.     return;
  4213.   }
  4214.   if (!ChkArgCnt(2, 2))
  4215.     return;
  4216.  
  4217.   if (DecodeAdr(&ArgStr[1], MModReg16) != ModReg16)
  4218.     return;
  4219.   if (AdrPart == SPReg)
  4220.   {
  4221.     WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  4222.     return;
  4223.   }
  4224.   dest_reg = AdrPart;
  4225.   dest_prefix = (PrefixCnt > ini_prefix_cnt) ? remove_prefix(0) : 0x00;
  4226.   if (DecodeAdr(&ArgStr[2], MModReg8 | MModImmIsAbs) != ModReg8)
  4227.     return;
  4228.   if ((AdrPart != MReg) || (PrefixCnt == ini_prefix_cnt))
  4229.   {
  4230.     WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  4231.     return;
  4232.   }
  4233.   src_prefix = remove_prefix(0);
  4234.   CodeLen = PrefixCnt;
  4235.   BAsmCode[CodeLen++] = 0xed;
  4236.   if ((dest_prefix == IXPrefix) && (src_prefix == IXPrefix))
  4237.     BAsmCode[CodeLen++] = 0x32;
  4238.   else if ((dest_prefix == IYPrefix) && (src_prefix == IXPrefix))
  4239.     BAsmCode[CodeLen++] = 0x55;
  4240.   else if ((dest_prefix == IXPrefix) && (src_prefix == IYPrefix))
  4241.     BAsmCode[CodeLen++] = 0x54;
  4242.   else if ((dest_prefix == IYPrefix) && (src_prefix == IYPrefix))
  4243.     BAsmCode[CodeLen++] = 0x33;
  4244.   else if (src_prefix == IXPrefix)
  4245.     BAsmCode[CodeLen++] = 0x02 | (dest_reg << 4);
  4246.   else
  4247.     BAsmCode[CodeLen++] = 0x03 | (dest_reg << 4);
  4248.   memcpy(&BAsmCode[CodeLen], AdrVals, AdrCnt);
  4249.   CodeLen += AdrCnt;
  4250. }
  4251.  
  4252. /*!------------------------------------------------------------------------
  4253.  * \fn     CodePEA(Word Code)
  4254.  * \brief  handle PEA instruction
  4255.  * ------------------------------------------------------------------------ */
  4256.  
  4257. static void CodePEA(Word Code)
  4258. {
  4259.   Byte ini_prefix_cnt = PrefixCnt,
  4260.        src_prefix;
  4261.  
  4262.   UNUSED(Code);
  4263.  
  4264.   if (!is_ez80())
  4265.   {
  4266.     char Str[100];
  4267.     as_snprintf(Str, sizeof(Str), "%seZ80%s", getmessage(Num_ErrMsgOnlyCPUSupported1), getmessage(Num_ErrMsgOnlyCPUSupported2));
  4268.     WrXError(ErrNum_InstructionNotSupported, Str);
  4269.     return;
  4270.   }
  4271.   if (!ChkArgCnt(1, 1))
  4272.     return;
  4273.  
  4274.   if (DecodeAdr(&ArgStr[1], MModReg8 | MModImmIsAbs) != ModReg8)
  4275.     return;
  4276.   if ((AdrPart != MReg) || (PrefixCnt == ini_prefix_cnt))
  4277.   {
  4278.     WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  4279.     return;
  4280.   }
  4281.   src_prefix = remove_prefix(0);
  4282.   CodeLen = PrefixCnt;
  4283.   BAsmCode[CodeLen++] = 0xed;
  4284.   BAsmCode[CodeLen++] = (src_prefix == IXPrefix) ? 0x65 : 0x66;
  4285.   memcpy(&BAsmCode[CodeLen], AdrVals, AdrCnt);
  4286.   CodeLen += AdrCnt;
  4287. }
  4288.  
  4289. static void DecodePORT(Word Code)
  4290. {
  4291.   UNUSED(Code);
  4292.  
  4293.   CodeEquate(SegIO, 0, PortEnd());
  4294. }
  4295.  
  4296. static void DecodeLDI_LDD(Word Code)
  4297. {
  4298.   if (ChkArgCnt(2,2)
  4299.    && chk_core_mask(e_core_mask_sharp))
  4300.   {
  4301.     DecodeAdr(&ArgStr[1], MModReg8);
  4302.     if (AdrMode == ModReg8)
  4303.       switch (AdrPart)
  4304.       {
  4305.         case 7:
  4306.           DecodeAdr(&ArgStr[2], MModReg8);
  4307.           if (AdrMode == ModReg8)
  4308.           {
  4309.             if (AdrPart != 6) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  4310.             else
  4311.             {
  4312.               BAsmCode[0] = Code | 0x08;
  4313.               CodeLen = 1;
  4314.             }
  4315.           }
  4316.           break;
  4317.         case 6:
  4318.           DecodeAdr(&ArgStr[2], MModReg8);
  4319.           if (AdrMode == ModReg8)
  4320.           {
  4321.             if (AdrPart != AccReg) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  4322.             else
  4323.             {
  4324.               BAsmCode[0] = Code;
  4325.               CodeLen = 1;
  4326.             }
  4327.           }
  4328.           break;
  4329.         default:
  4330.           WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  4331.       }
  4332.   }
  4333. }
  4334.  
  4335. static void DecodePRWINS(Word Code)
  4336. {
  4337.   UNUSED(Code);
  4338.  
  4339.   if (chk_core_mask(e_core_mask_z180))
  4340.   {
  4341.     printf("\nCBAR 0%02xh BBR 0%02xh CBR 0%02xh\n",
  4342.            (unsigned)Reg_CBAR, (unsigned)Reg_BBR, (unsigned)Reg_CBR);
  4343.     cpu_2_phys_area_dump(SegCode, stdout);
  4344.   }
  4345. }
  4346.  
  4347. /*!------------------------------------------------------------------------
  4348.  * \fn     valid_cbar(void)
  4349.  * \brief  allowed CBAR value?
  4350.  * \return True if valid
  4351.  * ------------------------------------------------------------------------ */
  4352.  
  4353. static Boolean valid_cbar(void)
  4354. {
  4355.   return ((Reg_CBAR & 0x0f) <= ((Reg_CBAR >> 4) & 0x0f));
  4356. }
  4357.  
  4358. /*!------------------------------------------------------------------------
  4359.  * \fn     update_z180_areas(void)
  4360.  * \brief  recompute Z180 mapped areas
  4361.  * ------------------------------------------------------------------------ */
  4362.  
  4363. static void update_z180_areas(void)
  4364. {
  4365.   if (valid_cbar())
  4366.   {
  4367.     Word common_area_start = ((Reg_CBAR >> 4) & 0x0f) << 12,
  4368.          bank_area_start = (Reg_CBAR & 0x0f) << 12;
  4369.  
  4370.     cpu_2_phys_area_clear(SegCode);
  4371.  
  4372.     /* Common Area 0 */
  4373.  
  4374.     if (bank_area_start > 0)
  4375.       cpu_2_phys_area_add(SegCode, 0, 0, bank_area_start);
  4376.  
  4377.     /* Bank Area */
  4378.  
  4379.     if (common_area_start > bank_area_start)
  4380.       cpu_2_phys_area_add(SegCode, bank_area_start, (Reg_BBR << 12) + bank_area_start, common_area_start - bank_area_start);
  4381.  
  4382.     /* Common Area 1 - always present since upper nibble of CBAR is always < 0x10 */
  4383.  
  4384.     cpu_2_phys_area_add(SegCode, common_area_start, (Reg_CBR << 12) + common_area_start, 0x10000ul - common_area_start);
  4385.  
  4386.     /* this *SHOULD* be a NOP, since completely filled the 64K CPU space: */
  4387.  
  4388.     cpu_2_phys_area_fill(SegCode, 0, 0xffff);
  4389.   }
  4390. }
  4391.  
  4392. /*!------------------------------------------------------------------------
  4393.  * \fn     check_cbar(void)
  4394.  * \brief  check valid CBAR value
  4395.  * ------------------------------------------------------------------------ */
  4396.  
  4397. static void check_cbar(void)
  4398. {
  4399.   if (valid_cbar())
  4400.     update_z180_areas();
  4401.   else
  4402.     WrError(ErrNum_InvCBAR);
  4403. }
  4404.  
  4405. /*==========================================================================*/
  4406. /* Codetabellenerzeugung */
  4407.  
  4408. static void AddFixed(const char *NewName, cpu_core_mask_t core_mask, Word NewCode)
  4409. {
  4410.   order_array_rsv_end(FixedOrders, BaseOrder);
  4411.   FixedOrders[InstrZ].core_mask = core_mask;
  4412.   FixedOrders[InstrZ].Code = NewCode;
  4413.   AddInstTable(InstTable, NewName, InstrZ++, DecodeFixed);
  4414. }
  4415.  
  4416. static void AddAcc(const char *NewName, cpu_core_mask_t core_mask, Word NewCode)
  4417. {
  4418.   order_array_rsv_end(AccOrders, BaseOrder);
  4419.   AccOrders[InstrZ].core_mask = core_mask;
  4420.   AccOrders[InstrZ].Code = NewCode;
  4421.   AddInstTable(InstTable, NewName, InstrZ++, DecodeAcc);
  4422. }
  4423.  
  4424. static void AddHL(const char *NewName, cpu_core_mask_t core_mask, Word NewCode)
  4425. {
  4426.   order_array_rsv_end(HLOrders, BaseOrder);
  4427.   HLOrders[InstrZ].core_mask = core_mask;
  4428.   HLOrders[InstrZ].Code = NewCode;
  4429.   AddInstTable(InstTable, NewName, InstrZ++, DecodeHL);
  4430. }
  4431.  
  4432. static void AddALU(const char *Name8, const char *Name16, Byte Code)
  4433. {
  4434.   AddInstTable(InstTable, Name8 , Code, DecodeALU8);
  4435.   AddInstTable(InstTable, Name16, Code, DecodeALU16);
  4436. }
  4437.  
  4438. static void AddShift(const char *Name8, const char *Name16, Byte Code)
  4439. {
  4440.   AddInstTable(InstTable, Name8 , Code, DecodeShift8);
  4441.   if (Name16)
  4442.     AddInstTable(InstTable, Name16, Code, DecodeShift16);
  4443. }
  4444.  
  4445. static void AddBit(const char *NName, Word Code)
  4446. {
  4447.   AddInstTable(InstTable, NName, Code, DecodeBit);
  4448. }
  4449.  
  4450. static void AddCondition(const char *NewName, Byte NewCode)
  4451. {
  4452.   order_array_rsv_end(Conditions, Condition);
  4453.   Conditions[InstrZ].Name = NewName;
  4454.   Conditions[InstrZ++].Code = NewCode;
  4455. }
  4456.  
  4457. static void InitFields(void)
  4458. {
  4459.   InstTable = CreateInstTable(203);
  4460.  
  4461.   add_null_pseudo(InstTable);
  4462.  
  4463.   AddInstTable(InstTable, "LD" , 0, DecodeLD);
  4464.   AddInstTable(InstTable, "LDW", 1, DecodeLD);
  4465.   AddInstTable(InstTable, "LDHL", 0, DecodeLDHL);
  4466.   AddInstTable(InstTable, "LDH", 0, DecodeLDH);
  4467.   AddInstTable(InstTable, "LDX", 0, DecodeLDX);
  4468.   AddInstTable(InstTable, "ADD", 0, DecodeADD);
  4469.   AddInstTable(InstTable, "ADDW", 0, DecodeADDW);
  4470.   AddInstTable(InstTable, "ADC" , 0, DecodeADC_SBC);
  4471.   AddInstTable(InstTable, "SBC" , 1, DecodeADC_SBC);
  4472.   AddInstTable(InstTable, "ADCW", 0, DecodeADCW_SBCW);
  4473.   AddInstTable(InstTable, "SBCW",16, DecodeADCW_SBCW);
  4474.   AddInstTable(InstTable, "INC" , 0, DecodeINC_DEC);
  4475.   AddInstTable(InstTable, "DEC" , 1, DecodeINC_DEC);
  4476.   AddInstTable(InstTable, "INCW", 2, DecodeINC_DEC);
  4477.   AddInstTable(InstTable, "DECW", 3, DecodeINC_DEC);
  4478.   AddInstTable(InstTable, "MLT" , 0, DecodeMLT);
  4479.   AddInstTable(InstTable, "DIVUW" , 0x28, DecodeMULT_DIV);
  4480.   AddInstTable(InstTable, "MULTW" , 0x00, DecodeMULT_DIV);
  4481.   AddInstTable(InstTable, "MULTUW", 0x08, DecodeMULT_DIV);
  4482.   AddInstTable(InstTable, "TST", 0, DecodeTST);
  4483.   AddInstTable(InstTable, "SWAP", 0, DecodeSWAP);
  4484.   AddInstTable(InstTable, "PUSH", 4, DecodePUSH_POP);
  4485.   AddInstTable(InstTable, "POP" , 0, DecodePUSH_POP);
  4486.   AddInstTable(InstTable, "EX"  , 0, DecodeEX);
  4487.   AddInstTable(InstTable, "TSTI", 0, DecodeTSTI);
  4488.   AddInstTable(InstTable, "IN"  , 0, DecodeIN_OUT);
  4489.   AddInstTable(InstTable, "OUT" , 1, DecodeIN_OUT);
  4490.   AddInstTable(InstTable, "INW"  , 0, DecodeINW_OUTW);
  4491.   AddInstTable(InstTable, "OUTW" , 1, DecodeINW_OUTW);
  4492.   AddInstTable(InstTable, "IN0"  , 0, DecodeIN0_OUT0);
  4493.   AddInstTable(InstTable, "OUT0" , 1, DecodeIN0_OUT0);
  4494.   AddInstTable(InstTable, "INA"  , 8, DecodeINA_INAW_OUTA_OUTAW);
  4495.   AddInstTable(InstTable, "INAW" , 9, DecodeINA_INAW_OUTA_OUTAW);
  4496.   AddInstTable(InstTable, "OUTA" , 0, DecodeINA_INAW_OUTA_OUTAW);
  4497.   AddInstTable(InstTable, "OUTAW", 1, DecodeINA_INAW_OUTA_OUTAW);
  4498.   AddInstTable(InstTable, "TSTIO", 0, DecodeTSTIO);
  4499.   AddInstTable(InstTable, "RET" , 0, DecodeRET);
  4500.   AddInstTable(InstTable, "JP" , 0, DecodeJP);
  4501.   AddInstTable(InstTable, "CALL", 0, DecodeCALL);
  4502.   AddInstTable(InstTable, "JR" , 0, DecodeJR);
  4503.   AddInstTable(InstTable, "J" , 0, DecodeJ);
  4504.   AddInstTable(InstTable, "CALR", 0, DecodeCALR);
  4505.   AddInstTable(InstTable, "DJNZ", 0, DecodeDJNZ);
  4506.   AddInstTable(InstTable, "RST", 0, DecodeRST);
  4507.   AddInstTable(InstTable, "DI", 0, DecodeEI_DI);
  4508.   AddInstTable(InstTable, "EI", 8, DecodeEI_DI);
  4509.   AddInstTable(InstTable, "IM", 0, DecodeIM);
  4510.   AddInstTable(InstTable, "LDCTL", 0, DecodeLDCTL);
  4511.   AddInstTable(InstTable, "RESC", 8, DecodeRESC_SETC);
  4512.   AddInstTable(InstTable, "SETC", 0, DecodeRESC_SETC);
  4513.   AddInstTable(InstTable, "DDIR", 0, DecodeDDIR);
  4514.   AddInstTable(InstTable, "PORT", 0, DecodePORT);
  4515.   AddInstTable(InstTable, "DEFB", eIntPseudoFlag_LittleEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString, DecodeIntelDB);
  4516.   AddInstTable(InstTable, "DEFW", eIntPseudoFlag_LittleEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_AllowFloat, DecodeIntelDW);
  4517.  
  4518.   InstrZ = 0;
  4519.   AddCondition("NZ", 0); AddCondition("Z" , 1);
  4520.   AddCondition("NC", 2); AddCondition("C" , 3);
  4521.   if (!is_sharp())
  4522.   {
  4523.     AddCondition("PO", 4); AddCondition("NV", 4);
  4524.     AddCondition("PE", 5); AddCondition("V" , 5);
  4525.     AddCondition("P" , 6); AddCondition("NS", 6);
  4526.     AddCondition("M" , 7); AddCondition("S" , 7);
  4527.   }
  4528.   AddCondition(NULL, 0);
  4529.  
  4530.   InstrZ = 0;
  4531.   AddFixed("EXX"   , e_core_mask_no_sharp  , 0x00d9);
  4532.   if (is_sharp())
  4533.   {
  4534.     AddInstTable(InstTable, "LDI", 0x22, DecodeLDI_LDD);
  4535.     AddInstTable(InstTable, "LDD", 0x32, DecodeLDI_LDD);
  4536.   }
  4537.   else
  4538.   {
  4539.     AddFixed("LDI"  , e_core_mask_no_sharp  , 0xeda0);
  4540.     AddFixed("LDD"  , e_core_mask_no_sharp  , 0xeda8);
  4541.   }
  4542.   AddFixed("LDIR"  , e_core_mask_no_sharp  , 0xedb0);
  4543.   AddFixed("LDDR"  , e_core_mask_no_sharp  , 0xedb8);
  4544.   AddFixed("CPI"   , e_core_mask_no_sharp  , 0xeda1);
  4545.   AddFixed("CPIR"  , e_core_mask_no_sharp  , 0xedb1);
  4546.   AddFixed("CPD"   , e_core_mask_no_sharp  , 0xeda9);
  4547.   AddFixed("CPDR"  , e_core_mask_no_sharp  , 0xedb9);
  4548.   AddFixed("RLCA"  , e_core_mask_all       , 0x0007);
  4549.   AddFixed("RRCA"  , e_core_mask_all       , 0x000f);
  4550.   AddFixed("RLA"   , e_core_mask_all       , 0x0017);
  4551.   AddFixed("RRA"   , e_core_mask_all       , 0x001f);
  4552.   AddFixed("RLD"   , e_core_mask_no_sharp  , 0xed6f);
  4553.   AddFixed("RRD"   , e_core_mask_no_sharp  , 0xed67);
  4554.   AddFixed("DAA"   , e_core_mask_all       , 0x0027);
  4555.   AddFixed("CCF"   , e_core_mask_all       , 0x003f);
  4556.   AddFixed("SCF"   , e_core_mask_all       , 0x0037);
  4557.   AddFixed("NOP"   , e_core_mask_all       , 0x0000);
  4558.   AddFixed("HALT"  , e_core_mask_all       , 0x0076);
  4559.   /* TODO: allow only no and .L as eZ80 attribute */
  4560.   AddFixed("RETI"  , e_core_mask_all       , is_sharp() ? 0x00d9 : 0xed4d);
  4561.   /* TODO: allow only no and .L as eZ80 attribute */
  4562.   AddFixed("RETN"  , e_core_mask_no_sharp  , 0xed45);
  4563.   AddFixed("INI"   , e_core_mask_no_sharp  , 0xeda2);
  4564.   AddFixed("INIR"  , e_core_mask_no_sharp  , 0xedb2);
  4565.   AddFixed("IND"   , e_core_mask_no_sharp  , 0xedaa);
  4566.   AddFixed("INDR"  , e_core_mask_no_sharp  , 0xedba);
  4567.   AddFixed("IND2"  , e_core_mask_ez80      , 0xed8c);
  4568.   AddFixed("IND2R" , e_core_mask_ez80      , 0xed9c);
  4569.   AddFixed("INDM"  , e_core_mask_ez80      , 0xed8a);
  4570.   AddFixed("INDMR" , e_core_mask_ez80      , 0xed9a);
  4571.   AddFixed("INI2"  , e_core_mask_ez80      , 0xed84);
  4572.   AddFixed("INI2R" , e_core_mask_ez80      , 0xed94);
  4573.   AddFixed("INIM"  , e_core_mask_ez80      , 0xed82);
  4574.   AddFixed("INIMR" , e_core_mask_ez80      , 0xed92);
  4575.   AddFixed("OTD2R" , e_core_mask_ez80      , 0xedbc);
  4576.   AddFixed("OTI2R" , e_core_mask_ez80      , 0xedb4);
  4577.   AddFixed("OUTD2" , e_core_mask_ez80      , 0xedac);
  4578.   AddFixed("OUTI2" , e_core_mask_ez80      , 0xeda4);
  4579.   AddFixed("RSMIX" , e_core_mask_ez80      , 0xed7e);
  4580.   AddFixed("STMIX" , e_core_mask_ez80      , 0xed7d);
  4581.   AddFixed("OUTI"  , e_core_mask_no_sharp  , 0xeda3);
  4582.   AddFixed("OTIR"  , e_core_mask_no_sharp  , 0xedb3);
  4583.   AddFixed("OUTD"  , e_core_mask_no_sharp  , 0xedab);
  4584.   AddFixed("OTDR"  , e_core_mask_no_sharp  , 0xedbb);
  4585.   AddFixed("EXA"   , e_core_mask_no_sharp  , 0x0008);
  4586.   AddFixed("EXD"   , e_core_mask_no_sharp  , 0x00eb);
  4587.   AddFixed("SLP"   , e_core_mask_min_z180  , 0xed76);
  4588.   AddFixed("OTIM"  , e_core_mask_min_z180  , 0xed83);
  4589.   AddFixed("OTIMR" , e_core_mask_min_z180  , 0xed93);
  4590.   AddFixed("OTDM"  , e_core_mask_min_z180  , 0xed8b);
  4591.   AddFixed("OTDMR" , e_core_mask_min_z180  , 0xed9b);
  4592.   AddFixed("BTEST" , e_core_mask_z380      , 0xedcf);
  4593.   AddFixed("EXALL" , e_core_mask_z380      , 0xedd9);
  4594.   AddFixed("EXXX"  , e_core_mask_z380      , 0xddd9);
  4595.   AddFixed("EXXY"  , e_core_mask_z380      , 0xfdd9);
  4596.   AddFixed("INDW"  , e_core_mask_z380      , 0xedea);
  4597.   AddFixed("INDRW" , e_core_mask_z380      , 0xedfa);
  4598.   AddFixed("INIW"  , e_core_mask_z380      , 0xede2);
  4599.   AddFixed("INIRW" , e_core_mask_z380      , 0xedf2);
  4600.   AddFixed("LDDW"  , e_core_mask_z380      , 0xede8);
  4601.   AddFixed("LDDRW" , e_core_mask_z380      , 0xedf8);
  4602.   AddFixed("LDIW"  , e_core_mask_z380      , 0xede0);
  4603.   AddFixed("LDIRW" , e_core_mask_z380      , 0xedf0);
  4604.   AddFixed("MTEST" , e_core_mask_z380      , 0xddcf);
  4605.   AddFixed("OTDRW" , e_core_mask_z380      , 0xedfb);
  4606.   AddFixed("OTIRW" , e_core_mask_z380      , 0xedf3);
  4607.   AddFixed("OUTDW" , e_core_mask_z380      , 0xedeb);
  4608.   AddFixed("OUTIW" , e_core_mask_z380      , 0xede3);
  4609.   AddFixed("RETB"  , e_core_mask_z380      , 0xed55);
  4610.   AddFixed("STOP"  , e_core_mask_sharp     , 0x0010);
  4611.  
  4612.   AddInstTable(InstTable, "INDRX", 0xedca, decode_ez80_xio);
  4613.   AddInstTable(InstTable, "INIRX", 0xedc2, decode_ez80_xio);
  4614.   AddInstTable(InstTable, "OTDRX", 0xedcb, decode_ez80_xio);
  4615.   AddInstTable(InstTable, "OTIRX", 0xedc3, decode_ez80_xio);
  4616.  
  4617.   InstrZ = 0;
  4618.   AddAcc("CPL"  , e_core_mask_all , 0x002f);
  4619.   AddAcc("NEG"  , e_core_mask_no_sharp   , 0xed44);
  4620.   AddAcc("EXTS" , e_core_mask_z380  , 0xed65);
  4621.  
  4622.   InstrZ = 0;
  4623.   AddHL("CPLW" , e_core_mask_z380, 0xdd2f);
  4624.   AddHL("NEGW" , e_core_mask_z380, 0xed54);
  4625.   AddHL("EXTSW", e_core_mask_z380, 0xed75);
  4626.  
  4627.   AddALU("SUB", "SUBW", 2); AddALU("AND", "ANDW", 4);
  4628.   AddALU("OR" , "ORW" , 6); AddALU("XOR", "XORW", 5);
  4629.   AddALU("CP" , "CPW" , 7);
  4630.  
  4631.   AddShift("RLC" , "RLCW" , 0); AddShift("RRC", "RRCW", 1);
  4632.   AddShift("RL"  , "RLW"  , 2); AddShift("RR" , "RRW" , 3);
  4633.   AddShift("SLA" , "SLAW" , 4); AddShift("SRA", "SRAW", 5);
  4634.   AddShift("SLIA", NULL   , 6); AddShift("SRL", "SRLW", 7);
  4635.   AddShift("SLS" , NULL   , 6); AddShift("SLI", NULL  , 6);
  4636.   AddShift("SL1" , NULL   , 6);
  4637.  
  4638.   AddBit("BIT", 0); AddBit("RES", 1); AddBit("SET", 2);
  4639.  
  4640.   AddInstTable(InstTable, "LEA", 0, CodeLEA);
  4641.   AddInstTable(InstTable, "PEA", 0, CodePEA);
  4642.  
  4643.   AddInstTable(InstTable, "REG" , 0, CodeREG);
  4644.  
  4645.   AddInstTable(InstTable, "PRWINS", 0, DecodePRWINS);
  4646.  
  4647.   AddIntelPseudo(InstTable, eIntPseudoFlag_LittleEndian);
  4648. }
  4649.  
  4650. static void DeinitFields(void)
  4651. {
  4652.   order_array_free(Conditions);
  4653.   order_array_free(FixedOrders);
  4654.   order_array_free(AccOrders);
  4655.   order_array_free(HLOrders);
  4656.  
  4657.   DestroyInstTable(InstTable);
  4658. }
  4659.  
  4660. /*=========================================================================*/
  4661.  
  4662. static void StripPref(const char *Arg, Byte Opcode)
  4663. {
  4664.   char *ptr, *ptr2;
  4665.   int z;
  4666.  
  4667.   /* do we have a prefix ? */
  4668.  
  4669.   if (!strcmp(OpPart.str.p_str, Arg))
  4670.   {
  4671.     /* add to code */
  4672.  
  4673.     BAsmCode[PrefixCnt++] = Opcode;
  4674.     StrCompReset(&OpPart);
  4675.  
  4676.     /* cut true opcode out of next argument */
  4677.  
  4678.     if (ArgCnt)
  4679.     {
  4680.       /* look for end of string */
  4681.  
  4682.       for (ptr = ArgStr[1].str.p_str; *ptr; ptr++)
  4683.         if (as_isspace(*ptr))
  4684.           break;
  4685.  
  4686.       /* look for beginning of next string */
  4687.  
  4688.       for (ptr2 = ptr; *ptr2; ptr2++)
  4689.         if (!as_isspace(*ptr2))
  4690.           break;
  4691.  
  4692.       /* copy out new opcode */
  4693.  
  4694.       OpPart.Pos.StartCol = ArgStr[1].Pos.StartCol;
  4695.       OpPart.Pos.Len = strmemcpy(OpPart.str.p_str, STRINGSIZE, ArgStr[1].str.p_str, ptr - ArgStr[1].str.p_str);
  4696.       NLS_UpString(OpPart.str.p_str);
  4697.  
  4698.       /* cut down arg or eliminate it completely */
  4699.  
  4700.       if (*ptr2)
  4701.       {
  4702.         strmov(ArgStr[1].str.p_str, ptr2);
  4703.         ArgStr[1].Pos.StartCol += ptr2 - ArgStr[1].str.p_str;
  4704.         ArgStr[1].Pos.Len -= ptr2 - ArgStr[1].str.p_str;
  4705.       }
  4706.       else
  4707.       {
  4708.         for (z = 1; z < ArgCnt; z++)
  4709.           StrCompCopy(&ArgStr[z], &ArgStr[z + 1]);
  4710.         ArgCnt--;
  4711.       }
  4712.     }
  4713.  
  4714.     /* if no further argument, that's all folks */
  4715.  
  4716.     else
  4717.       CodeLen = PrefixCnt;
  4718.   }
  4719. }
  4720.  
  4721. /*!------------------------------------------------------------------------
  4722.  * \fn     decode_attrpart_ez80(void)
  4723.  * \brief  decode eZ80-style attribute part for ADL mode overrides
  4724.  * \return True if success
  4725.  * ------------------------------------------------------------------------ */
  4726.  
  4727. static Boolean decode_attrpart_ez80(void)
  4728. {
  4729.   int attr_index = 0;
  4730.   const char *p_attr;
  4731.  
  4732.   AttrPartOpSize[0] =
  4733.   AttrPartOpSize[1] = eSymbolSizeUnknown;
  4734.   for (p_attr = AttrPart.str.p_str; *p_attr; p_attr++)
  4735.     switch (as_toupper(*p_attr))
  4736.     {
  4737.       case 'S':
  4738.       case 'L':
  4739.         if (AttrPartOpSize[attr_index] != eSymbolSizeUnknown)
  4740.           return False;
  4741.         AttrPartOpSize[attr_index] = (as_toupper(*p_attr) == 'L') ? eSymbolSize24Bit : eSymbolSize16Bit;
  4742.         break;
  4743.       case 'I':
  4744.         attr_index = 1;
  4745.         break;
  4746.       default:
  4747.         return False;
  4748.     }
  4749.   return True;
  4750. }
  4751.  
  4752. static void MakeCode_Z80(void)
  4753. {
  4754.   PrefixCnt = 0;
  4755.   OpSize = 0xff;
  4756.   MayLW = False;
  4757.  
  4758.   switch (p_curr_cpu_props->core)
  4759.   {
  4760.     case e_core_r2000:
  4761.       /* Rabbit 2000 prefixes */
  4762.       StripPref("ALTD", 0x76);
  4763.       if (!*OpPart.str.p_str) return;
  4764.       break;
  4765.     case e_core_z380:
  4766.       /* Z380: letzten Praefix umkopieren */
  4767.       LastPrefix = CurrPrefix;
  4768.       CurrPrefix = Pref_IN_N;
  4769.       break;
  4770.     case e_core_ez80:
  4771.     {
  4772.       int z, pref_index = 0;
  4773.       Boolean need_prefix = False;
  4774.       tSymbolSize def_size = Reg_ADL ? eSymbolSize24Bit : eSymbolSize16Bit;
  4775.  
  4776.       /* eZ80: Suffix Completion */
  4777.       for (z = 0; z < 2; z++)
  4778.       {
  4779.         if (AttrPartOpSize[z] == eSymbolSizeUnknown)
  4780.           AttrPartOpSize[z] = def_size;
  4781.         else
  4782.           need_prefix = True;
  4783.         pref_index |= (AttrPartOpSize[z] == eSymbolSize24Bit) << z;
  4784.       }
  4785.       if (need_prefix)
  4786.         BAsmCode[PrefixCnt++] = 0x40 | (pref_index << 3) | pref_index;
  4787.       break;
  4788.     }
  4789.     default:
  4790.       break;
  4791.   }
  4792.  
  4793.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  4794.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  4795. }
  4796.  
  4797. static void InitCode_Z80(void)
  4798. {
  4799.   Reg_CBAR = 0xf0;
  4800.   Reg_CBR = Reg_BBR = 0x00;
  4801.   Reg_ADL = 0;
  4802. }
  4803.  
  4804. static Boolean IsDef_Z80(void)
  4805. {
  4806.   return Memo("PORT") || Memo("REG");
  4807. }
  4808.  
  4809. /* Treat special case of AF' which is no quoting: */
  4810.  
  4811. static Boolean QualifyQuote_Z80(const char *pStart, const char *pQuotePos)
  4812. {
  4813.   if ((*pQuotePos == '\'')
  4814.    && (pQuotePos >= pStart + 2)
  4815.    && (as_toupper(*(pQuotePos - 2)) == 'A')
  4816.    && (as_toupper(*(pQuotePos - 1)) == 'F'))
  4817.     return False;
  4818.   return True;
  4819. }
  4820.  
  4821. /*!------------------------------------------------------------------------
  4822.  * \fn     DissectReg_Z80(char *p_dest, size_t dest_size, tRegInt value, tSymbolSize inp_size)
  4823.  * \brief  dissect register symbols - Z80 variant
  4824.  * \param  p_dest destination buffer
  4825.  * \param  dest_size destination buffer size
  4826.  * \param  value numeric register value
  4827.  * \param  inp_size register size
  4828.  * ------------------------------------------------------------------------ */
  4829.  
  4830. static void DissectReg_Z80(char *p_dest, size_t dest_size, tRegInt value, tSymbolSize inp_size)
  4831. {
  4832.   switch (inp_size)
  4833.   {
  4834.     case eSymbolSize8Bit:
  4835.       if ((value & 0xf0) == (IXPrefix & 0xf0))
  4836.         as_snprintf(p_dest, dest_size, "%s%c", Reg16Names[4], (value & 1) ? 'L' : (is_z80u() ? 'H' : 'U'));
  4837.       else if ((value & 0xf0) == (IYPrefix & 0xf0))
  4838.         as_snprintf(p_dest, dest_size, "%s%c", Reg16Names[5], (value & 1) ? 'L' : (is_z80u() ? 'H' : 'U'));
  4839.       else if ((value < 8) && (value != 6))
  4840.         as_snprintf(p_dest, dest_size, "%c", Reg8Names[value]);
  4841.       else
  4842.         goto none;
  4843.       break;
  4844.     case eSymbolSize16Bit:
  4845.       if ((value & 0xf0) == (IXPrefix & 0xf0))
  4846.         as_snprintf(p_dest, dest_size, Reg16Names[4]);
  4847.       else if ((value & 0xf0) == (IYPrefix & 0xf0))
  4848.         as_snprintf(p_dest, dest_size, Reg16Names[5]);
  4849.       else if (value < 4)
  4850.         as_snprintf(p_dest, dest_size, "%s", Reg16Names[value]);
  4851.       else
  4852.         goto none;
  4853.       break;
  4854.     none:
  4855.     default:
  4856.       as_snprintf(p_dest, dest_size, "%d-%u", (int)inp_size, (unsigned)value);
  4857.   }
  4858. }
  4859.  
  4860. /*!------------------------------------------------------------------------
  4861.  * \fn     InternSymbol_Z80(char *p_arg, TempResult *p_result)
  4862.  * \brief  handle built-in (register) symbols for Z80
  4863.  * \param  p_arg source argument
  4864.  * \param  p_result result buffer
  4865.  * ------------------------------------------------------------------------ */
  4866.  
  4867. static void InternSymbol_Z80(char *p_arg, TempResult *p_result)
  4868. {
  4869.   Byte reg_num;
  4870.  
  4871.   if (DecodeReg8Core(p_arg, &reg_num))
  4872.   {
  4873.     p_result->Typ = TempReg;
  4874.     p_result->DataSize = eSymbolSize8Bit;
  4875.     p_result->Contents.RegDescr.Reg = reg_num;
  4876.     p_result->Contents.RegDescr.Dissect = DissectReg_Z80;
  4877.     p_result->Contents.RegDescr.compare = NULL;
  4878.   }
  4879.   else if (DecodeReg16Core(p_arg, &reg_num))
  4880.   {
  4881.     p_result->Typ = TempReg;
  4882.     p_result->DataSize = eSymbolSize16Bit;
  4883.     p_result->Contents.RegDescr.Reg = reg_num;
  4884.     p_result->Contents.RegDescr.Dissect = DissectReg_Z80;
  4885.     p_result->Contents.RegDescr.compare = NULL;
  4886.   }
  4887. }
  4888.  
  4889. static Boolean ChkMoreOneArg(void)
  4890. {
  4891.   return (ArgCnt > 1);
  4892. }
  4893.  
  4894. static Boolean chk_pc_z380(LargeWord addr)
  4895. {
  4896.   switch (ActPC)
  4897.   {
  4898.     case SegCode:
  4899.       return (addr < (ExtFlag ? 0xfffffffful : 0xffffu));
  4900.     default:
  4901.       return True;
  4902.   }
  4903. }
  4904.  
  4905. /*!------------------------------------------------------------------------
  4906.  * \fn     SwitchTo_Z80(void *p_user)
  4907.  * \brief  switch to Z80 target
  4908.  * \param  p_user properties of CPU
  4909.  * ------------------------------------------------------------------------ */
  4910.  
  4911. static void SwitchTo_Z80(void *p_user)
  4912. {
  4913.   p_curr_cpu_props = (const cpu_props_t*)p_user;
  4914.  
  4915.   TurnWords = False;
  4916.   SetIntConstMode(eIntConstModeIntel);
  4917.   SetIsOccupiedFnc = ChkMoreOneArg;
  4918.  
  4919.   PCSymbol = "$"; HeaderID = 0x51; NOPCode = 0x00;
  4920.   DivideChars = ","; HasAttrs = False;
  4921.  
  4922.   ValidSegs = 1 << SegCode;
  4923.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  4924.  
  4925.   switch (p_curr_cpu_props->core)
  4926.   {
  4927.     case e_core_z380:
  4928.       SegLimits[SegCode] = 0xfffffffful;
  4929.       ChkPC = chk_pc_z380;
  4930.  
  4931.       /* Extended Modes only on Z380 */
  4932.  
  4933.       if (!onoff_test_and_set(e_onoff_reg_extmode))
  4934.         SetFlag(&ExtFlag, ExtModeSymName, False);
  4935.       AddONOFF(ExtModeCmdName, &ExtFlag, ExtModeSymName, False);
  4936.       if (!onoff_test_and_set(e_onoff_reg_lwordmode))
  4937.         SetFlag(&LWordFlag, LWordModeSymName, False);
  4938.       AddONOFF(LWordModeCmdName, &LWordFlag , LWordModeSymName , False);
  4939.       break;
  4940.     case e_core_ez80:
  4941.     {
  4942.       static const ASSUMERec assume_ez80[] =
  4943.       {
  4944.         { "ADL"  , &Reg_ADL  , 0, 1   , 0, NULL },
  4945.         { "MBASE", &Reg_MBASE, 0, 0xff, 0, NULL }
  4946.       };
  4947.  
  4948.       SegLimits[SegCode] = 0xfffffful;
  4949.       AttrChars = "."; HasAttrs = True;
  4950.       DecodeAttrPart = decode_attrpart_ez80;
  4951.       pASSUMERecs = assume_ez80;
  4952.       ASSUMERecCnt = as_array_size(assume_ez80);
  4953.       break;
  4954.     }
  4955.     case e_core_z180:
  4956.     {
  4957.       static const ASSUMERec ASSUMEZ180s[] =
  4958.       {
  4959.         { "CBAR" , &Reg_CBAR , 0,  0xff, 0xf0, check_cbar },
  4960.         { "CBR"  , &Reg_CBR  , 0,  0xff, 0   , update_z180_areas },
  4961.         { "BBR"  , &Reg_BBR  , 0,  0xff, 0   , update_z180_areas },
  4962.       };
  4963.  
  4964.       SegLimits[SegCode] = 0x7fffful;
  4965.       pASSUMERecs = ASSUMEZ180s;
  4966.       ASSUMERecCnt = as_array_size(ASSUMEZ180s);
  4967.       update_z180_areas();
  4968.       break;
  4969.     }
  4970.     case e_core_z80u:
  4971.       SegLimits[SegCode] = 0xffffffu;
  4972.       break;
  4973.     default:
  4974.       SegLimits[SegCode] = 0xffffu;
  4975.   }
  4976.  
  4977.   /* Gameboy Z80 does not have I/O space, and no IX/IY, do not test for them and allow as normal symbols: */
  4978.  
  4979.   if (is_sharp())
  4980.     Reg16Cnt = 4;
  4981.   else
  4982.   {
  4983.     ValidSegs |= 1 << SegIO;
  4984.     Grans[SegIO  ] = 1; ListGrans[SegIO  ] = 1; SegInits[SegIO  ] = 0;
  4985.     SegLimits[SegIO  ] = PortEnd();
  4986.     Reg16Cnt = 6;
  4987.   }
  4988.  
  4989.   MakeCode = MakeCode_Z80;
  4990.   IsDef = IsDef_Z80;
  4991.   QualifyQuote = QualifyQuote_Z80;
  4992.   InternSymbol = InternSymbol_Z80;
  4993.   SwitchFrom = DeinitFields; InitFields();
  4994.   DissectReg = DissectReg_Z80;
  4995.  
  4996.   asmerr_warn_relative_add();
  4997. }
  4998.  
  4999. static const cpu_props_t cpu_props[] =
  5000. {
  5001.   { "GBZ80"     , e_core_sharp, e_core_flag_none },
  5002.   { "LR35902"   , e_core_sharp, e_core_flag_none },
  5003.   { "Z80"       , e_core_z80  , e_core_flag_none },
  5004.   { "Z80UNDOC"  , e_core_z80u , e_core_flag_none },
  5005.   { "Z180"      , e_core_z180 , e_core_flag_none },
  5006.   { "RABBIT2000", e_core_r2000, e_core_flag_none },
  5007.   { "eZ80190"   , e_core_ez80 , e_core_flag_i_8bit | e_core_flag_no_xio },
  5008.   { "eZ80L92"   , e_core_ez80 , e_core_flag_i_8bit },
  5009.   { "eZ80F91"   , e_core_ez80 , e_core_flag_none },
  5010.   { "eZ80F92"   , e_core_ez80 , e_core_flag_i_8bit },
  5011.   { "eZ80F93"   , e_core_ez80 , e_core_flag_i_8bit },
  5012.   { "Z380"      , e_core_z380 , e_core_flag_none }
  5013. };
  5014.  
  5015. void codez80_init(void)
  5016. {
  5017.   const cpu_props_t *p_props;
  5018.  
  5019.   for (p_props = cpu_props; p_props < cpu_props + as_array_size(cpu_props); p_props++)
  5020.     (void)AddCPUUser(p_props->p_name, SwitchTo_Z80, (void*)p_props, NULL);
  5021.  
  5022.   AddInitPassProc(InitCode_Z80);
  5023. }
  5024.