Subversion Repositories pentevo

Rev

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

  1. /* code62015.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Sharp SC62015                                               */
  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 "chunks.h"
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmallg.h"
  22. #include "onoff_common.h"
  23. #include "asmitree.h"
  24. #include "codevars.h"
  25. #include "codepseudo.h"
  26. #include "headids.h"
  27. #include "errmsg.h"
  28. #include "chartrans.h"
  29. #include "codepseudo.h"
  30. #include "intpseudo.h"
  31.  
  32. #include "code62015.h"
  33.  
  34. /*---------------------------------------------------------------------------*/
  35.  
  36. static CPUVar CPUSC62015;
  37.  
  38. /*---------------------------------------------------------------------------*/
  39.  
  40. #define RegA  0
  41. #define RegIL 1
  42. #define RegBA 2
  43. #define RegI  3
  44. #define RegX  4
  45. #define RegY  5
  46. #define RegU  6
  47. #define RegS  7
  48. #define RegB  8
  49. #define RegIH 9
  50. #define RegPS 10
  51. #define RegPC 11
  52. #define RegF  12
  53. #define RegIMR 13
  54.  
  55. #define IsR1(reg) ((reg) == RegA || (reg) == RegIL)
  56. #define IsR2(reg) ((reg) == RegBA || (reg) == RegI)
  57. #define IsR3(reg) ((reg) >= RegX && (reg) <= RegS)
  58. #define IsR4(reg) ((reg) >= RegX && (reg) <= RegU)
  59.  
  60. #define IsWP(index) ((index) == 0 || (index) == 1)
  61. #define IsWPL(index) ((index) == 0 || (index) == 1 || (index) == 2)
  62.  
  63. typedef struct
  64. {
  65.         const char name[4];
  66.         Byte addr;
  67. } tIntReg;
  68.  
  69. static const tIntReg IntRegs[] =
  70. {
  71.         { "BP" , 0xec },
  72.         { "PX" , 0xed },
  73.         { "PY" , 0xee },
  74.         { "AMC", 0xef },
  75.         { "KOL", 0xf0 },
  76.         { "KOH", 0xf1 },
  77.         { "KI" , 0xf2 },
  78.         { "EOL", 0xf3 },
  79.         { "EOH", 0xf4 },
  80.         { "EIL", 0xf5 },
  81.         { "EIH", 0xf6 },
  82.         { "UCR", 0xf7 },
  83.         { "USR", 0xf8 },
  84.         { "RXD", 0xf9 },
  85.         { "TXD", 0xfa },
  86.         { "IMR", 0xfb },
  87.         { "ISR", 0xfc },
  88.         { "SCR", 0xfd },
  89.         { "LCC", 0xfe },
  90.         { "SSR", 0xff },
  91. };
  92.  
  93. static Boolean DecodeReg(const tStrComp *arg, Byte *pReg)
  94. {
  95.         const char rtable[][4] = { "A", "IL", "BA", "I", "X", "Y", "U", "S", "B", "IH", "PS", "PC", "F", "IMR" };
  96.         const char *str = arg->str.p_str;
  97.         size_t i;
  98.  
  99.         for (i = 0; i < as_array_size(rtable); i++)
  100.         {
  101.                 if (as_strcasecmp(str, rtable[i]) == 0)
  102.                 {
  103.                         *pReg = i;
  104.                         return True;
  105.                 }
  106.         }
  107.  
  108.         return False;
  109. }
  110.  
  111. static int RegSize(Byte Reg)
  112. {
  113.         int size;
  114.  
  115.         switch (Reg)
  116.         {
  117.         case RegPS:
  118.                 size = 0;
  119.                 break;
  120.         case 0: /* A */
  121.         case 1: /* IL */
  122.         case 8: /* B */
  123.         case 9: /* IH */
  124.                 size = 1;
  125.                 break;
  126.         case 2: /* BA */
  127.         case 3: /* I */
  128.         case 11:        /* PC */
  129.                 size = 2;
  130.                 break;
  131.         default:
  132.                 size = 3;
  133.         }
  134.  
  135.         return size;
  136. }
  137.  
  138. static Boolean IsCoreReg(Byte reg)
  139. {
  140.         return (reg < 8) ? True : False;
  141. }
  142.  
  143. static Boolean DecodeInternal(const tStrComp *pArg, Byte *pMode, Byte *pDisp, const char *pPReg)
  144. {
  145.         size_t i;
  146.         String Temp;
  147.         tStrComp temp;
  148.         Byte mode = 0;
  149.         Boolean OK;
  150.         int val;
  151.         int sign = 1;
  152.         tSymbolFlags flags;
  153.  
  154.         for (i = 0; i < as_array_size(IntRegs); i++)
  155.         {
  156.                 if (!as_strcasecmp(pArg->str.p_str, IntRegs[i].name))
  157.                 {
  158.                         *pMode = 0;
  159.                         *pDisp = IntRegs[i].addr;
  160.                         return True;
  161.                 }
  162.         }
  163.  
  164.         if (!IsIndirect(pArg->str.p_str)) return False;
  165.  
  166. #if 0
  167.         StrCompRefRight(&temp, pArg, 1);        /* strip off left '(' */
  168. #endif
  169.         StrCompMkTemp(&temp, Temp, sizeof(Temp));
  170.         StrCompCopy(&temp, pArg);
  171.         StrCompCutLeft(&temp, 1);
  172.         StrCompShorten(&temp, 1);       /* strip off right ')' */
  173.         KillPrefBlanksStrComp(&temp);
  174.         KillPostBlanksStrComp(&temp);
  175.  
  176.         if (!as_strncasecmp(temp.str.p_str, "BP", 2))
  177.         {
  178.                 mode = 1;
  179.         }
  180.         else if (!as_strncasecmp(temp.str.p_str, pPReg, 2))
  181.         {
  182.                 mode = 2;
  183.         }
  184.         else
  185.         {
  186.                 val = EvalStrIntExpression(&temp, UInt8, &OK);
  187.                 if (OK)
  188.                 {
  189.                         *pMode = 0;
  190.                         *pDisp = val;
  191.                         return OK;
  192.                 }
  193.  
  194.                 return False;
  195.         }
  196.  
  197.         StrCompCutLeft(&temp, 2);
  198.         KillPrefBlanksStrComp(&temp);
  199.  
  200.         if (temp.Pos.Len == 0)
  201.         {
  202.                 /* Displacement omitted */
  203.                 *pMode = mode;
  204.                 *pDisp = 0;
  205.                 return True;
  206.         }
  207.  
  208.         if (temp.str.p_str[0] == '+')
  209.         {
  210.                 sign = 1;
  211.                 StrCompCutLeft(&temp, 1);
  212.         }
  213.         else if (temp.str.p_str[0] == '-')
  214.         {
  215.                 sign = -1;
  216.                 StrCompCutLeft(&temp, 1);
  217.         }
  218.         KillPrefBlanksStrComp(&temp);
  219.  
  220.         if (mode == 1 && !as_strcasecmp(temp.str.p_str, pPReg))
  221.         {
  222.                 *pMode = 3;
  223.                 *pDisp = 0;
  224.                 return True;
  225.         }
  226.  
  227.         val = EvalStrIntExpressionWithFlags(&temp, UInt8, &OK, &flags) * sign;
  228.         if (OK)
  229.         {
  230.                 if (!mFirstPassUnknownOrQuestionable(flags) && (val > 127 || val < -128))
  231.                 {
  232.                         WrStrErrorPos(ErrNum_DistTooBig, pArg);
  233.                         return False;
  234.                 }
  235.                 *pMode = mode;
  236.                 *pDisp = val;
  237.                 return True;
  238.         }
  239.  
  240.         return False;
  241. }
  242.  
  243. static void PreByte(Byte mode1, Byte mode2)
  244. {
  245.         static const Byte ptable[] = {
  246.                 0x32, 0x30, 0x33, 0x31,
  247.                 0x22, 0x00, 0x23, 0x21,
  248.                 0x36, 0x34, 0x37, 0x35,
  249.                 0x26, 0x24, 0x27, 0x25 };
  250.  
  251.         if (mode1 == 1 && mode2 == 1) return;
  252.  
  253.         if (mode1 > 3 || mode2 > 3)
  254.         {
  255.                 WrError(ErrNum_InternalError);
  256.                 return;
  257.         }
  258.  
  259.         BAsmCode[CodeLen++] = ptable[mode1 * 4 + mode2];
  260. }
  261.  
  262. static Boolean DecodeDirect(const tStrComp *pArg, LongInt *pAddr)
  263. {
  264.         String Temp;
  265.         tStrComp temp;
  266.         LongInt val;
  267.         Boolean OK;
  268.  
  269.         if (!IsIndirectGen(pArg->str.p_str, "[]")) return False;
  270.  
  271.         StrCompMkTemp(&temp, Temp, sizeof(Temp));
  272.         StrCompCopy(&temp, pArg);
  273.         StrCompCutLeft(&temp, 1);
  274.         StrCompShorten(&temp, 1);
  275.         KillPrefBlanksStrComp(&temp);
  276.         KillPostBlanksStrComp(&temp);
  277.  
  278.         val = EvalStrIntExpression(&temp, UInt20, &OK);
  279.         if (OK)
  280.         {
  281.                 *pAddr = val;
  282.                 return OK;
  283.         }
  284.  
  285.         return False;
  286. }
  287.  
  288. static Boolean DecodeRegIndirect(const tStrComp *pArg, Byte *pReg, Byte *pMode)
  289. {
  290.         String Temp;
  291.         tStrComp temp;
  292.         Byte reg;
  293.         int l;
  294.         Byte mode = 0x00;
  295.  
  296.         if (!IsIndirectGen(pArg->str.p_str, "[]")) return False;
  297.         StrCompMkTemp(&temp, Temp, sizeof(Temp));
  298.         StrCompCopy(&temp, pArg);
  299.         StrCompCutLeft(&temp, 1);
  300.         StrCompShorten(&temp, 1);
  301.         KillPrefBlanksStrComp(&temp);
  302.         KillPostBlanksStrComp(&temp);
  303.  
  304.         l = strlen(temp.str.p_str);
  305.         if ((l >= 2) && !strncmp(temp.str.p_str + l - 2, "++", 2))
  306.         {
  307.                 mode = 0x20;
  308.                 StrCompShorten(&temp, 2);
  309.         }
  310.         else if (!strncmp(temp.str.p_str, "--", 2))
  311.         {
  312.                 mode = 0x30;
  313.                 StrCompCutLeft(&temp, 2);
  314.         }
  315.  
  316.         if (DecodeReg(&temp, &reg))
  317.         {
  318.                 *pReg = reg;
  319.                 *pMode = mode;
  320.                 return True;
  321.         }
  322.  
  323.         return False;
  324. }
  325.  
  326. static Boolean DecodeRegBase(const tStrComp *pArg, Byte *pReg, Byte *pMode, Byte *pDisp)
  327. {
  328.         String Temp;
  329.         tStrComp temp;
  330.         String Temp2;
  331.         tStrComp temp2;
  332.         int i;
  333.         char ch;
  334.         Byte reg;
  335.         Byte mode;
  336.         Word val;
  337.         Boolean OK;
  338.  
  339.         if (!IsIndirectGen(pArg->str.p_str, "[]")) return False;
  340.         StrCompMkTemp(&temp, Temp, sizeof(Temp));
  341.         StrCompCopy(&temp, pArg);
  342.         StrCompCutLeft(&temp, 1);
  343.         StrCompShorten(&temp, 1);
  344.         KillPrefBlanksStrComp(&temp);
  345.         KillPostBlanksStrComp(&temp);
  346.  
  347.         for (i = 0; temp.str.p_str[i]; i++)
  348.         {
  349.                 ch = temp.str.p_str[i];
  350.                 if (isalpha(ch)) continue;
  351.                 if (isspace(ch) || ch == '+' || ch == '-') break;
  352.                 return False;
  353.         }
  354.  
  355.         if (i <= 2)
  356.         {
  357.                 StrCompMkTemp(&temp2, Temp2, sizeof(Temp2));
  358.                 StrCompCopy(&temp2, &temp);
  359.                 StrCompShorten(&temp, strlen(temp.str.p_str) - i);
  360.                 StrCompCutLeft(&temp2, i);
  361.                 KillPrefBlanksStrComp(&temp2);
  362.  
  363.                 if (!DecodeReg(&temp, &reg) || !IsR3(reg)) return False;
  364.  
  365.                 if (temp2.str.p_str[0] == '+')
  366.                 {
  367.                         mode = 0x80;
  368.                 }
  369.                 else if (temp2.str.p_str[0] == '-')
  370.                 {
  371.                         mode = 0xc0;
  372.                 }
  373.                 else return False;
  374.  
  375.                 StrCompCutLeft(&temp2, i);
  376.                 KillPrefBlanksStrComp(&temp2);
  377.  
  378.                 val = EvalStrIntExpression(&temp2, UInt8, &OK);
  379.                 if (!OK) return False;
  380.  
  381.                 *pReg = reg;
  382.                 *pMode = mode;
  383.                 *pDisp = val;
  384.                 return True;
  385.         }
  386.  
  387.         return False;
  388. }
  389.  
  390. static Boolean DecodeImm(const tStrComp *pArg, LongInt *pVal, int size)
  391. {
  392.         LongInt val;
  393.         Boolean OK;
  394.  
  395.         switch (size)
  396.         {
  397.         case 1: /* 8 bit */
  398.                 val = EvalStrIntExpression(pArg, Int8, &OK);
  399.                 break;
  400.         case 2: /* 16 bit */
  401.                 val = EvalStrIntExpression(pArg, Int16, &OK);
  402.                 break;
  403.         case 3: /* 20 bit */
  404.                 val = EvalStrIntExpression(pArg, Int20, &OK);
  405.                 break;
  406.         default:
  407.                 WrError(ErrNum_InternalError);
  408.                 return False;
  409.         }
  410.  
  411.         if (OK)
  412.         {
  413.                 *pVal = val;
  414.                 return True;
  415.         }
  416.  
  417.         return False;
  418. }
  419.  
  420. static Boolean DecodeIntIndirect(const tStrComp *pArg, Byte *pDir, Byte *pDisp2, Byte *pMode, Byte *pDisp, const char *pPReg)
  421. {
  422.         String Temp;
  423.         String Temp2;
  424.         tStrComp temp;
  425.         tStrComp temp2;
  426.         char *pEnd;
  427.         int pos;
  428.         Byte dir;
  429.         Byte mode;
  430.         Byte disp;
  431.         Byte disp2;
  432.         Boolean OK;
  433.  
  434.         if (!IsIndirectGen(pArg->str.p_str, "[]")) return False;
  435.         StrCompMkTemp(&temp, Temp, sizeof(Temp));
  436.         StrCompCopy(&temp, pArg);
  437.         StrCompCutLeft(&temp, 1);
  438.         StrCompShorten(&temp, 1);
  439.         KillPrefBlanksStrComp(&temp);
  440.         KillPostBlanksStrComp(&temp);
  441.  
  442.         if (temp.str.p_str[0] != '(') return False;
  443.         pEnd = FindClosingParenthese(temp.str.p_str + 1);
  444.         pos = pEnd - temp.str.p_str + 1;
  445.         if (!pEnd) return False;
  446.  
  447.         StrCompMkTemp(&temp2, Temp2, sizeof(Temp2));
  448.         StrCompCopySub(&temp2, &temp, pos, strlen(temp.str.p_str) - pos);
  449.         StrCompShorten(&temp, strlen(temp.str.p_str) - pos);
  450.         KillPrefBlanksStrComp(&temp2);
  451.  
  452.         if (!DecodeInternal(&temp, &mode, &disp, pPReg)) return False;
  453.  
  454.         dir = 0x00;
  455.         if (strlen(temp2.str.p_str) > 0)
  456.         {
  457.                 switch (temp2.str.p_str[0])
  458.                 {
  459.                 case '+':
  460.                         dir = 0x80;
  461.                         break;
  462.                 case '-':
  463.                         dir = 0xc0;
  464.                         break;
  465.                 default:
  466.                         return False;
  467.                 }
  468.  
  469.                 StrCompCutLeft(&temp2, 1);
  470.                 disp2 = EvalStrIntExpression(&temp2, UInt8, &OK);
  471.                 if (!OK) return False;
  472.         }
  473.   else
  474.     disp2 = 0;
  475.  
  476.         *pDir = dir;
  477.         *pMode = mode;
  478.         *pDisp2 = disp2;
  479.         *pDisp = disp;
  480.         return True;
  481. }
  482.  
  483. static void AddrOut20(LongInt addr)
  484. {
  485.         BAsmCode[CodeLen++] = addr;
  486.         BAsmCode[CodeLen++] = addr >> 8;
  487.         BAsmCode[CodeLen++] = addr >> 16;
  488. }
  489.  
  490. /*---------------------------------------------------------------------------*/
  491.  
  492. static void DecodeMV(Word Index)
  493. {
  494.         int size = Index;
  495.         int i;
  496.         Byte reg1;
  497.         Byte reg2;
  498.         Byte mode1;
  499.         Byte mode2;
  500.         Byte disp1;
  501.         Byte disp2;
  502.         Byte dir;
  503.         Byte mdisp;
  504.         LongInt addr;
  505.         LongInt val;
  506.  
  507.         if (ChkArgCnt(2, 2))
  508.         {
  509.                 if (DecodeReg(&ArgStr[1], &reg1))
  510.                 {
  511.                         if (!size) size = RegSize(reg1);
  512.  
  513.                         if (DecodeReg(&ArgStr[2], &reg2))
  514.                         {
  515.                                 if (size == 1)
  516.                                 {
  517.                                         if (reg1 == RegA && reg2 == RegB)
  518.                                         {
  519.                                                 BAsmCode[0] = 0x74;
  520.                                                 CodeLen = 1;
  521.                                                 return;
  522.                                         }
  523.                                         if (reg1 == RegB && reg2 == RegA)
  524.                                         {
  525.                                                 BAsmCode[0] = 0x75;
  526.                                                 CodeLen = 1;
  527.                                                 return;
  528.                                         }
  529.                                 }
  530.  
  531.                                 if (!Index && reg1 < 8 && reg2 < 8 && RegSize(reg1) > 1)
  532.                                 {
  533.                                         if (RegSize(reg1) != RegSize(reg2))
  534.                                         {
  535.                                                 WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);       /* Register size conflict */
  536.                                                 return;
  537.                                         }
  538.  
  539.                                         BAsmCode[0] = 0xFD;
  540.                                         BAsmCode[1] = (reg1 << 4) | reg2;
  541.                                         CodeLen = 2;
  542.                                         return;
  543.                                 }
  544.  
  545.                                 WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  546.                                 return;
  547.                         }
  548.  
  549.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  550.                         {
  551.                                 PreByte(mode2, 1);
  552.                                 BAsmCode[CodeLen++] = 0x80 | reg1;
  553.                                 BAsmCode[CodeLen++] = disp2;
  554.                                 return;
  555.                         }
  556.  
  557.                         if (reg1 != RegS && DecodeRegIndirect(&ArgStr[2], &reg2, &mode2))
  558.                         {
  559.                                 BAsmCode[0] = 0x90 | reg1;
  560.                                 BAsmCode[1] = mode2 | reg2;
  561.                                 CodeLen = 2;
  562.                                 return;
  563.                         }
  564.  
  565.                         if (DecodeRegBase(&ArgStr[2], &reg2, &mode2, &disp2))
  566.                         {
  567.                                 BAsmCode[0] = 0x90 | reg1;
  568.                                 BAsmCode[1] = mode2 | reg2;
  569.                                 BAsmCode[2] = disp2;
  570.                                 CodeLen = 3;
  571.                                 return;
  572.                         }
  573.  
  574.                         if (DecodeIntIndirect(&ArgStr[2], &dir, &mdisp, &mode2, &disp2, "PX"))
  575.                         {
  576.                                 PreByte(mode2, 1);
  577.                                 BAsmCode[CodeLen++] = 0x98 | reg1;
  578.                                 BAsmCode[CodeLen++] = dir;
  579.                                 BAsmCode[CodeLen++] = disp2;
  580.                                 if (dir) BAsmCode[CodeLen++] = mdisp;
  581.                                 return;
  582.                         }
  583.  
  584.                         if (DecodeDirect(&ArgStr[2], &addr))
  585.                         {
  586.                                 BAsmCode[CodeLen++] = 0x88 | reg1;
  587.                                 AddrOut20(addr);
  588.                                 return;
  589.                         }
  590.  
  591.                         if (DecodeImm(&ArgStr[2], &val, size))
  592.                         {
  593.                                 BAsmCode[CodeLen++] = 0x08 | reg1;
  594.                                 for (i = 0; i < size; i++)
  595.                                 {
  596.                                         BAsmCode[CodeLen++] = val >> (i * 8);
  597.                                 }
  598.                                 return;
  599.                         }
  600.  
  601.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  602.                         return;
  603.                 }
  604.  
  605.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  606.                 {
  607.                         if (DecodeReg(&ArgStr[2], &reg2) && IsCoreReg(reg2))
  608.                         {
  609.                                 PreByte(mode1, 1);
  610.                                 BAsmCode[CodeLen++] = 0xa0 | reg2;
  611.                                 BAsmCode[CodeLen++] = disp1;
  612.                                 return;
  613.                         }
  614.  
  615.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  616.                         {
  617.                                 PreByte(mode1, mode2);
  618.                                 BAsmCode[CodeLen++] = 0xc8;
  619.                                 BAsmCode[CodeLen++] = disp1;
  620.                                 BAsmCode[CodeLen++] = disp2;
  621.                                 return;
  622.                         }
  623.  
  624.                         if (DecodeRegIndirect(&ArgStr[2], &reg2, &mode2))
  625.                         {
  626.                                 PreByte(mode1, 1);
  627.                                 BAsmCode[CodeLen++] = 0xe0;
  628.                                 BAsmCode[CodeLen++] = mode2 | reg2;
  629.                                 BAsmCode[CodeLen++] = disp1;
  630.                                 return;
  631.                         }
  632.  
  633.                         if (DecodeRegBase(&ArgStr[2], &reg2, &mode2, &disp2))
  634.                         {
  635.                                 PreByte(mode1, 1);
  636.                                 BAsmCode[CodeLen++] = 0xe0;
  637.                                 BAsmCode[CodeLen++] = mode2 | reg2;
  638.                                 BAsmCode[CodeLen++] = disp1;
  639.                                 BAsmCode[CodeLen++] = disp2;
  640.                                 return;
  641.                         }
  642.  
  643.                         if (DecodeIntIndirect(&ArgStr[2], &dir, &mdisp, &mode2, &disp2, "PY"))
  644.                         {
  645.                                 PreByte(mode1, mode2);
  646.                                 BAsmCode[CodeLen++] = 0xf0;
  647.                                 BAsmCode[CodeLen++] = dir;
  648.                                 BAsmCode[CodeLen++] = disp1;
  649.                                 BAsmCode[CodeLen++] = disp2;
  650.                                 if (dir) BAsmCode[CodeLen++] = mdisp;
  651.                                 return;
  652.                         }
  653.  
  654.                         if (DecodeDirect(&ArgStr[2], &addr))
  655.                         {
  656.                                 PreByte(mode1, 1);
  657.                                 BAsmCode[CodeLen++] = 0xd0;
  658.                                 BAsmCode[CodeLen++] = disp1;
  659.                                 AddrOut20(addr);
  660.                                 return;
  661.                         }
  662.  
  663.                         if (DecodeImm(&ArgStr[2], &val, 1))
  664.                         {
  665.                                 PreByte(mode1, 1);
  666.                                 BAsmCode[CodeLen++] = 0xcc;
  667.                                 BAsmCode[CodeLen++] = disp1;
  668.                                 BAsmCode[CodeLen++] = val;
  669.                                 return;
  670.                         }
  671.  
  672.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  673.                         return;
  674.                 }
  675.  
  676.                 if (DecodeRegIndirect(&ArgStr[1], &reg1, &mode1))
  677.                 {
  678.                         if (DecodeReg(&ArgStr[2], &reg2) && reg2 != RegS)
  679.                         {
  680.                                 BAsmCode[0] = 0xb0 | reg2;
  681.                                 BAsmCode[1] = mode1 | reg1;
  682.                                 CodeLen = 2;
  683.                                 return;
  684.                         }
  685.  
  686.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  687.                         {
  688.                                 PreByte(mode2, 1);
  689.                                 BAsmCode[CodeLen++] = 0xe8;
  690.                                 BAsmCode[CodeLen++] = mode1 | reg1;
  691.                                 BAsmCode[CodeLen++] = disp2;
  692.                                 return;
  693.                         }
  694.  
  695.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  696.                         return;
  697.                 }
  698.  
  699.                 if (DecodeRegBase(&ArgStr[1], &reg1, &mode1, &disp1))
  700.                 {
  701.                         if (DecodeReg(&ArgStr[2], &reg2))
  702.                         {
  703.                                 BAsmCode[0] = 0xb0 | reg2;
  704.                                 BAsmCode[1] = mode1 | reg1;
  705.                                 BAsmCode[2] = disp1;
  706.                                 CodeLen = 3;
  707.                                 return;
  708.                         }
  709.  
  710.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  711.                         {
  712.                                 PreByte(mode2, 1);
  713.                                 BAsmCode[CodeLen++] = 0xe8;
  714.                                 BAsmCode[CodeLen++] = mode1 | reg1;
  715.                                 BAsmCode[CodeLen++] = disp2;
  716.                                 BAsmCode[CodeLen++] = disp1;
  717.                                 return;                        
  718.                         }
  719.  
  720.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  721.                         return;
  722.                 }
  723.  
  724.                 if (DecodeIntIndirect(&ArgStr[1], &dir, &mdisp, &mode1, &disp1, "PX"))
  725.                 {
  726.                         if (DecodeReg(&ArgStr[2], &reg2))
  727.                         {
  728.                                 PreByte(mode1, 1);
  729.                                 BAsmCode[CodeLen++] = 0xb8 | reg2;
  730.                                 BAsmCode[CodeLen++] = dir;
  731.                                 BAsmCode[CodeLen++] = disp1;
  732.                                 if (dir) BAsmCode[CodeLen++] = mdisp;
  733.                                 return;
  734.                         }
  735.  
  736.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  737.                         {
  738.                                 PreByte(mode1, mode2);
  739.                                 BAsmCode[CodeLen++] = 0xf8;
  740.                                 BAsmCode[CodeLen++] = dir;
  741.                                 BAsmCode[CodeLen++] = disp1;
  742.                                 if (dir) BAsmCode[CodeLen++] = mdisp;
  743.                                 BAsmCode[CodeLen++] = disp2;
  744.                                 return;
  745.                         }
  746.  
  747.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  748.                         return;
  749.                 }
  750.  
  751.                 if (DecodeDirect(&ArgStr[1], &addr))
  752.                 {
  753.                         if (DecodeReg(&ArgStr[2], &reg2) && IsCoreReg(reg2))
  754.                         {
  755.                                 BAsmCode[CodeLen++] = 0xa8 | reg2;
  756.                                 AddrOut20(addr);
  757.                                 return;
  758.                         }
  759.  
  760.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  761.                         {
  762.                                 PreByte(mode2, 1);
  763.                                 BAsmCode[CodeLen++] = 0xd8;
  764.                                 AddrOut20(addr);
  765.                                 BAsmCode[CodeLen++] = disp2;
  766.                                 return;
  767.                         }
  768.  
  769.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  770.                         return;
  771.                 }
  772.  
  773.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  774.                 return;
  775.         }
  776. }
  777.  
  778. static void DecodeMVW(Word Index)
  779. {
  780.         Byte mode1;
  781.         Byte mode2;
  782.         Byte disp1;
  783.         Byte disp2;
  784.         Byte reg;
  785.         Byte dir;
  786.         Byte mdisp;
  787.         LongInt val;
  788.         LongInt addr;
  789.         int i;
  790.  
  791.         if (ChkArgCnt(2, 2))
  792.         {
  793.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  794.                 {
  795.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  796.                         {
  797.                                 PreByte(mode1, mode2);
  798.                                 BAsmCode[CodeLen++] = (Index == 3) ? 0xcf : 0xc9 + Index;
  799.                                 BAsmCode[CodeLen++] = disp1;
  800.                                 BAsmCode[CodeLen++] = disp2;
  801.                                 return;
  802.                         }
  803.  
  804.                         if (IsWPL(Index) &&     DecodeRegIndirect(&ArgStr[2], &reg, &mode2))
  805.                         {
  806.                                 PreByte(mode1, 1);
  807.                                 BAsmCode[CodeLen++] = 0xe1 + Index;
  808.                                 BAsmCode[CodeLen++] = mode2 | reg;
  809.                                 BAsmCode[CodeLen++] = disp1;
  810.                                 return;
  811.                         }
  812.  
  813.                         if (IsWPL(Index) &&     DecodeRegBase(&ArgStr[2], &reg, &mode2, &disp2))
  814.                         {
  815.                                 const Byte optab[] = { 0xe1, 0xe2, 0x56, 0x00 };
  816.  
  817.                                 PreByte(mode1, 1);
  818.                                 BAsmCode[CodeLen++] = optab[Index];
  819.                                 BAsmCode[CodeLen++] = mode2 | reg;
  820.                                 BAsmCode[CodeLen++] = disp1;
  821.                                 BAsmCode[CodeLen++] = disp2;
  822.                                 return;
  823.                         }
  824.  
  825.                         if (IsWPL(Index) &&     DecodeIntIndirect(&ArgStr[2], &dir, &mdisp, &mode2, &disp2, "PY"))
  826.                         {
  827.                                 PreByte(mode1, mode2);
  828.                                 BAsmCode[CodeLen++] = 0xf1 + Index;
  829.                                 BAsmCode[CodeLen++] = dir;
  830.                                 BAsmCode[CodeLen++] = disp1;
  831.                                 BAsmCode[CodeLen++] = disp2;
  832.                                 if (dir) BAsmCode[CodeLen++] = mdisp;
  833.                                 return;
  834.                         }
  835.  
  836.                         if (IsWPL(Index) &&     DecodeDirect(&ArgStr[2], &addr))
  837.                         {
  838.                                 PreByte(mode1, 1);
  839.                                 BAsmCode[CodeLen++] = 0xd1 + Index;
  840.                                 BAsmCode[CodeLen++] = disp1;
  841.                                 AddrOut20(addr);
  842.                                 return;
  843.                         }
  844.  
  845.                         if (IsWP(Index) && DecodeImm(&ArgStr[2], &val, Index + 2))
  846.                         {
  847.                                 PreByte(mode1, 1);
  848.                                 BAsmCode[CodeLen++] = (Index == 0) ? 0xcd : 0xdc;
  849.                                 BAsmCode[CodeLen++] = disp1;
  850.                                 for (i = 0; i < Index + 2; i++)
  851.                                 {
  852.                                         BAsmCode[CodeLen++] = val >> (i * 8);
  853.                                 }
  854.                                 return;
  855.                         }
  856.  
  857.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  858.                         return;
  859.                 }
  860.  
  861.                 if (DecodeRegIndirect(&ArgStr[1], &reg, &mode1))
  862.                 {
  863.                         if (IsWPL(Index) &&     DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  864.                         {
  865.                                 PreByte(mode2, 1);
  866.                                 BAsmCode[CodeLen++] = 0xe9 + Index;
  867.                                 BAsmCode[CodeLen++] = mode1 | reg;
  868.                                 BAsmCode[CodeLen++] = disp2;
  869.                                 return;
  870.                         }
  871.  
  872.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  873.                         return;
  874.                 }
  875.  
  876.                 if (DecodeRegBase(&ArgStr[1], &reg, &mode1, &disp1))
  877.                 {
  878.                         if (IsWPL(Index) &&     DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  879.                         {
  880.                                 const Byte optab[] = { 0xe9, 0xea, 0x5e, 0x00 };
  881.  
  882.                                 PreByte(mode2, 1);
  883.                                 BAsmCode[CodeLen++] = optab[Index];
  884.                                 BAsmCode[CodeLen++] = mode1 | reg;
  885.                                 BAsmCode[CodeLen++] = disp2;
  886.                                 BAsmCode[CodeLen++] = disp1;
  887.                                 return;
  888.                         }
  889.  
  890.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  891.                         return;
  892.                 }
  893.  
  894.                 if (DecodeIntIndirect(&ArgStr[1], &dir, &mdisp, &mode1, &disp1, "PX"))
  895.                 {
  896.                         if (IsWPL(Index) &&     DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  897.                         {
  898.                                 PreByte(mode1, mode2);
  899.                                 BAsmCode[CodeLen++] = 0xf9 + Index;
  900.                                 BAsmCode[CodeLen++] = dir;
  901.                                 BAsmCode[CodeLen++] = disp1;
  902.                                 if (dir) BAsmCode[CodeLen++] = mdisp;
  903.                                 BAsmCode[CodeLen++] = disp2;
  904.                                 return;
  905.                         }
  906.  
  907.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  908.                         return;
  909.                 }
  910.  
  911.                 if (DecodeDirect(&ArgStr[1], &addr))
  912.                 {
  913.                         if (IsWPL(Index) &&     DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  914.                         {
  915.                                 PreByte(mode2, 1);
  916.                                 BAsmCode[CodeLen++] = 0xd9 + Index;
  917.                                 AddrOut20(addr);
  918.                                 BAsmCode[CodeLen++] = disp2;
  919.                                 return;
  920.                         }
  921.  
  922.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  923.                         return;
  924.                 }
  925.  
  926.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  927.                 return;
  928.         }
  929. }
  930.  
  931. static void DecodeEX(Word Index)
  932. {
  933.         Byte reg1;
  934.         Byte reg2;
  935.         Byte mode1;
  936.         Byte mode2;
  937.         Byte disp1;
  938.         Byte disp2;
  939.  
  940.   UNUSED(Index);
  941.  
  942.         if (ChkArgCnt(2, 2))
  943.         {
  944.                 if (DecodeReg(&ArgStr[1], &reg1))
  945.                 {
  946.                         if (DecodeReg(&ArgStr[2], &reg2))
  947.                         {
  948.                                 if (RegSize(reg1) != RegSize(reg2))
  949.                                 {
  950.                                         WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);       /* Register size conflict */
  951.                                         return;
  952.                                 }
  953.  
  954.                                 if (RegSize(reg1) == 1)
  955.                                 {
  956.                                         if (reg1 != RegA || reg2 != RegB)
  957.                                         {
  958.                                                 WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);       /* Register size conflict */
  959.                                                 return;
  960.                                         }
  961.  
  962.                                         BAsmCode[0] = 0xdd;
  963.                                         CodeLen =1;
  964.                                         return;
  965.                                 }
  966.                                 else
  967.                                 {
  968.                                         if ((IsR2(reg1) && IsR2(reg2)) || (IsR3(reg1) && IsR3(reg2)))
  969.                                         {
  970.                                                 BAsmCode[0] = 0xed;
  971.                                                 BAsmCode[1] = (reg1 << 4) | reg2;
  972.                                                 CodeLen = 2;
  973.                                                 return;
  974.                                         }
  975.                                 }
  976.                                
  977.                                 WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  978.                                 return;
  979.                         }
  980.  
  981.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  982.                         return;
  983.                 }
  984.  
  985.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  986.                 {
  987.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  988.                         {
  989.                                 PreByte(mode1, mode2);
  990.                                 BAsmCode[CodeLen++] = 0xc0;
  991.                                 BAsmCode[CodeLen++] = disp1;
  992.                                 BAsmCode[CodeLen++] = disp2;
  993.                                 return;
  994.                         }
  995.  
  996.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  997.                         return;
  998.                 }
  999.  
  1000.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1001.                 return;
  1002.         }
  1003. }
  1004.  
  1005. static void DecodeEXW(Word Index)
  1006. {
  1007.         Byte mode1;
  1008.         Byte mode2;
  1009.         Byte disp1;
  1010.         Byte disp2;
  1011.  
  1012.         if (ChkArgCnt(2, 2))
  1013.         {
  1014.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  1015.                 {
  1016.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  1017.                         {
  1018.                                 PreByte(mode1, mode2);
  1019.                                 BAsmCode[CodeLen++] = Index;
  1020.                                 BAsmCode[CodeLen++] = disp1;
  1021.                                 BAsmCode[CodeLen++] = disp2;
  1022.                                 return;
  1023.                         }
  1024.  
  1025.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1026.                         return;
  1027.                 }
  1028.  
  1029.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1030.                 return;
  1031.         }
  1032. }
  1033.  
  1034. static void DecodeSWAP(Word Index)
  1035. {
  1036.         Byte reg;
  1037.  
  1038.         if (ChkArgCnt(1, 1))
  1039.         {
  1040.                 if (DecodeReg(&ArgStr[1], &reg))
  1041.                 {
  1042.                         if (reg == RegA)
  1043.                         {
  1044.                                 BAsmCode[0] = Index;
  1045.                                 CodeLen = 1;
  1046.                                 return;
  1047.                         }
  1048.                 }
  1049.  
  1050.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1051.                 return;
  1052.         }
  1053. }
  1054.  
  1055. static void DecodeADD(Word Index)
  1056. {
  1057.         Byte reg1;
  1058.         Byte reg2;
  1059.         Byte mode;
  1060.         Byte disp;
  1061.         LongInt val;
  1062.  
  1063.         if (ChkArgCnt(2, 2))
  1064.         {
  1065.                 if (DecodeReg(&ArgStr[1], &reg1))
  1066.                 {
  1067.                         if (DecodeReg(&ArgStr[2], &reg2))
  1068.                         {
  1069.                                 if (IsR1(reg1) && IsR1(reg2))
  1070.                                 {
  1071.                                         BAsmCode[0] = Index | 0x06;
  1072.                                 }
  1073.                                 else if (IsR2(reg1) && (IsR1(reg2) || IsR2(reg2)))
  1074.                                 {
  1075.                                         BAsmCode[0] = Index | 0x04;
  1076.                                 }
  1077.                                 else if (IsR3(reg1) && (IsR1(reg2) || IsR2(reg2) || IsR3(reg2)))
  1078.                                 {
  1079.                                         BAsmCode[0] = Index | 0x05;
  1080.                                 }
  1081.                                 else
  1082.                                 {
  1083.                                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1084.                                         return;
  1085.                                 }
  1086.                                 BAsmCode[1] = (reg1 << 4) | reg2;
  1087.                                 CodeLen = 2;
  1088.                                 return;
  1089.                         }
  1090.  
  1091.                         if (DecodeInternal(&ArgStr[2], &mode, &disp, "PX"))
  1092.                         {
  1093.                                 if (reg1 == RegA)
  1094.                                 {
  1095.                                         PreByte(mode, 1);
  1096.                                         BAsmCode[CodeLen++] = Index | 0x02;
  1097.                                         BAsmCode[CodeLen++] = disp;
  1098.                                         return;
  1099.                                 }
  1100.                         }
  1101.  
  1102.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1103.                         {
  1104.                                 if (reg1 == RegA)
  1105.                                 {
  1106.                                         BAsmCode[0] = Index;
  1107.                                         BAsmCode[1] = val;
  1108.                                         CodeLen = 2;
  1109.                                         return;
  1110.                                 }
  1111.                         }
  1112.  
  1113.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1114.                         return;
  1115.                 }
  1116.  
  1117.                 if (DecodeInternal(&ArgStr[1], &mode, &disp, "PX"))
  1118.                 {
  1119.                         if (DecodeReg(&ArgStr[2], &reg2))
  1120.                         {
  1121.                                 if (reg2 == RegA)
  1122.                                 {
  1123.                                         PreByte(mode, 1);
  1124.                                         BAsmCode[CodeLen++] = Index | 0x03;
  1125.                                         BAsmCode[CodeLen++] = disp;
  1126.                                         return;
  1127.                                 }
  1128.                         }
  1129.  
  1130.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1131.                         {
  1132.                                 PreByte(mode, 1);
  1133.                                 BAsmCode[CodeLen++] = Index | 0x01;
  1134.                                 BAsmCode[CodeLen++] = disp;
  1135.                                 BAsmCode[CodeLen++] = val;
  1136.                                 return;
  1137.                         }
  1138.  
  1139.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1140.                         return;
  1141.                 }
  1142.  
  1143.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1144.         }
  1145. }
  1146.  
  1147. static void DecodeADC(Word Index)
  1148. {
  1149.         Byte reg;
  1150.         LongInt val;
  1151.         Byte mode;
  1152.         Byte disp;
  1153.  
  1154.         if (ChkArgCnt(2, 2))
  1155.         {
  1156.                 if (DecodeReg(&ArgStr[1], &reg))
  1157.                 {
  1158.                         if (DecodeInternal(&ArgStr[2], &mode, &disp, "PX"))
  1159.                         {
  1160.                                 if (reg == RegA)
  1161.                                 {
  1162.                                         PreByte(mode, 1);
  1163.                                         BAsmCode[CodeLen++] = Index | 0x02;
  1164.                                         BAsmCode[CodeLen++] = disp;
  1165.                                         return;
  1166.                                 }
  1167.                         }
  1168.  
  1169.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1170.                         {
  1171.                                 if (reg == RegA)
  1172.                                 {
  1173.                                         BAsmCode[0] = Index;
  1174.                                         BAsmCode[1] = val;
  1175.                                         CodeLen = 2;
  1176.                                         return;
  1177.                                 }
  1178.  
  1179.                                 WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  1180.                                 return;
  1181.                         }
  1182.  
  1183.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1184.                         return;
  1185.                 }
  1186.  
  1187.                 if (DecodeInternal(&ArgStr[1], &mode, &disp, "PX"))
  1188.                 {
  1189.                         if (DecodeReg(&ArgStr[2], &reg))
  1190.                         {
  1191.                                 if (reg == RegA)
  1192.                                 {
  1193.                                         PreByte(mode, 1);
  1194.                                         BAsmCode[CodeLen++] = Index | 0x03;
  1195.                                         BAsmCode[CodeLen++] = disp;
  1196.                                         return;
  1197.                                 }
  1198.                         }
  1199.  
  1200.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1201.                         {
  1202.                                 PreByte(mode, 1);
  1203.                                 BAsmCode[CodeLen++] = Index | 0x01;
  1204.                                 BAsmCode[CodeLen++] = disp;
  1205.                                 BAsmCode[CodeLen++] = val;
  1206.                                 return;
  1207.                         }
  1208.  
  1209.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1210.                         return;
  1211.                 }
  1212.  
  1213.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1214.         }
  1215. }
  1216.  
  1217. static void DecodeADCL(Word Index)
  1218. {
  1219.         Byte mode1;
  1220.         Byte mode2;
  1221.         Byte disp1;
  1222.         Byte disp2;
  1223.         Byte reg;
  1224.  
  1225.   UNUSED(Index);
  1226.  
  1227.         if (ChkArgCnt(2, 2))
  1228.         {
  1229.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  1230.                 {
  1231.                         if (DecodeReg(&ArgStr[2], &reg))
  1232.                         {
  1233.                                 if (reg == RegA)
  1234.                                 {
  1235.                                         PreByte(mode1, 1);
  1236.                                         BAsmCode[CodeLen++] = Index | 0x01;
  1237.                                         BAsmCode[CodeLen++] = disp1;
  1238.                                         return;
  1239.                                 }
  1240.                         }
  1241.  
  1242.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  1243.                         {
  1244.                                 PreByte(mode1, mode2);
  1245.                                 BAsmCode[CodeLen++] = Index;
  1246.                                 BAsmCode[CodeLen++] = disp1;
  1247.                                 BAsmCode[CodeLen++] = disp2;
  1248.                                 return;
  1249.                         }
  1250.  
  1251.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1252.                         return;
  1253.                 }              
  1254.                
  1255.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1256.         }
  1257. }
  1258.  
  1259. static void DecodePMDF(Word Index)
  1260. {
  1261.         Byte mode;
  1262.         Byte disp;
  1263.         Byte reg;
  1264.         LongInt val;
  1265.  
  1266.   UNUSED(Index);
  1267.  
  1268.         if (ChkArgCnt(2, 2))
  1269.         {
  1270.                 if (DecodeInternal(&ArgStr[1], &mode, &disp, "PX"))
  1271.                 {
  1272.                         if (DecodeReg(&ArgStr[2], &reg))
  1273.                         {
  1274.                                 if (reg == RegA)
  1275.                                 {
  1276.                                         PreByte(mode, 1);
  1277.                                         BAsmCode[CodeLen++] = 0x57;
  1278.                                         BAsmCode[CodeLen++] = disp;
  1279.                                         return;
  1280.                                 }
  1281.                         }
  1282.  
  1283.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1284.                         {
  1285.                                 PreByte(mode, 1);
  1286.                                 BAsmCode[CodeLen++] = 0x47;
  1287.                                 BAsmCode[CodeLen++] = disp;
  1288.                                 BAsmCode[CodeLen++] = val;
  1289.                                 return;
  1290.                         }
  1291.  
  1292.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1293.                         return;
  1294.                 }              
  1295.                
  1296.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1297.         }
  1298. }
  1299.  
  1300. static void DecodeAND(Word Index)
  1301. {
  1302.         Byte reg;
  1303.         Byte mode1;
  1304.         Byte mode2;
  1305.         Byte disp1;
  1306.         Byte disp2;
  1307.         LongInt addr;
  1308.         LongInt val;
  1309.  
  1310.         if (ChkArgCnt(2, 2))
  1311.         {
  1312.                 if (DecodeReg(&ArgStr[1], &reg) && reg == RegA)
  1313.                 {
  1314.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PX"))
  1315.                         {
  1316.                                 PreByte(mode2, 1);
  1317.                                 BAsmCode[CodeLen++] = Index | 0x07;
  1318.                                 BAsmCode[CodeLen++] = disp2;
  1319.                                 return;
  1320.                         }
  1321.  
  1322.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1323.                         {
  1324.                                 BAsmCode[0] = Index;
  1325.                                 BAsmCode[1] = val;
  1326.                                 CodeLen = 2;
  1327.                                 return;
  1328.                         }
  1329.  
  1330.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1331.                         return;
  1332.                 }
  1333.  
  1334.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  1335.                 {
  1336.                         if (DecodeReg(&ArgStr[2], &reg) && reg == RegA)
  1337.                         {
  1338.                                 PreByte(mode1, 1);
  1339.                                 BAsmCode[CodeLen++] = Index | 0x03;
  1340.                                 BAsmCode[CodeLen++] = disp1;
  1341.                                 return;
  1342.                         }
  1343.  
  1344.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  1345.                         {
  1346.                                 PreByte(mode1, mode2);
  1347.                                 BAsmCode[CodeLen++] = Index | 0x06;
  1348.                                 BAsmCode[CodeLen++] = disp1;
  1349.                                 BAsmCode[CodeLen++] = disp2;
  1350.                                 return;
  1351.                         }
  1352.  
  1353.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1354.                         {
  1355.                                 PreByte(mode1, 1);
  1356.                                 BAsmCode[CodeLen++] = Index | 0x01;
  1357.                                 BAsmCode[CodeLen++] = disp1;
  1358.                                 BAsmCode[CodeLen++] = val;
  1359.                                 return;
  1360.                         }
  1361.  
  1362.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1363.                         return;
  1364.                 }
  1365.  
  1366.                 if (DecodeDirect(&ArgStr[1], &addr))
  1367.                 {
  1368.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1369.                         {
  1370.                                 BAsmCode[CodeLen++] = Index | 0x02;
  1371.                                 AddrOut20(addr);
  1372.                                 BAsmCode[CodeLen++] = val;
  1373.                                 return;
  1374.                         }
  1375.  
  1376.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1377.                         return;
  1378.                 }
  1379.  
  1380.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1381.         }
  1382. }
  1383.  
  1384. static void DecodeINC(Word Index)
  1385. {
  1386.         Byte reg;
  1387.         Byte mode;
  1388.         Byte disp;
  1389.  
  1390.         if (ChkArgCnt(1, 1))
  1391.         {
  1392.                 if (DecodeReg(&ArgStr[1], &reg) && IsCoreReg(reg))
  1393.                 {
  1394.                         BAsmCode[0] = Index;
  1395.                         BAsmCode[1] = reg;
  1396.                         CodeLen = 2;
  1397.                         return;
  1398.                 }
  1399.  
  1400.                 if (DecodeInternal(&ArgStr[1], &mode, &disp, "PX"))
  1401.                 {
  1402.                         PreByte(mode, 1);
  1403.                         BAsmCode[CodeLen++] = Index | 0x01;
  1404.                         BAsmCode[CodeLen++] = disp;
  1405.                         return;
  1406.                 }
  1407.  
  1408.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1409.         }
  1410. }
  1411.  
  1412. static void DecodeROR(Word Index)
  1413. {
  1414.         Byte reg;
  1415.         Byte mode;
  1416.         Byte disp;
  1417.  
  1418.         if (ChkArgCnt(1, 1))
  1419.         {
  1420.                 if (DecodeReg(&ArgStr[1], &reg) && reg == RegA)
  1421.                 {
  1422.                         BAsmCode[0] = Index;
  1423.                         CodeLen = 1;
  1424.                         return;
  1425.                 }
  1426.  
  1427.                 if (DecodeInternal(&ArgStr[1], &mode, &disp, "PX"))
  1428.                 {
  1429.                         PreByte(mode, 1);
  1430.                         BAsmCode[CodeLen++] = Index | 0x01;
  1431.                         BAsmCode[CodeLen++] = disp;
  1432.                         return;
  1433.                 }
  1434.  
  1435.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1436.         }
  1437. }
  1438.  
  1439. static void DecodeDSRL(Word Index)
  1440. {
  1441.         Byte mode;
  1442.         Byte disp;
  1443.  
  1444.   UNUSED(Index);
  1445.  
  1446.         if (ChkArgCnt(1, 1))
  1447.         {
  1448.                 if (DecodeInternal(&ArgStr[1], &mode, &disp, "PX"))
  1449.                 {
  1450.                         PreByte(mode, 1);
  1451.                         BAsmCode[CodeLen++] = Index;
  1452.                         BAsmCode[CodeLen++] = disp;
  1453.                         return;
  1454.                 }
  1455.  
  1456.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1457.         }
  1458. }
  1459.  
  1460. static void DecodeCMP(Word Index)
  1461. {
  1462.         Byte reg;
  1463.         Byte mode1;
  1464.         Byte mode2;
  1465.         Byte disp1;
  1466.         Byte disp2;
  1467.         LongInt val;
  1468.         LongInt addr;
  1469.  
  1470.   UNUSED(Index);
  1471.  
  1472.         if (ChkArgCnt(2, 2))
  1473.         {
  1474.                 if (DecodeReg(&ArgStr[1], &reg) && reg == RegA)
  1475.                 {
  1476.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1477.                         {
  1478.                                 BAsmCode[0] = 0x60;
  1479.                                 BAsmCode[1] = val;
  1480.                                 CodeLen = 2;
  1481.                                 return;
  1482.                         }
  1483.  
  1484.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1485.                         return;
  1486.                 }
  1487.  
  1488.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  1489.                 {
  1490.                         if (DecodeReg(&ArgStr[2], &reg) && reg == RegA)
  1491.                         {
  1492.                                 PreByte(mode1, 1);
  1493.                                 BAsmCode[CodeLen++] = 0x63;
  1494.                                 BAsmCode[CodeLen++] = disp1;
  1495.                                 return;
  1496.                         }
  1497.  
  1498.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  1499.                         {
  1500.                                 PreByte(mode1, mode2);
  1501.                                 BAsmCode[CodeLen++] = 0xb7;
  1502.                                 BAsmCode[CodeLen++] = disp1;
  1503.                                 BAsmCode[CodeLen++] = disp2;
  1504.                                 return;
  1505.                         }
  1506.  
  1507.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1508.                         {
  1509.                                 PreByte(mode1, 1);
  1510.                                 BAsmCode[CodeLen++] = 0x61;
  1511.                                 BAsmCode[CodeLen++] = disp1;
  1512.                                 BAsmCode[CodeLen++] = val;
  1513.                                 return;
  1514.                         }
  1515.  
  1516.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1517.                         return;
  1518.                 }
  1519.  
  1520.                 if (DecodeDirect(&ArgStr[1], &addr))
  1521.                 {
  1522.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1523.                         {
  1524.                                 BAsmCode[CodeLen++] = 0x62;
  1525.                                 AddrOut20(addr);
  1526.                                 BAsmCode[CodeLen++] = val;
  1527.                                 return;
  1528.                         }
  1529.  
  1530.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1531.                         return;
  1532.                 }
  1533.  
  1534.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1535.         }
  1536. }
  1537.  
  1538. static void DecodeCMPW(Word Index)
  1539. {
  1540.         Byte reg;
  1541.         Byte mode1;
  1542.         Byte mode2;
  1543.         Byte disp1;
  1544.         Byte disp2;
  1545.  
  1546.   UNUSED(Index);
  1547.  
  1548.         if (ChkArgCnt(2, 2))
  1549.         {
  1550.                 if (DecodeInternal(&ArgStr[1], &mode1, &disp1, "PX"))
  1551.                 {
  1552.                         if (DecodeReg(&ArgStr[2], &reg))
  1553.                         {
  1554.                                 if (IsCoreReg(reg) && RegSize(reg) == Index)
  1555.                                 {
  1556.                                         PreByte(mode1, 1);
  1557.                                         BAsmCode[CodeLen++] = 0xd4 | Index;
  1558.                                         BAsmCode[CodeLen++] = reg;
  1559.                                         BAsmCode[CodeLen++] = disp1;
  1560.                                         return;
  1561.                                 }
  1562.                         }
  1563.  
  1564.                         if (DecodeInternal(&ArgStr[2], &mode2, &disp2, "PY"))
  1565.                         {
  1566.                                 PreByte(mode1, mode2);
  1567.                                 BAsmCode[CodeLen++] = 0xc4 | Index;
  1568.                                 BAsmCode[CodeLen++] = disp1;
  1569.                                 BAsmCode[CodeLen++] = disp2;
  1570.                                 return;
  1571.                         }
  1572.  
  1573.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1574.                         return;
  1575.                 }
  1576.  
  1577.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1578.         }
  1579. }
  1580.  
  1581. static void DecodeTEST(Word Index)
  1582. {
  1583.         Byte reg;
  1584.         Byte mode;
  1585.         Byte disp;
  1586.         LongInt val;
  1587.         LongInt addr;
  1588.  
  1589.   UNUSED(Index);
  1590.  
  1591.         if (ChkArgCnt(2, 2))
  1592.         {
  1593.                 if (DecodeReg(&ArgStr[1], &reg) && reg == RegA)
  1594.                 {
  1595.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1596.                         {
  1597.                                 BAsmCode[0] = 0x64;
  1598.                                 BAsmCode[1] = val;
  1599.                                 CodeLen = 2;
  1600.                                 return;
  1601.                         }
  1602.  
  1603.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1604.                         return;
  1605.                 }
  1606.  
  1607.                 if (DecodeDirect(&ArgStr[1], &addr))
  1608.                 {
  1609.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1610.                         {
  1611.                                 BAsmCode[CodeLen++] = 0x66;
  1612.                                 AddrOut20(addr);
  1613.                                 BAsmCode[CodeLen++] = val;
  1614.                                 return;
  1615.                         }
  1616.  
  1617.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1618.                         return;
  1619.                 }
  1620.  
  1621.                 if (DecodeInternal(&ArgStr[1], &mode, &disp, "PX"))
  1622.                 {
  1623.                         if (DecodeReg(&ArgStr[2], &reg) && reg == RegA)
  1624.                         {
  1625.                                 PreByte(mode, 1);
  1626.                                 BAsmCode[CodeLen++] = 0x67;
  1627.                                 BAsmCode[CodeLen++] = disp;
  1628.                                 return;
  1629.                         }
  1630.  
  1631.                         if (DecodeImm(&ArgStr[2], &val, 1))
  1632.                         {
  1633.                                 PreByte(mode, 1);
  1634.                                 BAsmCode[CodeLen++] = 0x65;
  1635.                                 BAsmCode[CodeLen++] = disp;
  1636.                                 BAsmCode[CodeLen++] = val;
  1637.                                 return;
  1638.                         }
  1639.  
  1640.                         WrStrErrorPos(ErrNum_InvArg, &ArgStr[2]);
  1641.                         return;
  1642.                 }
  1643.  
  1644.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1645.         }
  1646. }
  1647.  
  1648. static void DecodeJP(Word Index)
  1649. {
  1650.         const Byte OP = Index & 0xff;
  1651.         const int alen = (Index & 0x0100) ? 3 : 2;
  1652.         int i;
  1653.         Boolean ValOK;
  1654.         tSymbolFlags flags;
  1655.         LongInt addr;
  1656.         Byte mode;
  1657.         Byte disp;
  1658.         Byte reg;
  1659.  
  1660.         if (ChkArgCnt(1, 1))
  1661.         {
  1662.                 if (Index & 0x0200)
  1663.                 {
  1664.                         if (DecodeReg(&ArgStr[1], &reg) && IsR3(reg))
  1665.                         {
  1666.                                 BAsmCode[0] = 0x11;
  1667.                                 BAsmCode[1] = reg;
  1668.                                 CodeLen = 2;
  1669.                                 return;
  1670.                         }
  1671.  
  1672.                         if (DecodeInternal(&ArgStr[1], &mode, &disp, "PY"))
  1673.                         {
  1674.                                 PreByte(mode, 1);
  1675.                                 BAsmCode[CodeLen++] = 0x10;
  1676.                                 BAsmCode[CodeLen++] = disp;
  1677.                                 return;
  1678.                         }
  1679.                 }
  1680.  
  1681.                 addr = EvalStrIntExpressionWithFlags(&ArgStr[1], Int20, &ValOK, &flags);
  1682.                 if (ValOK)
  1683.                 {
  1684.                         if (!(Index & 0x100) &&
  1685.                                 !mFirstPassUnknownOrQuestionable(flags) &&
  1686.                                 (addr & 0xf0000) != (EProgCounter() & 0xf0000))
  1687.                         {
  1688.                                 WrStrErrorPos(ErrNum_TargOnDiffPage, &ArgStr[1]);
  1689.                                 return;
  1690.                         }
  1691.  
  1692.                         BAsmCode[CodeLen++] = OP;
  1693.                         for (i = 0; i < alen; i++)
  1694.                         {
  1695.                                 BAsmCode[CodeLen++] = addr >> (i * 8);
  1696.                         }
  1697.                         return;
  1698.                 }
  1699.  
  1700.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1701.         }
  1702. }
  1703.  
  1704. static void DecodeJR(Word Index)
  1705. {
  1706.         Byte OpCode = Index;
  1707.         LongInt addr;
  1708.         int disp;
  1709.         Boolean ValOK;
  1710.         tSymbolFlags flags;
  1711.  
  1712.         if (ChkArgCnt(1, 1))
  1713.         {
  1714.                 addr = EvalStrIntExpressionWithFlags(&ArgStr[1], Int20, &ValOK, &flags);
  1715.                 if (!mFirstPassUnknownOrQuestionable(flags) &&
  1716.                         (addr & 0xf0000) != (EProgCounter() & 0xf0000))
  1717.                 {
  1718.                         WrStrErrorPos(ErrNum_TargOnDiffPage, &ArgStr[1]);
  1719.                         return;
  1720.                 }
  1721.  
  1722.                 disp = addr - (EProgCounter() + 2);
  1723.  
  1724.                 if (!mFirstPassUnknownOrQuestionable(flags))
  1725.                 {
  1726.                         if (disp < -255 || disp > 255)
  1727.                         {
  1728.                                 WrStrErrorPos(ErrNum_JmpDistTooBig, &ArgStr[1]);
  1729.                                 return;
  1730.                         }
  1731.  
  1732.                         if (disp < 0)
  1733.                         {
  1734.                                 OpCode |= 0x01;
  1735.                                 disp = -disp;
  1736.                         }
  1737.                 }
  1738.  
  1739.                 BAsmCode[0] = OpCode;
  1740.                 BAsmCode[1] = disp;
  1741.                 CodeLen = 2;
  1742.         }
  1743. }
  1744.  
  1745. static void DecodeFixed(Word Index)
  1746. {
  1747.         if (ChkArgCnt(0, 0))
  1748.         {
  1749.                 BAsmCode[0] = Index;
  1750.                 CodeLen = 1;
  1751.         }
  1752. }
  1753.  
  1754. static void DecodePUSHS(Word Index)
  1755. {
  1756.         Byte reg;
  1757.  
  1758.         if (ChkArgCnt(1, 1))
  1759.         {
  1760.                 if (DecodeReg(&ArgStr[1], &reg))
  1761.                 {
  1762.                         if (IsR1(reg) || IsR2(reg) || reg == RegX || reg == RegY)
  1763.                         {
  1764.                                 BAsmCode[0] = (Index ? 0x90 : 0xb0) | reg;
  1765.                                 BAsmCode[1] = 0x37;
  1766.                                 CodeLen = 2;
  1767.                                 return;
  1768.                         }
  1769.  
  1770.                         if (reg == RegF)
  1771.                         {
  1772.                                 BAsmCode[0] = Index ? 0x5f : 0x4f;
  1773.                                 CodeLen = 1;
  1774.                                 return;
  1775.                         }
  1776.  
  1777.                         if (reg == RegIMR)
  1778.                         {
  1779.                                 BAsmCode[0] = 0x30;
  1780.                                 BAsmCode[1] = Index ? 0xe0 : 0xe8;
  1781.                                 BAsmCode[2] = Index ? 0x27 : 0x37;
  1782.                                 BAsmCode[3] = 0xfb;
  1783.                                 CodeLen = 4;
  1784.                                 return;
  1785.                         }
  1786.                 }
  1787.  
  1788.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1789.         }
  1790. }
  1791.  
  1792. static void DecodePUSHU(Word Index)
  1793. {
  1794.         const Byte OpBase = Index ? 0x38 : 0x28;
  1795.         Byte reg;
  1796.  
  1797.         if (ChkArgCnt(1, 1))
  1798.         {
  1799.                 if (DecodeReg(&ArgStr[1], &reg))
  1800.                 {
  1801.                         if (IsR1(reg) || IsR2(reg) || reg == RegX || reg == RegY)
  1802.                         {
  1803.                                 BAsmCode[0] = OpBase | reg;
  1804.                                 CodeLen = 1;
  1805.                                 return;
  1806.                         }
  1807.  
  1808.                         if (reg == RegF)
  1809.                         {
  1810.                                 BAsmCode[0] = OpBase | 0x06;
  1811.                                 CodeLen = 1;
  1812.                                 return;
  1813.                         }
  1814.  
  1815.                         if (reg == RegIMR)
  1816.                         {
  1817.                                 BAsmCode[0] = OpBase | 0x07;
  1818.                                 CodeLen = 1;
  1819.                                 return;
  1820.                         }
  1821.                 }
  1822.  
  1823.                 WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  1824.         }
  1825. }
  1826.  
  1827. /*---------------------------------------------------------------------------*/
  1828.  
  1829. static void AddMVW(const char *NName, Word NCode)
  1830. {
  1831.         AddInstTable(InstTable, NName, NCode, DecodeMVW);
  1832. }
  1833.  
  1834. static void AddEXW(const char *NName, Word NCode)
  1835. {
  1836.         AddInstTable(InstTable, NName, NCode, DecodeEXW);
  1837. }
  1838.  
  1839. static void AddADD(const char *NName, Word NCode)
  1840. {
  1841.         AddInstTable(InstTable, NName, NCode, DecodeADD);
  1842. }
  1843.  
  1844. static void AddADC(const char *NName, Word NCode)
  1845. {
  1846.         AddInstTable(InstTable, NName, NCode, DecodeADC);
  1847. }
  1848.  
  1849. static void AddADCL(const char *NName, Word NCode)
  1850. {
  1851.         AddInstTable(InstTable, NName, NCode, DecodeADCL);
  1852. }
  1853.  
  1854. static void AddAND(const char *NName, Word NCode)
  1855. {
  1856.         AddInstTable(InstTable, NName, NCode, DecodeAND);
  1857. }
  1858.  
  1859. static void AddINC(const char *NName, Word NCode)
  1860. {
  1861.         AddInstTable(InstTable, NName, NCode, DecodeINC);
  1862. }
  1863.  
  1864. static void AddROR(const char *NName, Word NCode)
  1865. {
  1866.         AddInstTable(InstTable, NName, NCode, DecodeROR);
  1867. }
  1868.  
  1869. static void AddDSRL(const char *NName, Word NCode)
  1870. {
  1871.         AddInstTable(InstTable, NName, NCode, DecodeDSRL);
  1872. }
  1873.  
  1874. static void AddCMPW(const char *NName, Word NCode)
  1875. {
  1876.         AddInstTable(InstTable, NName, NCode, DecodeCMPW);
  1877. }
  1878.  
  1879. static void AddJP(const char *NName, Word NCode)
  1880. {
  1881.         AddInstTable(InstTable, NName, NCode, DecodeJP);
  1882. }
  1883.  
  1884. static void AddJR(const char *NName, Word NCode)
  1885. {
  1886.         AddInstTable(InstTable, NName, NCode, DecodeJR);
  1887. }
  1888.  
  1889. static void AddFixed(const char *NName, Word NCode)
  1890. {
  1891.         AddInstTable(InstTable, NName, NCode, DecodeFixed);
  1892. }
  1893.  
  1894. static void AddPUSHS(const char *NName, Word NCode)
  1895. {
  1896.         AddInstTable(InstTable, NName, NCode, DecodePUSHS);
  1897. }
  1898.  
  1899. static void AddPUSHU(const char *NName, Word NCode)
  1900. {
  1901.         AddInstTable(InstTable, NName, NCode, DecodePUSHU);
  1902. }
  1903.  
  1904. static void InitFields(void)
  1905. {
  1906.         InstTable = CreateInstTable(64);
  1907.  
  1908.         /* a. MV */
  1909.         AddInstTable(InstTable, "MV", 0, DecodeMV);
  1910.         AddMVW("MVW", 0);
  1911.         AddMVW("MVP", 1);
  1912.         AddMVW("MVL", 2);
  1913.         AddMVW("MVLD", 3);
  1914.  
  1915.         /* b. EX/SWAP */
  1916.         AddInstTable(InstTable, "EX", 0, DecodeEX);
  1917.         AddEXW("EXW", 0xc1);
  1918.         AddEXW("EXP", 0xc2);
  1919.         AddEXW("EXL", 0xc3);
  1920.         AddInstTable(InstTable, "SWAP", 0xee, DecodeSWAP);
  1921.  
  1922.         /* c. ADD/ADC/SUB/SBC/DADL/DSBL/PMDF */
  1923.         AddADD("ADD", 0x40);
  1924.         AddADC("ADC", 0x50);
  1925.         AddADD("SUB", 0x48);
  1926.         AddADC("SBC", 0x58);
  1927.         AddADCL("ADCL", 0x54);
  1928.         AddADCL("SBCL", 0x5c);
  1929.         AddADCL("DADL", 0xc4);
  1930.         AddADCL("DSBL", 0xd4);
  1931.         AddInstTable(InstTable, "PMDF", 0, DecodePMDF);
  1932.  
  1933.         /* d. AND/OR/XOR */
  1934.         AddAND("AND", 0x70);
  1935.         AddAND("OR", 0x78);
  1936.         AddAND("XOR", 0x68);
  1937.  
  1938.         /* e. INC/DEC */
  1939.         AddINC("INC", 0x6c);
  1940.         AddINC("DEC", 0x7c);
  1941.  
  1942.         /* f. ROR */
  1943.         AddROR("ROR", 0xe4);
  1944.         AddROR("ROL", 0xe6);
  1945.         AddROR("SHR", 0xf4);
  1946.         AddROR("SHL", 0xf6);
  1947.         AddDSRL("DSRL", 0xfc);
  1948.         AddDSRL("DSLL", 0xec);
  1949.  
  1950.         /* g. CMP/TEST */
  1951.         AddInstTable(InstTable, "CMP", 0, DecodeCMP);
  1952.         AddCMPW("CMPW", 2);
  1953.         AddCMPW("CMPP", 3);
  1954.         AddInstTable(InstTable, "TEST", 0, DecodeTEST);
  1955.  
  1956.         /* h. JP/JPF/JR/CALL */
  1957.         AddJP("JP", 0x02 | 0x0200);
  1958.         AddJP("JPF", 0x03 | 0x0100);
  1959.         AddJR("JR", 0x12);
  1960.         AddJP("JPZ", 0x14);
  1961.         AddJP("JPNZ", 0x15);
  1962.         AddJP("JPC", 0x16);
  1963.         AddJP("JPNC", 0x17);
  1964.         AddJR("JRZ", 0x18);
  1965.         AddJR("JRNZ", 0x1a);
  1966.         AddJR("JRC", 0x1c);
  1967.         AddJR("JRNC", 0x1e);
  1968.  
  1969.         /* i. CALL/CALLF/RET */
  1970.         AddJP("CALL", 0x04);
  1971.         AddJP("CALLF", 0x05 | 0x0100);
  1972.         AddFixed("RET", 0x06);
  1973.         AddFixed("RETF", 0x07);
  1974.  
  1975.         /* j. PUSH/POP */
  1976.         AddPUSHS("PUSHS", 0);
  1977.         AddPUSHU("PUSHU", 0);
  1978.         AddPUSHS("POPS", 1);
  1979.         AddPUSHU("POPU", 1);
  1980.  
  1981.         /* k. Other */
  1982.         AddFixed("NOP", 0x00);
  1983.         AddFixed("WAIT", 0xef);
  1984.         AddFixed("SC", 0x97);
  1985.         AddFixed("RC", 0x9f);
  1986.         AddFixed("RETI", 0x01);
  1987.         AddFixed("HALT", 0xde);
  1988.         AddFixed("OFF", 0xdf);
  1989.         AddFixed("TCL", 0xce);
  1990.         AddFixed("IR", 0xfe);
  1991.         AddFixed("RESET", 0xff);
  1992. }
  1993.  
  1994. static void DeinitFields(void)
  1995. {
  1996.         DestroyInstTable(InstTable);
  1997. }
  1998.  
  1999. /*---------------------------------------------------------------------------*/
  2000.  
  2001. static void MakeCode_SC62015(void)
  2002. {
  2003.         CodeLen = 0;
  2004.         DontPrint = False;
  2005.  
  2006.         if (Memo("")) return;
  2007.  
  2008.         if (DecodeIntelPseudo(False)) return;
  2009.  
  2010.         if (!LookupInstTable(InstTable, OpPart.str.p_str))
  2011.                 WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  2012.  
  2013.         if ((EProgCounter() & 0xf0000) != ((EProgCounter() + CodeLen) & 0xf0000))
  2014.                 WrError(ErrNum_PageCrossing);
  2015. }
  2016.  
  2017. static Boolean IsDef_SC62015(void)
  2018. {
  2019.         return False;
  2020. }
  2021.  
  2022. static void SwitchFrom_SC62015(void)
  2023. {
  2024.         DeinitFields();
  2025. }
  2026.  
  2027. static void SwitchTo_SC62015(void)
  2028. {
  2029.         const TFamilyDescr *pDescr;
  2030.         TurnWords = False;
  2031.         SetIntConstMode(eIntConstModeIntel);
  2032.  
  2033.         pDescr = FindFamilyByName("SC62015");
  2034.         PCSymbol = "*";
  2035.         HeaderID = pDescr->Id;
  2036.         NOPCode = 0x00; /* NOP */
  2037.         DivideChars = ",";
  2038.         HasAttrs = False;
  2039.  
  2040.         ValidSegs = (1 << SegCode) | (1 << SegReg);
  2041.         Grans[SegCode] = 1;
  2042.         ListGrans[SegCode] = 1;
  2043.         SegInits[SegCode] = 0x00000;
  2044.         SegLimits[SegCode] = 0xfffff;
  2045.         Grans[SegReg] = 1;
  2046.         ListGrans[SegReg] = 1;
  2047.         SegInits[SegReg] = 0x00;
  2048.         SegLimits[SegReg] = 0xff;
  2049.  
  2050.         MakeCode = MakeCode_SC62015;
  2051.         IsDef = IsDef_SC62015;
  2052.         SwitchFrom = SwitchFrom_SC62015;
  2053.         InitFields();
  2054. }
  2055.  
  2056. void code62015_init(void)
  2057. {
  2058.         CPUSC62015 = AddCPU("SC62015", SwitchTo_SC62015);
  2059. }
  2060.