Subversion Repositories pentevo

Rev

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

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