Subversion Repositories pentevo

Rev

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

  1. /* code78k0.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator 78K0-Familie                                                */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <ctype.h>
  14.  
  15. #include "bpemu.h"
  16. #include "strutil.h"
  17. #include "asmdef.h"
  18. #include "asmsub.h"
  19. #include "asmpars.h"
  20. #include "asmitree.h"
  21. #include "codepseudo.h"
  22. #include "intpseudo.h"
  23. #include "codevars.h"
  24. #include "errmsg.h"
  25.  
  26. #include "code78k0.h"
  27.  
  28. enum
  29. {
  30.   ModNone = -1,
  31.   ModReg8 = 0,
  32.   ModReg16 = 1,
  33.   ModImm = 2,
  34.   ModShort = 3,
  35.   ModSFR = 4,
  36.   ModAbs = 5,
  37.   ModIReg = 6,
  38.   ModIndex = 7,
  39.   ModDisp = 8
  40. };
  41.  
  42. #define MModReg8 (1 << ModReg8)
  43. #define MModReg16 (1 << ModReg16)
  44. #define MModImm (1 << ModImm)
  45. #define MModShort (1 << ModShort)
  46. #define MModSFR (1 << ModSFR)
  47. #define MModAbs (1 << ModAbs)
  48. #define MModIReg (1 << ModIReg)
  49. #define MModIndex (1 << ModIndex)
  50. #define MModDisp (1 << ModDisp)
  51.  
  52. #define AccReg 1
  53. #define AccReg16 0
  54.  
  55. static Byte OpSize,AdrPart;
  56. static Byte AdrVals[2];
  57. static ShortInt AdrMode;
  58.  
  59. static CPUVar CPU78070;
  60.  
  61. /*-------------------------------------------------------------------------*/
  62. /* Adressausdruck parsen */
  63.  
  64. static void DecodeAdr(const tStrComp *pArg, Word Mask)
  65. {
  66.   static const char RegNames[8][2] =
  67.   {
  68.     "X","A","C","B","E","D","L","H"
  69.   };
  70.  
  71.   Word AdrWord;
  72.   int z;
  73.   Boolean OK, LongFlag;
  74.   int ArgLen = strlen(pArg->str.p_str);
  75.   tSymbolFlags Flags;
  76.  
  77.   AdrMode = ModNone;
  78.   AdrCnt = 0;
  79.  
  80.   /* Register */
  81.  
  82.   for (z = 0; z < 8; z++)
  83.     if (!as_strcasecmp(pArg->str.p_str, RegNames[z]))
  84.     {
  85.       AdrMode = ModReg8;
  86.       AdrPart = z;
  87.       goto chk;
  88.     }
  89.  
  90.   if (as_toupper(*pArg->str.p_str) == 'R')
  91.   {
  92.     if ((strlen(pArg->str.p_str) == 2) && (pArg->str.p_str[1] >= '0') && (pArg->str.p_str[1] <= '7'))
  93.     {
  94.       AdrMode = ModReg8;
  95.       AdrPart = pArg->str.p_str[1] - '0';
  96.       goto chk;
  97.     }
  98.     else if ((ArgLen == 3) && (as_toupper(pArg->str.p_str[1]) == 'P') && (pArg->str.p_str[2] >= '0') && (pArg->str.p_str[2] <= '3'))
  99.     {
  100.       AdrMode = ModReg16;
  101.       AdrPart = pArg->str.p_str[2] - '0';
  102.       goto chk;
  103.     }
  104.   }
  105.  
  106.   if (ArgLen == 2)
  107.   {
  108.     for (z = 0; z < 4; z++)
  109.       if ((as_toupper(*pArg->str.p_str) == *RegNames[(z << 1) + 1])
  110.        && (as_toupper(pArg->str.p_str[1]) == *RegNames[z << 1]))
  111.       {
  112.         AdrMode = ModReg16;
  113.         AdrPart = z;
  114.         goto chk;
  115.       }
  116.   }
  117.  
  118.   /* immediate */
  119.  
  120.   if (*pArg->str.p_str == '#')
  121.   {
  122.     switch (OpSize)
  123.     {
  124.       case 0:
  125.         AdrVals[0] = EvalStrIntExpressionOffs(pArg, 1, Int8, &OK);
  126.         break;
  127.       case 1:
  128.         AdrWord = EvalStrIntExpressionOffs(pArg, 1, Int16, &OK);
  129.         if (OK)
  130.         {
  131.           AdrVals[0] = Lo(AdrWord);
  132.           AdrVals[1] = Hi(AdrWord);
  133.         }
  134.         break;
  135.     }
  136.     if (OK)
  137.     {
  138.       AdrMode = ModImm;
  139.       AdrCnt = OpSize + 1;
  140.     }
  141.     goto chk;
  142.   }
  143.  
  144.   /* indirekt */
  145.  
  146.   if ((*pArg->str.p_str == '[') && (pArg->str.p_str[ArgLen - 1] == ']'))
  147.   {
  148.     tStrComp Arg;
  149.  
  150.     StrCompRefRight(&Arg, pArg, 1);
  151.     StrCompShorten(&Arg, 1);
  152.  
  153.     if ((!as_strcasecmp(Arg.str.p_str, "DE")) || (!as_strcasecmp(Arg.str.p_str, "RP2")))
  154.     {
  155.       AdrMode = ModIReg;
  156.       AdrPart = 0;
  157.     }
  158.     else if ((!as_strncasecmp(Arg.str.p_str, "HL", 2)) && (!as_strncasecmp(Arg.str.p_str, "RP3", 3))) WrStrErrorPos(ErrNum_InvReg, &Arg);
  159.     else
  160.     {
  161.       StrCompIncRefLeft(&Arg, 2);
  162.       if (*Arg.str.p_str == '3')
  163.         StrCompIncRefLeft(&Arg, 1);
  164.       if ((!as_strcasecmp(Arg.str.p_str, "+B")) || (!as_strcasecmp(Arg.str.p_str, "+R3")))
  165.       {
  166.         AdrMode = ModIndex;
  167.         AdrPart = 1;
  168.       }
  169.       else if ((!as_strcasecmp(Arg.str.p_str, "+C")) || (!as_strcasecmp(Arg.str.p_str, "+R2")))
  170.       {
  171.         AdrMode = ModIndex;
  172.         AdrPart = 0;
  173.       }
  174.       else
  175.       {
  176.         if (Arg.str.p_str[0])
  177.           AdrVals[0] = EvalStrIntExpression(&Arg, UInt8, &OK);
  178.         else
  179.         {
  180.           AdrVals[0] = 0;
  181.           OK = True;
  182.         }
  183.         if (OK)
  184.         {
  185.           if (AdrVals[0] == 0)
  186.           {
  187.             AdrMode = ModIReg;
  188.             AdrPart = 1;
  189.           }
  190.           else
  191.           {
  192.             AdrMode = ModDisp;
  193.             AdrCnt = 1;
  194.           }
  195.         }
  196.       }
  197.     }
  198.  
  199.     goto chk;
  200.   }
  201.  
  202.   /* erzwungen lang ? */
  203.  
  204.   LongFlag = !!(*pArg->str.p_str == '!');
  205.  
  206.   /* -->absolut */
  207.  
  208.   AdrWord = EvalStrIntExpressionOffsWithFlags(pArg, LongFlag, UInt16, &OK, &Flags);
  209.   if (mFirstPassUnknown(Flags))
  210.   {
  211.     AdrWord &= 0xffffe;
  212.     if (!(Mask & MModAbs))
  213.       AdrWord = (AdrWord | 0xff00) & 0xff1f;
  214.   }
  215.   if (OK)
  216.   {
  217.     if ((!LongFlag) && (Mask & MModShort) && (AdrWord >= 0xfe20) && (AdrWord <= 0xff1f))
  218.     {
  219.       AdrMode = ModShort;
  220.       AdrCnt = 1;
  221.       AdrVals[0] = Lo(AdrWord);
  222.     }
  223.     else if ((!LongFlag) && (Mask & MModSFR) && (((AdrWord >= 0xff00) && (AdrWord <= 0xffcf)) || (AdrWord >= 0xffe0)))
  224.     {
  225.       AdrMode = ModSFR;
  226.       AdrCnt = 1;
  227.       AdrVals[0] = Lo(AdrWord);
  228.     }
  229.     else
  230.     {
  231.       AdrMode = ModAbs;
  232.       AdrCnt = 2;
  233.       AdrVals[0] = Lo(AdrWord);
  234.       AdrVals[1] = Hi(AdrWord);
  235.     }
  236.   }
  237.  
  238. chk:
  239.   if ((AdrMode != ModNone) && (!(Mask & (1 << AdrMode))))
  240.   {
  241.     WrError(ErrNum_InvAddrMode);
  242.     AdrMode = ModNone;
  243.     AdrCnt = 0;
  244.   }
  245. }
  246.  
  247. static void ChkEven(void)
  248. {
  249.   if ((AdrMode==ModAbs) || (AdrMode==ModShort) || (AdrMode==ModSFR))
  250.     if ((AdrVals[0]&1)==1) WrError(ErrNum_AddrNotAligned);
  251. }
  252.  
  253. static Boolean DecodeBitAdr(const tStrComp *pArg, Byte *Erg)
  254. {
  255.   char *p;
  256.   Boolean OK;
  257.   tStrComp Reg, Bit;
  258.  
  259.   p = RQuotPos(pArg->str.p_str, '.');
  260.   if (!p)
  261.   {
  262.     WrError(ErrNum_InvBitPos);
  263.     return False;
  264.   }
  265.  
  266.   StrCompSplitRef(&Reg, &Bit, pArg, p);
  267.   *Erg = EvalStrIntExpression(&Bit, UInt3, &OK) << 4;
  268.   if (!OK)
  269.     return False;
  270.  
  271.   DecodeAdr(&Reg, MModShort | MModSFR | MModIReg | MModReg8);
  272.   switch (AdrMode)
  273.   {
  274.     case ModReg8:
  275.       if (AdrPart != AccReg)
  276.       {
  277.         WrError(ErrNum_InvAddrMode);
  278.         return False;
  279.       }
  280.       else
  281.       {
  282.         *Erg += 0x88;
  283.         return True;
  284.       }
  285.     case ModShort:
  286.       return True;
  287.     case ModSFR:
  288.       *Erg += 0x08;
  289.       return True;
  290.     case ModIReg:
  291.       if (AdrPart == 0)
  292.       {
  293.         WrError(ErrNum_InvAddrMode);
  294.         return False;
  295.       }
  296.       else
  297.       {
  298.         *Erg += 0x80;
  299.         return True;
  300.       }
  301.     default:
  302.       return False;
  303.   }
  304. }
  305.  
  306. /*-------------------------------------------------------------------------*/
  307. /* Instruction Decoders */
  308.  
  309. /* ohne Argument */
  310.  
  311. static void DecodeFixed(Word Code)
  312. {
  313.   if (ChkArgCnt(0, 0))
  314.   {
  315.     if (Hi(Code))
  316.       BAsmCode[CodeLen++] = Hi(Code);
  317.     BAsmCode[CodeLen++] = Lo(Code);
  318.   }
  319. }
  320.  
  321. /* Datentransfer */
  322.  
  323. static void DecodeMOV(Word Index)
  324. {
  325.   Byte HReg;
  326.  
  327.   UNUSED(Index);
  328.  
  329.   if (ChkArgCnt(2, 2))
  330.   {
  331.     DecodeAdr(&ArgStr[1], MModReg8 | MModShort | MModSFR | MModAbs
  332.                        | MModIReg | MModIndex | MModDisp);
  333.     switch (AdrMode)
  334.     {
  335.       case ModReg8:
  336.         HReg = AdrPart;
  337.         DecodeAdr(&ArgStr[2], MModImm | MModReg8
  338.                            | ((HReg == AccReg) ? MModShort | MModSFR | MModAbs | MModIReg | MModIndex | MModDisp : 0));
  339.         switch (AdrMode)
  340.         {
  341.           case ModReg8:
  342.             if ((HReg == AccReg) == (AdrPart == AccReg)) WrError(ErrNum_InvAddrMode);
  343.             else if (HReg == AccReg)
  344.             {
  345.               CodeLen = 1;
  346.               BAsmCode[0] = 0x60 + AdrPart;
  347.             }
  348.             else
  349.             {
  350.               CodeLen = 1;
  351.               BAsmCode[0] = 0x70 + HReg;
  352.             }
  353.             break;
  354.           case ModImm:
  355.             CodeLen = 2;
  356.             BAsmCode[0] = 0xa0 + HReg;
  357.             BAsmCode[1] = AdrVals[0];
  358.             break;
  359.           case ModShort:
  360.             CodeLen = 2;
  361.             BAsmCode[0] = 0xf0;
  362.             BAsmCode[1] = AdrVals[0];
  363.             break;
  364.           case ModSFR:
  365.             CodeLen = 2;
  366.             BAsmCode[0] = 0xf4;
  367.             BAsmCode[1] = AdrVals[0];
  368.             break;
  369.           case ModAbs:
  370.             CodeLen = 3;
  371.             BAsmCode[0] = 0x8e;
  372.             memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  373.             break;
  374.           case ModIReg:
  375.             CodeLen = 1;
  376.             BAsmCode[0] = 0x85 + (AdrPart << 1);
  377.             break;
  378.           case ModIndex:
  379.             CodeLen = 1;
  380.             BAsmCode[0] = 0xaa + AdrPart;
  381.             break;
  382.           case ModDisp:
  383.             CodeLen = 2;
  384.             BAsmCode[0] = 0xae;
  385.             BAsmCode[1] = AdrVals[0];
  386.             break;
  387.         }
  388.         break;
  389.  
  390.       case ModShort:
  391.         BAsmCode[1] = AdrVals[0];
  392.         DecodeAdr(&ArgStr[2], MModReg8 | MModImm);
  393.         switch (AdrMode)
  394.         {
  395.           case ModReg8:
  396.             if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  397.             else
  398.             {
  399.               BAsmCode[0] = 0xf2;
  400.               CodeLen = 2;
  401.             }
  402.             break;
  403.           case ModImm:
  404.             BAsmCode[0] = 0x11;
  405.             BAsmCode[2] = AdrVals[0];
  406.             CodeLen = 3;
  407.             break;
  408.         }
  409.         break;
  410.  
  411.       case ModSFR:
  412.         BAsmCode[1] = AdrVals[0];
  413.         DecodeAdr(&ArgStr[2], MModReg8 | MModImm);
  414.         switch (AdrMode)
  415.         {
  416.           case ModReg8:
  417.             if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  418.             else
  419.             {
  420.               BAsmCode[0] = 0xf6;
  421.               CodeLen = 2;
  422.             }
  423.             break;
  424.           case ModImm:
  425.             BAsmCode[0] = 0x13;
  426.             BAsmCode[2] = AdrVals[0];
  427.             CodeLen = 3;
  428.             break;
  429.         }
  430.         break;
  431.  
  432.       case ModAbs:
  433.         memcpy(BAsmCode + 1, AdrVals, 2);
  434.         DecodeAdr(&ArgStr[2], MModReg8);
  435.         if (AdrMode == ModReg8)
  436.         {
  437.           if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  438.           else
  439.           {
  440.             BAsmCode[0] = 0x9e;
  441.             CodeLen = 3;
  442.           }
  443.         }
  444.         break;
  445.  
  446.       case ModIReg:
  447.         HReg = AdrPart;
  448.         DecodeAdr(&ArgStr[2], MModReg8);
  449.         if (AdrMode == ModReg8)
  450.         {
  451.           if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  452.           else
  453.           {
  454.             BAsmCode[0] = 0x95 | (HReg << 1);
  455.             CodeLen = 1;
  456.           }
  457.         }
  458.         break;
  459.  
  460.       case ModIndex:
  461.         HReg = AdrPart;
  462.         DecodeAdr(&ArgStr[2], MModReg8);
  463.         if (AdrMode == ModReg8)
  464.         {
  465.           if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  466.           else
  467.           {
  468.             BAsmCode[0] = 0xba + HReg;
  469.             CodeLen = 1;
  470.           }
  471.         }
  472.         break;
  473.  
  474.       case ModDisp:
  475.         BAsmCode[1] = AdrVals[0];
  476.         DecodeAdr(&ArgStr[2], MModReg8);
  477.         if (AdrMode == ModReg8)
  478.         {
  479.           if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  480.           else
  481.           {
  482.             BAsmCode[0] = 0xbe;
  483.             CodeLen = 2;
  484.           }
  485.         }
  486.         break;
  487.     }
  488.   }
  489. }
  490.  
  491. static void DecodeXCH(Word Index)
  492. {
  493.   UNUSED(Index);
  494.  
  495.   if (ChkArgCnt(2, 2))
  496.   {
  497.     Boolean Swap = (!as_strcasecmp(ArgStr[2].str.p_str, "A")) || (!as_strcasecmp(ArgStr[2].str.p_str, "RP1"));
  498.     tStrComp *pArg1 = Swap ? &ArgStr[2] : &ArgStr[1],
  499.              *pArg2 = Swap ? &ArgStr[1] : &ArgStr[2];
  500.  
  501.     DecodeAdr(pArg1, MModReg8);
  502.     if (AdrMode != ModNone)
  503.     {
  504.       if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  505.       else
  506.       {
  507.         DecodeAdr(pArg2, MModReg8 | MModShort | MModSFR | MModAbs
  508.                        | MModIReg | MModIndex | MModDisp);
  509.         switch (AdrMode)
  510.         {
  511.           case ModReg8:
  512.             if (AdrPart == AccReg) WrError(ErrNum_InvAddrMode);
  513.             else
  514.             {
  515.               BAsmCode[0] = 0x30 + AdrPart;
  516.               CodeLen = 1;
  517.             }
  518.             break;
  519.           case ModShort:
  520.             BAsmCode[0] = 0x83;
  521.             BAsmCode[1] = AdrVals[0];
  522.             CodeLen = 2;
  523.             break;
  524.           case ModSFR:
  525.             BAsmCode[0] = 0x93;
  526.             BAsmCode[1] = AdrVals[0];
  527.             CodeLen = 2;
  528.             break;
  529.           case ModAbs:
  530.             BAsmCode[0] = 0xce;
  531.             memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  532.             CodeLen = 3;
  533.             break;
  534.           case ModIReg:
  535.             BAsmCode[0] = 0x05 + (AdrPart << 1);
  536.             CodeLen = 1;
  537.             break;
  538.           case ModIndex:
  539.             BAsmCode[0] = 0x31;
  540.             BAsmCode[1] = 0x8a + AdrPart;
  541.             CodeLen = 2;
  542.             break;
  543.           case ModDisp:
  544.             BAsmCode[0] = 0xde;
  545.             BAsmCode[1] = AdrVals[0];
  546.             CodeLen = 2;
  547.             break;
  548.         }
  549.       }
  550.     }
  551.   }
  552. }
  553.  
  554. static void DecodeMOVW(Word Index)
  555. {
  556.   Byte HReg;
  557.  
  558.   UNUSED(Index);
  559.  
  560.   OpSize = 1;
  561.  
  562.   if (ChkArgCnt(2, 2))
  563.   {
  564.     DecodeAdr(&ArgStr[1], MModReg16 | MModShort | MModSFR | MModAbs);
  565.     switch (AdrMode)
  566.     {
  567.       case ModReg16:
  568.         HReg = AdrPart;
  569.         DecodeAdr(&ArgStr[2], MModReg16 | MModImm
  570.                            | ((HReg == AccReg16) ? MModShort | MModSFR | MModAbs : 0));
  571.         switch (AdrMode)
  572.         {
  573.           case ModReg16:
  574.             if ((HReg == AccReg16) == (AdrPart == AccReg16)) WrError(ErrNum_InvAddrMode);
  575.             else if (HReg == AccReg16)
  576.             {
  577.               BAsmCode[0] = 0xc0 + (AdrPart << 1);
  578.               CodeLen = 1;
  579.             }
  580.             else
  581.             {
  582.               BAsmCode[0] = 0xd0 + (HReg << 1);
  583.               CodeLen = 1;
  584.             }
  585.             break;
  586.           case ModImm:
  587.             BAsmCode[0] = 0x10 + (HReg << 1);
  588.             memcpy(BAsmCode + 1, AdrVals, 2);
  589.             CodeLen = 3;
  590.             break;
  591.           case ModShort:
  592.             BAsmCode[0] = 0x89;
  593.             BAsmCode[1] = AdrVals[0];
  594.             CodeLen = 2;
  595.             ChkEven();
  596.             break;
  597.           case ModSFR:
  598.             BAsmCode[0] = 0xa9;
  599.             BAsmCode[1] = AdrVals[0];
  600.             CodeLen = 2;
  601.             ChkEven();
  602.             break;
  603.           case ModAbs:
  604.             BAsmCode[0] = 0x02;
  605.             memcpy(BAsmCode + 1, AdrVals, 2);
  606.             CodeLen = 3;
  607.             ChkEven();
  608.             break;
  609.         }
  610.         break;
  611.  
  612.       case ModShort:
  613.         ChkEven();
  614.         BAsmCode[1] = AdrVals[0];
  615.         DecodeAdr(&ArgStr[2], MModReg16 | MModImm);
  616.         switch (AdrMode)
  617.         {
  618.           case ModReg16:
  619.             if (AdrPart != AccReg16) WrError(ErrNum_InvAddrMode);
  620.             else
  621.             {
  622.               BAsmCode[0] = 0x99;
  623.               CodeLen = 2;
  624.             }
  625.             break;
  626.           case ModImm:
  627.             BAsmCode[0] = 0xee;
  628.             memcpy(BAsmCode + 2, AdrVals, 2);
  629.             CodeLen = 4;
  630.             break;
  631.         }
  632.         break;
  633.  
  634.       case ModSFR:
  635.         ChkEven();
  636.         BAsmCode[1] = AdrVals[0];
  637.         DecodeAdr(&ArgStr[2], MModReg16 | MModImm);
  638.         switch (AdrMode)
  639.         {
  640.           case ModReg16:
  641.             if (AdrPart != AccReg16) WrError(ErrNum_InvAddrMode);
  642.             else
  643.             {
  644.               BAsmCode[0] = 0xb9;
  645.               CodeLen = 2;
  646.             }
  647.            break;
  648.           case ModImm:
  649.             BAsmCode[0] = 0xfe;
  650.             memcpy(BAsmCode + 2,AdrVals, 2);
  651.             CodeLen = 4;
  652.             break;
  653.         }
  654.         break;
  655.  
  656.       case ModAbs:
  657.         ChkEven();
  658.         memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  659.         DecodeAdr(&ArgStr[2], MModReg16);
  660.         if (AdrMode == ModReg16)
  661.         {
  662.           if (AdrPart != AccReg16) WrError(ErrNum_InvAddrMode);
  663.           else
  664.           {
  665.             BAsmCode[0] = 0x03;
  666.             CodeLen = 3;
  667.           }
  668.         }
  669.         break;
  670.     }
  671.   }
  672. }
  673.  
  674. static void DecodeXCHW(Word Index)
  675. {
  676.   Byte HReg;
  677.  
  678.   UNUSED(Index);
  679.  
  680.   if (ChkArgCnt(2, 2))
  681.   {
  682.     DecodeAdr(&ArgStr[1], MModReg16);
  683.     if (AdrMode == ModReg16)
  684.     {
  685.       HReg = AdrPart;
  686.       DecodeAdr(&ArgStr[2], MModReg16);
  687.       if (AdrMode == ModReg16)
  688.       {
  689.         if ((HReg == AccReg16) == (AdrPart == AccReg16)) WrError(ErrNum_InvAddrMode);
  690.         else
  691.         {
  692.           BAsmCode[0] = (HReg == AccReg16) ? 0xe0 + (AdrPart << 1) : 0xe0 + (HReg << 1);
  693.           CodeLen = 1;
  694.         }
  695.       }
  696.     }
  697.   }
  698. }
  699.  
  700. static void DecodeStack(Word Index)
  701. {
  702.   if (!ChkArgCnt(1, 1));
  703.   else if (!as_strcasecmp(ArgStr[1].str.p_str, "PSW"))
  704.   {
  705.     BAsmCode[0] = 0x22 + Index;
  706.     CodeLen = 1;
  707.   }
  708.   else
  709.   {
  710.     DecodeAdr(&ArgStr[1], MModReg16);
  711.     if (AdrMode == ModReg16)
  712.     {
  713.       BAsmCode[0] = 0xb1 - Index + (AdrPart << 1);
  714.       CodeLen = 1;
  715.     }
  716.   }
  717. }
  718.  
  719. /* Arithmetik */
  720.  
  721. static void DecodeAri(Word Index)
  722. {
  723.   Byte HReg;
  724.  
  725.   if (ChkArgCnt(2, 2))
  726.   {
  727.     DecodeAdr(&ArgStr[1], MModReg8 | MModShort);
  728.     switch (AdrMode)
  729.     {
  730.       case ModReg8:
  731.         HReg = AdrPart;
  732.         DecodeAdr(&ArgStr[2], MModReg8 | ((HReg == AccReg) ? (MModImm | MModShort | MModAbs | MModIReg | MModIndex | MModDisp) : 0));
  733.         switch (AdrMode)
  734.         {
  735.           case ModReg8:
  736.             if (AdrPart == AccReg)
  737.             {
  738.               BAsmCode[0] = 0x61;
  739.               BAsmCode[1] = (Index << 4) + HReg;
  740.               CodeLen = 2;
  741.             }
  742.             else if (HReg == AccReg)
  743.             {
  744.               BAsmCode[0] = 0x61;
  745.               BAsmCode[1] = 0x08 + (Index << 4) + AdrPart;
  746.               CodeLen = 2;
  747.             }
  748.             else WrError(ErrNum_InvAddrMode);
  749.             break;
  750.           case ModImm:
  751.             BAsmCode[0] = (Index << 4) + 0x0d;
  752.             BAsmCode[1] = AdrVals[0];
  753.             CodeLen = 2;
  754.             break;
  755.           case ModShort:
  756.             BAsmCode[0] = (Index << 4) + 0x0e;
  757.             BAsmCode[1] = AdrVals[0];
  758.             CodeLen = 2;
  759.             break;
  760.           case ModAbs:
  761.             BAsmCode[0] = (Index << 4) + 0x08;
  762.             memcpy(BAsmCode + 1, AdrVals, 2);
  763.             CodeLen = 3;
  764.             break;
  765.           case ModIReg:
  766.             if (AdrPart == 0) WrError(ErrNum_InvAddrMode);
  767.             else
  768.             {
  769.               BAsmCode[0] = (Index << 4) + 0x0f;
  770.               CodeLen = 1;
  771.             }
  772.             break;
  773.           case ModIndex:
  774.             BAsmCode[0] = 0x31;
  775.             BAsmCode[1] = (Index << 4) + 0x0a + AdrPart;
  776.             CodeLen = 2;
  777.             break;
  778.           case ModDisp:
  779.             BAsmCode[0] = (Index << 4) + 0x09;
  780.             BAsmCode[1] = AdrVals[0];
  781.             CodeLen = 2;
  782.             break;
  783.         }
  784.         break;
  785.  
  786.       case ModShort:
  787.         BAsmCode[1] = AdrVals[0];
  788.         DecodeAdr(&ArgStr[2], MModImm);
  789.         if (AdrMode == ModImm)
  790.         {
  791.           BAsmCode[0] = (Index << 4) + 0x88;
  792.           BAsmCode[2] = AdrVals[0];
  793.           CodeLen = 3;
  794.         }
  795.         break;
  796.     }
  797.   }
  798. }
  799.  
  800. static void DecodeAri16(Word Index)
  801. {
  802.   if (ChkArgCnt(2, 2))
  803.   {
  804.     OpSize = 1;
  805.     DecodeAdr(&ArgStr[1], MModReg16);
  806.     if (AdrMode == ModReg16)
  807.     {
  808.       DecodeAdr(&ArgStr[2], MModImm);
  809.       if (AdrMode == ModImm)
  810.       {
  811.         BAsmCode[0] = 0xca + (Index << 4);
  812.         memcpy(BAsmCode + 1, AdrVals, 2);
  813.         CodeLen = 3;
  814.       }
  815.     }
  816.   }
  817. }
  818.  
  819. static void DecodeMULU(Word Index)
  820. {
  821.   UNUSED(Index);
  822.  
  823.   if (ChkArgCnt(1, 1))
  824.   {
  825.     DecodeAdr(&ArgStr[1], MModReg8);
  826.     if (AdrMode == ModReg8)
  827.     {
  828.       if (AdrPart != 0) WrError(ErrNum_InvAddrMode);
  829.       else
  830.       {
  831.         BAsmCode[0] = 0x31;
  832.         BAsmCode[1] = 0x88;
  833.         CodeLen = 2;
  834.       }
  835.     }
  836.   }
  837. }
  838.  
  839. static void DecodeDIVUW(Word Index)
  840. {
  841.   UNUSED(Index);
  842.  
  843.   if (ChkArgCnt(1, 1))
  844.   {
  845.     DecodeAdr(&ArgStr[1], MModReg8);
  846.     if (AdrMode == ModReg8)
  847.     {
  848.       if (AdrPart != 2) WrError(ErrNum_InvAddrMode);
  849.       else
  850.       {
  851.         BAsmCode[0] = 0x31;
  852.         BAsmCode[1] = 0x82;
  853.         CodeLen = 2;
  854.       }
  855.     }
  856.   }
  857. }
  858.  
  859. static void DecodeINCDEC(Word Index)
  860. {
  861.   if (ChkArgCnt(1, 1))
  862.   {
  863.     DecodeAdr(&ArgStr[1], MModReg8 | MModShort);
  864.     switch (AdrMode)
  865.     {
  866.       case ModReg8:
  867.         BAsmCode[0] = 0x40 + AdrPart + Index;
  868.         CodeLen = 1;
  869.         break;
  870.       case ModShort:
  871.         BAsmCode[0] = 0x81 + Index;
  872.         BAsmCode[1] = AdrVals[0];
  873.         CodeLen = 2;
  874.         break;
  875.     }
  876.   }
  877. }
  878.  
  879. static void DecodeINCDECW(Word Index)
  880. {
  881.   if (ChkArgCnt(1, 1))
  882.   {
  883.     DecodeAdr(&ArgStr[1], MModReg16);
  884.     if (AdrMode == ModReg16)
  885.     {
  886.       BAsmCode[0] = 0x80 + Index + (AdrPart << 1);
  887.       CodeLen = 1;
  888.     }
  889.   }
  890. }
  891.  
  892. static void DecodeShift(Word Index)
  893. {
  894.   Byte HReg;
  895.   Boolean OK;
  896.  
  897.   if (ChkArgCnt(2, 2))
  898.   {
  899.     DecodeAdr(&ArgStr[1], MModReg8);
  900.     if (AdrMode == ModReg8)
  901.     {
  902.       if (AdrPart != AccReg) WrError(ErrNum_InvAddrMode);
  903.       else
  904.       {
  905.         HReg = EvalStrIntExpression(&ArgStr[2], UInt1, &OK);
  906.         if (OK)
  907.         {
  908.           if (HReg != 1) WrError(ErrNum_UnderRange);
  909.           else
  910.           {
  911.             BAsmCode[0] = 0x24 + Index;
  912.             CodeLen = 1;
  913.           }
  914.         }
  915.       }
  916.     }
  917.   }
  918. }
  919.  
  920. static void DecodeRot4(Word Index)
  921. {
  922.   if (ChkArgCnt(1, 1))
  923.   {
  924.     DecodeAdr(&ArgStr[1], MModIReg);
  925.     if (AdrMode == ModIReg)
  926.     {
  927.       if (AdrPart == 0) WrError(ErrNum_InvAddrMode);
  928.       else
  929.       {
  930.         BAsmCode[0] = 0x31;
  931.         BAsmCode[1] = 0x80 + Index;
  932.         CodeLen = 2;
  933.       }
  934.     }
  935.   }
  936. }
  937.  
  938. /* Bitoperationen */
  939.  
  940. static void DecodeMOV1(Word Index)
  941. {
  942.   Byte HReg;
  943.  
  944.   UNUSED(Index);
  945.  
  946.   if (ChkArgCnt(2, 2))
  947.   {
  948.     Boolean Swap = !as_strcasecmp(ArgStr[2].str.p_str, "CY");
  949.     tStrComp *pArg1 = Swap ? &ArgStr[2] : &ArgStr[1],
  950.              *pArg2 = Swap ? &ArgStr[1] : &ArgStr[2];
  951.     int z = Swap ? 1 : 4;
  952.  
  953.     if (as_strcasecmp(pArg1->str.p_str, "CY")) WrError(ErrNum_InvAddrMode);
  954.     else if (DecodeBitAdr(pArg2, &HReg))
  955.     {
  956.       BAsmCode[0] = 0x61 + (Ord((HReg & 0x88) != 0x88) << 4);
  957.       BAsmCode[1] = z + HReg;
  958.       memcpy(BAsmCode + 2, AdrVals, AdrCnt);
  959.       CodeLen = 2 + AdrCnt;
  960.     }
  961.   }
  962. }
  963.  
  964. static void DecodeBit2(Word Index)
  965. {
  966.   Byte HReg;
  967.  
  968.   if (!ChkArgCnt(2, 2));
  969.   else if (as_strcasecmp(ArgStr[1].str.p_str, "CY")) WrError(ErrNum_InvAddrMode);
  970.   else if (DecodeBitAdr(&ArgStr[2], &HReg))
  971.   {
  972.     BAsmCode[0] = 0x61 + (Ord((HReg & 0x88) != 0x88) << 4);
  973.     BAsmCode[1] = Index + 5 + HReg;
  974.     memcpy(BAsmCode + 2, AdrVals, AdrCnt);
  975.     CodeLen = 2 + AdrCnt;
  976.   }
  977. }
  978.  
  979. static void DecodeSETCLR1(Word Index)
  980. {
  981.   Byte HReg;
  982.  
  983.   if (!ChkArgCnt(1, 1));
  984.   else if (!as_strcasecmp(ArgStr[1].str.p_str, "CY"))
  985.   {
  986.     BAsmCode[0] = 0x20 + Index;
  987.     CodeLen = 1;
  988.   }
  989.   else if (DecodeBitAdr(&ArgStr[1], &HReg))
  990.   {
  991.     if ((HReg & 0x88) == 0)
  992.     {
  993.       BAsmCode[0] = 0x0a + Index + (HReg & 0x70);
  994.       BAsmCode[1] = AdrVals[0];
  995.       CodeLen = 2;
  996.     }
  997.     else
  998.     {
  999.       BAsmCode[0] =0x61 + (Ord((HReg & 0x88) != 0x88) << 4);
  1000.       BAsmCode[1] =HReg + 2 + Index;
  1001.       memcpy(BAsmCode + 2, AdrVals, AdrCnt);
  1002.       CodeLen=2 + AdrCnt;
  1003.     }
  1004.   }
  1005. }
  1006.  
  1007. static void DecodeNOT1(Word Index)
  1008. {
  1009.   UNUSED(Index);
  1010.  
  1011.   if (!ChkArgCnt(1, 1));
  1012.   else if (as_strcasecmp(ArgStr[1].str.p_str, "CY")) WrError(ErrNum_InvAddrMode);
  1013.   else
  1014.   {
  1015.     BAsmCode[0] = 0x01;
  1016.     CodeLen = 1;
  1017.   }
  1018. }
  1019.  
  1020. /* Spruenge */
  1021.  
  1022. static void DecodeCALL(Word Index)
  1023. {
  1024.   UNUSED(Index);
  1025.  
  1026.   if (ChkArgCnt(1, 1))
  1027.   {
  1028.     DecodeAdr(&ArgStr[1], MModAbs);
  1029.     if (AdrMode == ModAbs)
  1030.     {
  1031.       BAsmCode[0] = 0x9a;
  1032.       memcpy(BAsmCode + 1, AdrVals, 2);
  1033.       CodeLen = 3;
  1034.     }
  1035.   }
  1036. }
  1037.  
  1038. static void DecodeCALLF(Word Index)
  1039. {
  1040.   Word AdrWord;
  1041.   Boolean OK;
  1042.  
  1043.   UNUSED(Index);
  1044.  
  1045.   if (ChkArgCnt(1, 1))
  1046.   {
  1047.     AdrWord = EvalStrIntExpressionOffs(&ArgStr[1], !!(*ArgStr[1].str.p_str == '!'), UInt11, &OK);
  1048.     if (OK)
  1049.     {
  1050.       BAsmCode[0] = 0x0c | (Hi(AdrWord) << 4);
  1051.       BAsmCode[1] = Lo(AdrWord);
  1052.       CodeLen = 2;
  1053.     }
  1054.   }
  1055. }
  1056.  
  1057. static void DecodeCALLT(Word Index)
  1058. {
  1059.   Word AdrWord;
  1060.   Boolean OK;
  1061.   int l = strlen(ArgStr[1].str.p_str);
  1062.  
  1063.   UNUSED(Index);
  1064.  
  1065.   if (!ChkArgCnt(1, 1));
  1066.   else if ((*ArgStr[1].str.p_str != '[') || (ArgStr[1].str.p_str[l - 1] != ']')) WrError(ErrNum_InvAddrMode);
  1067.   else
  1068.   {
  1069.     tSymbolFlags Flags;
  1070.  
  1071.     ArgStr[1].str.p_str[l - 1] = '\0';
  1072.     AdrWord = EvalStrIntExpressionOffsWithFlags(&ArgStr[1], 1, UInt6, &OK, &Flags);
  1073.     if (mFirstPassUnknown(Flags)) AdrWord &= 0xfffe;
  1074.     if (OK)
  1075.     {
  1076.       if (Odd(AdrWord)) WrError(ErrNum_NotAligned);
  1077.       else
  1078.       {
  1079.         BAsmCode[0] = 0xc1 + (AdrWord & 0x3e);
  1080.         CodeLen = 1;
  1081.       }
  1082.     }
  1083.   }
  1084. }
  1085.  
  1086. static void DecodeBR(Word Index)
  1087. {
  1088.   Word AdrWord;
  1089.   Integer AdrInt;
  1090.   Boolean OK;
  1091.   Byte HReg;
  1092.  
  1093.   UNUSED(Index);
  1094.  
  1095.   if (!ChkArgCnt(1, 1));
  1096.   else if ((!as_strcasecmp(ArgStr[1].str.p_str, "AX")) || (!as_strcasecmp(ArgStr[1].str.p_str, "RP0")))
  1097.   {
  1098.     BAsmCode[0] = 0x31;
  1099.     BAsmCode[1] = 0x98;
  1100.     CodeLen = 2;
  1101.   }
  1102.   else
  1103.   {
  1104.     unsigned Offset = 0;
  1105.     tSymbolFlags Flags;
  1106.  
  1107.     if (*ArgStr[1].str.p_str == '!')
  1108.     {
  1109.       Offset++;
  1110.       HReg = 1;
  1111.     }
  1112.     else if (*ArgStr[1].str.p_str == '$')
  1113.     {
  1114.       Offset++;
  1115.       HReg = 2;
  1116.     }
  1117.     else HReg = 0;
  1118.     AdrWord = EvalStrIntExpressionOffsWithFlags(&ArgStr[1], Offset, UInt16, &OK, &Flags);
  1119.     if (OK)
  1120.     {
  1121.       if (HReg == 0)
  1122.       {
  1123.         AdrInt = AdrWord - (EProgCounter() - 2);
  1124.         HReg = ((AdrInt >= -128) && (AdrInt < 127)) ? 2 : 1;
  1125.       }
  1126.       switch (HReg)
  1127.       {
  1128.         case 1:
  1129.           BAsmCode[0] = 0x9b;
  1130.           BAsmCode[1] = Lo(AdrWord);
  1131.           BAsmCode[2] = Hi(AdrWord);
  1132.           CodeLen = 3;
  1133.           break;
  1134.         case 2:
  1135.           AdrInt = AdrWord - (EProgCounter() + 2);
  1136.           if (((AdrInt < -128) || (AdrInt > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1137.           else
  1138.           {
  1139.             BAsmCode[0] = 0xfa;
  1140.             BAsmCode[1] = AdrInt & 0xff;
  1141.             CodeLen = 2;
  1142.           }
  1143.           break;
  1144.       }
  1145.     }
  1146.   }
  1147. }
  1148.  
  1149. static void DecodeRel(Word Index)
  1150. {
  1151.   Integer AdrInt;
  1152.   Boolean OK;
  1153.   tSymbolFlags Flags;
  1154.  
  1155.   if (ChkArgCnt(1, 1))
  1156.   {
  1157.     AdrInt = EvalStrIntExpressionOffsWithFlags(&ArgStr[1], ('$' == *ArgStr[1].str.p_str), UInt16, &OK, &Flags) - (EProgCounter() + 2);
  1158.     if (OK)
  1159.     {
  1160.       if (((AdrInt < -128) || (AdrInt > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1161.       else
  1162.       {
  1163.         BAsmCode[0] = 0x8d + (Index << 4);
  1164.         BAsmCode[1] = AdrInt & 0xff;
  1165.         CodeLen = 2;
  1166.       }
  1167.     }
  1168.   }
  1169. }
  1170.  
  1171. static void DecodeBRel(Word Index)
  1172. {
  1173.   Integer AdrInt;
  1174.   tSymbolFlags Flags;
  1175.   Byte HReg;
  1176.   Boolean OK;
  1177.  
  1178.   if (!ChkArgCnt(2, 2));
  1179.   else if (DecodeBitAdr(&ArgStr[1], &HReg))
  1180.   {
  1181.     if ((Index == 1) && ((HReg & 0x88) == 0))
  1182.     {
  1183.       BAsmCode[0] = 0x8c + HReg;
  1184.       BAsmCode[1] = AdrVals[0];
  1185.       HReg = 2;
  1186.     }
  1187.     else
  1188.     {
  1189.       BAsmCode[0] = 0x31;
  1190.       switch (HReg & 0x88)
  1191.       {
  1192.         case 0x00:
  1193.           BAsmCode[1] = 0x00;
  1194.           break;
  1195.         case 0x08:
  1196.           BAsmCode[1] = 0x04;
  1197.           break;
  1198.         case 0x80:
  1199.           BAsmCode[1] = 0x84;
  1200.           break;
  1201.         case 0x88:
  1202.           BAsmCode[1] = 0x0c;
  1203.           break;
  1204.       }
  1205.       BAsmCode[1] += (HReg & 0x70) + Index + 1;
  1206.       BAsmCode[2] = AdrVals[0];
  1207.       HReg = 2 + AdrCnt;
  1208.     }
  1209.     AdrInt = EvalStrIntExpressionOffsWithFlags(&ArgStr[2], !!(*ArgStr[2].str.p_str == '$'), UInt16, &OK, &Flags) - (EProgCounter() + HReg + 1);
  1210.     if (OK)
  1211.     {
  1212.       if (((AdrInt < -128) || (AdrInt > 127)) & !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1213.       else
  1214.       {
  1215.         BAsmCode[HReg] = AdrInt & 0xff;
  1216.         CodeLen = HReg + 1;
  1217.       }
  1218.     }
  1219.   }
  1220. }
  1221.  
  1222. static void DecodeDBNZ(Word Index)
  1223. {
  1224.   Integer AdrInt;
  1225.   tSymbolFlags Flags;
  1226.   Boolean OK;
  1227.  
  1228.   UNUSED(Index);
  1229.  
  1230.   if (ChkArgCnt(2, 2))
  1231.   {
  1232.     DecodeAdr(&ArgStr[1], MModReg8 + MModShort);
  1233.     if ((AdrMode == ModReg8) && ((AdrPart & 6) != 2)) WrError(ErrNum_InvAddrMode);
  1234.     else if (AdrMode != ModNone)
  1235.     {
  1236.       BAsmCode[0] = (AdrMode == ModReg8) ? 0x88 + AdrPart : 0x04;
  1237.       BAsmCode[1] = AdrVals[0];
  1238.       AdrInt = EvalStrIntExpressionOffsWithFlags(&ArgStr[2], !!(*ArgStr[2].str.p_str == '$'), UInt16, &OK, &Flags) - (EProgCounter() + AdrCnt + 2);
  1239.       if (OK)
  1240.       {
  1241.         if (((AdrInt < -128) || (AdrInt > 127)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  1242.         else
  1243.         {
  1244.           BAsmCode[AdrCnt + 1] = AdrInt & 0xff;
  1245.           CodeLen = AdrCnt + 2;
  1246.         }
  1247.       }
  1248.     }
  1249.   }
  1250. }
  1251.  
  1252. /* Steueranweisungen */
  1253.  
  1254. static void DecodeSEL(Word Index)
  1255. {
  1256.   Byte HReg;
  1257.  
  1258.   UNUSED(Index);
  1259.  
  1260.   if (ArgCnt != 1) WrError(ErrNum_InvAddrMode);
  1261.   else if ((strlen(ArgStr[1].str.p_str) != 3) || (as_strncasecmp(ArgStr[1].str.p_str, "RB", 2) != 0)) WrError(ErrNum_InvAddrMode);
  1262.   else
  1263.   {
  1264.     HReg = ArgStr[1].str.p_str[2] - '0';
  1265.     if (ChkRange(HReg, 0, 3))
  1266.     {
  1267.       BAsmCode[0] = 0x61;
  1268.       BAsmCode[1] = 0xd0 + ((HReg & 1) << 3) + ((HReg & 2) << 4);
  1269.       CodeLen = 2;
  1270.     }
  1271.   }
  1272. }
  1273.  
  1274. /*-------------------------------------------------------------------------*/
  1275. /* dynamische Codetabellenverwaltung */
  1276.  
  1277. static void AddFixed(const char *NewName, Word NewCode)
  1278. {
  1279.   AddInstTable(InstTable, NewName, NewCode, DecodeFixed);
  1280. }
  1281.  
  1282. static void AddAri(const char *NewName)
  1283. {
  1284.   AddInstTable(InstTable, NewName, InstrZ++, DecodeAri);
  1285. }
  1286.  
  1287. static void AddAri16(const char *NewName)
  1288. {
  1289.   AddInstTable(InstTable, NewName, InstrZ++, DecodeAri16);
  1290. }
  1291.  
  1292. static void AddShift(const char *NewName)
  1293. {
  1294.   AddInstTable(InstTable, NewName, InstrZ++, DecodeShift);
  1295. }
  1296.  
  1297. static void AddBit2(const char *NewName)
  1298. {
  1299.   AddInstTable(InstTable, NewName, InstrZ++, DecodeBit2);
  1300. }
  1301.  
  1302. static void AddRel(const char *NewName)
  1303. {
  1304.   AddInstTable(InstTable, NewName, InstrZ++, DecodeRel);
  1305. }
  1306.  
  1307. static void AddBRel(const char *NewName)
  1308. {
  1309.   AddInstTable(InstTable, NewName, InstrZ++, DecodeBRel);
  1310. }
  1311.  
  1312. static void InitFields(void)
  1313. {
  1314.   InstTable = CreateInstTable(201);
  1315.  
  1316.   add_null_pseudo(InstTable);
  1317.  
  1318.   AddInstTable(InstTable, "MOV"  , 0, DecodeMOV);
  1319.   AddInstTable(InstTable, "XCH"  , 0, DecodeXCH);
  1320.   AddInstTable(InstTable, "MOVW" , 0, DecodeMOVW);
  1321.   AddInstTable(InstTable, "XCHW" , 0, DecodeXCHW);
  1322.   AddInstTable(InstTable, "PUSH" , 0, DecodeStack);
  1323.   AddInstTable(InstTable, "POP"  , 1, DecodeStack);
  1324.   AddInstTable(InstTable, "MULU" , 0, DecodeMULU);
  1325.   AddInstTable(InstTable, "DIVUW", 0, DecodeDIVUW);
  1326.   AddInstTable(InstTable, "INC"  , 0, DecodeINCDEC);
  1327.   AddInstTable(InstTable, "DEC"  ,16, DecodeINCDEC);
  1328.   AddInstTable(InstTable, "INCW" , 0, DecodeINCDECW);
  1329.   AddInstTable(InstTable, "DECW" ,16, DecodeINCDECW);
  1330.   AddInstTable(InstTable, "ROL4" , 0, DecodeRot4);
  1331.   AddInstTable(InstTable, "ROR4" ,16, DecodeRot4);
  1332.   AddInstTable(InstTable, "MOV1" , 0, DecodeMOV1);
  1333.   AddInstTable(InstTable, "SET1" , 0, DecodeSETCLR1);
  1334.   AddInstTable(InstTable, "CLR1" , 1, DecodeSETCLR1);
  1335.   AddInstTable(InstTable, "NOT1" , 1, DecodeNOT1);
  1336.   AddInstTable(InstTable, "CALL" , 0, DecodeCALL);
  1337.   AddInstTable(InstTable, "CALLF", 0, DecodeCALLF);
  1338.   AddInstTable(InstTable, "CALLT", 0, DecodeCALLT);
  1339.   AddInstTable(InstTable, "BR"   , 0, DecodeBR);
  1340.   AddInstTable(InstTable, "DBNZ" , 0, DecodeDBNZ);
  1341.   AddInstTable(InstTable, "SEL"  , 0, DecodeSEL);
  1342.  
  1343.   AddFixed("BRK"  , 0x00bf); AddFixed("RET"  , 0x00af);
  1344.   AddFixed("RETB" , 0x009f); AddFixed("RETI" , 0x008f);
  1345.   AddFixed("HALT" , 0x7110); AddFixed("STOP" , 0x7100);
  1346.   AddFixed("NOP"  , 0x0000); AddFixed("EI"   , 0x7a1e);
  1347.   AddFixed("DI"   , 0x7b1e); AddFixed("ADJBA", 0x6180);
  1348.   AddFixed("ADJBS", 0x6190);
  1349.  
  1350.   InstrZ = 0;
  1351.   AddAri("ADD" ); AddAri("SUB" ); AddAri("ADDC"); AddAri("SUBC");
  1352.   AddAri("CMP" ); AddAri("AND" ); AddAri("OR"  ); AddAri("XOR" );
  1353.  
  1354.   InstrZ = 0;
  1355.   AddAri16("ADDW"); AddAri16("SUBW"); AddAri16("CMPW");
  1356.  
  1357.   InstrZ = 0;
  1358.   AddShift("ROR"); AddShift("RORC"); AddShift("ROL"); AddShift("ROLC");
  1359.  
  1360.   InstrZ = 0;
  1361.   AddBit2("AND1"); AddBit2("OR1"); AddBit2("XOR1");
  1362.  
  1363.   InstrZ = 0;
  1364.   AddRel("BC"); AddRel("BNC"); AddRel("BZ"); AddRel("BNZ");
  1365.  
  1366.   InstrZ = 0;
  1367.   AddBRel("BTCLR"); AddBRel("BT"); AddBRel("BF");
  1368.  
  1369.   AddIntelPseudo(InstTable, eIntPseudoFlag_LittleEndian);
  1370. }
  1371.  
  1372. static void DeinitFields(void)
  1373. {
  1374.   DestroyInstTable(InstTable);
  1375. }
  1376.  
  1377. /*-------------------------------------------------------------------------*/
  1378.  
  1379. static void MakeCode_78K0(void)
  1380. {
  1381.   OpSize = eSymbolSize8Bit;
  1382.  
  1383.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  1384.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  1385. }
  1386.  
  1387. static Boolean IsDef_78K0(void)
  1388. {
  1389.   return False;
  1390. }
  1391.  
  1392. static void SwitchFrom_78K0(void)
  1393. {
  1394.   DeinitFields();
  1395. }
  1396.  
  1397. static void SwitchTo_78K0(void)
  1398. {
  1399.   TurnWords = False;
  1400.   SetIntConstMode(eIntConstModeIntel);
  1401.  
  1402.   PCSymbol = "PC";
  1403.   HeaderID = 0x7c;
  1404.   NOPCode = 0x00;
  1405.   DivideChars = ",";
  1406.   HasAttrs = False;
  1407.  
  1408.   ValidSegs = 1 << SegCode;
  1409.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  1410.   SegLimits[SegCode] = 0xffff;
  1411.  
  1412.   MakeCode = MakeCode_78K0;
  1413.   IsDef = IsDef_78K0;
  1414.   SwitchFrom = SwitchFrom_78K0;
  1415.   InitFields();
  1416. }
  1417.  
  1418. void code78k0_init(void)
  1419. {
  1420.   CPU78070 = AddCPU("78070", SwitchTo_78K0);
  1421. }
  1422.