Subversion Repositories pentevo

Rev

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

  1. /* code807c.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator National INS807X.c                                          */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <ctype.h>
  13. #include <string.h>
  14. #include "bpemu.h"
  15.  
  16. #include "strutil.h"
  17. #include "asmdef.h"
  18. #include "asmsub.h"
  19. #include "errmsg.h"
  20. #include "asmpars.h"
  21. #include "asmitree.h"
  22. #include "headids.h"
  23. #include "intpseudo.h"
  24. #include "codevars.h"
  25. #include "errmsg.h"
  26.  
  27. #include "code807x.h"
  28.  
  29. /*---------------------------------------------------------------------------*/
  30.  
  31. #define ShiftOrderCnt 5
  32. #define BranchOrderCnt 5
  33.  
  34. #define ModNone (-1)
  35. #define ModReg 0
  36. #define MModReg (1 << ModReg)
  37. #define ModImm 1
  38. #define MModImm (1 << ModImm)
  39. #define ModMem 2
  40. #define MModMem (1 << ModMem)
  41. #define ModAcc 3
  42. #define MModAcc (1 << ModAcc)
  43. #define ModE 4
  44. #define MModE (1 << ModE)
  45. #define ModS 5
  46. #define MModS (1 << ModS)
  47. #define ModT 6
  48. #define MModT (1 << ModT)
  49.  
  50. typedef struct
  51. {
  52.   Byte Code, Code16;
  53. } ShiftOrder;
  54.  
  55. static ShiftOrder *ShiftOrders;
  56.  
  57. static int OpSize, AdrMode;
  58. static Byte AdrVals[2], AdrPart;
  59.  
  60. static CPUVar CPU8070;
  61.  
  62. /*---------------------------------------------------------------------------*/
  63.  
  64. static Boolean SetOpSize(int NewSize)
  65. {
  66.   Boolean Result = True;
  67.  
  68.   if (OpSize == -1)
  69.     OpSize = NewSize;
  70.   else if (OpSize != NewSize)
  71.   {
  72.     WrError(ErrNum_ConfOpSizes);
  73.     Result = False;
  74.   }
  75.  
  76.   return Result;
  77. }
  78.  
  79. static Boolean GetReg16(char *Asc, Byte *AdrPart)
  80. {
  81.   int z;
  82.   static const char Reg16Names[4][3] = { "PC", "SP", "P2", "P3" };
  83.  
  84.   for (z = 0; z < 4; z++)
  85.     if (!as_strcasecmp(Asc, Reg16Names[z]))
  86.     {
  87.       *AdrPart = z;
  88.       return True;
  89.     }
  90.   return False;
  91. }
  92.  
  93. static void DecodeAdr(int Index, Byte Mask, LongInt PCDelta)
  94. {
  95.   int Cnt;
  96.   Word TmpVal;
  97.   LongInt Addr;
  98.   Boolean OK;
  99.  
  100.   AdrMode = ModNone;
  101.  
  102.   if (!ChkArgCnt(Index, ArgCntMax))
  103.     return;
  104.  
  105.   Cnt = ArgCnt - Index + 1;
  106.  
  107.   /* accumulator ? */
  108.  
  109.   if (!as_strcasecmp(ArgStr[Index].str.p_str, "A"))
  110.   {
  111.     if (SetOpSize(0))
  112.       AdrMode = ModAcc;
  113.     goto AdrFound;
  114.   }
  115.  
  116.   if (!as_strcasecmp(ArgStr[Index].str.p_str, "EA"))
  117.   {
  118.     if (SetOpSize(1))
  119.       AdrMode = ModAcc;
  120.     goto AdrFound;
  121.   }
  122.  
  123.   if (!as_strcasecmp(ArgStr[Index].str.p_str, "E"))
  124.   {
  125.     if (SetOpSize(0))
  126.       AdrMode = ModE;
  127.     goto AdrFound;
  128.   }
  129.  
  130.   if (!as_strcasecmp(ArgStr[Index].str.p_str, "S"))
  131.   {
  132.     if (SetOpSize(0))
  133.       AdrMode = ModS;
  134.     goto AdrFound;
  135.   }
  136.  
  137.   if (!as_strcasecmp(ArgStr[Index].str.p_str, "T"))
  138.   {
  139.     if (SetOpSize(1))
  140.       AdrMode = ModT;
  141.     goto AdrFound;
  142.   }
  143.  
  144.   /* register ? */
  145.  
  146.   if (GetReg16(ArgStr[Index].str.p_str, &AdrPart))
  147.   {
  148.     if (SetOpSize(1))
  149.       AdrMode = ModReg;
  150.     goto AdrFound;
  151.   }
  152.  
  153.   /* immediate? */
  154.  
  155.   if ((*ArgStr[Index].str.p_str == '#') || (*ArgStr[Index].str.p_str == '='))
  156.   {
  157.     switch (OpSize)
  158.     {
  159.       case 0:
  160.         AdrVals[0] = EvalStrIntExpressionOffs(&ArgStr[Index], 1, Int8, &OK);
  161.         break;
  162.       case 1:
  163.         TmpVal = EvalStrIntExpressionOffs(&ArgStr[Index], 1, Int16, &OK);
  164.         if (OK)
  165.         {
  166.           AdrVals[0] = Lo(TmpVal); AdrVals[1] = Hi(TmpVal);
  167.         }
  168.         break;
  169.       default:
  170.         WrError(ErrNum_UndefOpSizes);
  171.         OK = False;
  172.     }
  173.     if (OK)
  174.     {
  175.       AdrCnt = OpSize + 1; AdrMode = ModImm; AdrPart = 4;
  176.     }
  177.     goto AdrFound;
  178.   }
  179.  
  180.   if (Cnt == 1)
  181.   {
  182.     tSymbolFlags Flags;
  183.  
  184.     Addr = EvalStrIntExpressionWithFlags(&ArgStr[Index], UInt16, &OK, &Flags);
  185.     if (mFirstPassUnknown(Flags))
  186.       Addr &= 0xff;
  187.     if (OK)
  188.     {
  189.       if ((Hi(Addr) != 0x00) && (Hi(Addr) != 0xff)) WrError(ErrNum_OverRange);
  190.       else
  191.       {
  192.         AdrVals[0] = Lo(Addr);
  193.         AdrMode = ModMem; AdrPart = 5; AdrCnt = 1;
  194.       }
  195.     }
  196.     goto AdrFound;
  197.   }
  198.  
  199.   else
  200.   {
  201.     Boolean Incr = 0;
  202.  
  203.     if (*ArgStr[Index].str.p_str == '@')
  204.       Incr++;
  205.  
  206.     OK = GetReg16(ArgStr[Index + 1].str.p_str, &AdrPart);
  207.     if (!OK) WrStrErrorPos(ErrNum_InvReg, &ArgStr[Index + 1]);
  208.     else if ((Incr) && (AdrPart < 2)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[Index + 1]);
  209.     else
  210.     {
  211.       tSymbolFlags Flags;
  212.  
  213.       if (Incr)
  214.         AdrPart |= 4;
  215.       Addr = EvalStrIntExpressionOffsWithFlags(&ArgStr[Index], Incr, Int16, &OK, &Flags);
  216.       if (OK)
  217.       {
  218.         if (!AdrPart)
  219.           Addr -= (EProgCounter() + PCDelta);
  220.         if (!mFirstPassUnknownOrQuestionable(Flags) && ((Addr < - 128) || (Addr > 127))) WrError(ErrNum_OverRange);
  221.         else
  222.         {
  223.           AdrMode = ModMem;
  224.           AdrVals[0] = Addr & 0xff;
  225.           AdrCnt = 1;
  226.         }
  227.       }
  228.     }
  229.   }
  230.  
  231. AdrFound:
  232.   if ((AdrMode != ModNone) && ((Mask & (1 << AdrMode)) == 0))
  233.   {
  234.     WrError(ErrNum_InvAddrMode);
  235.     AdrMode = ModNone;
  236.   }
  237. }
  238.  
  239. /*---------------------------------------------------------------------------*/
  240.  
  241. static void DecodeFixed(Word Code)
  242. {
  243.   if (ChkArgCnt(0, 0))
  244.   {
  245.     BAsmCode[0] = Code;
  246.     CodeLen = 1;
  247.   }
  248. }
  249.  
  250. static void DecodeLD(Word Index)
  251. {
  252.   UNUSED(Index);
  253.  
  254.   if (ChkArgCnt(1, 3))
  255.   {
  256.     DecodeAdr(1, MModAcc | MModReg | MModT | MModE | MModS, 0);
  257.     switch (AdrMode)
  258.     {
  259.       case ModAcc:
  260.         if (OpSize == 0)
  261.         {
  262.           DecodeAdr(2, MModMem | MModImm | MModS | MModE, 1);
  263.           switch (AdrMode)
  264.           {
  265.             case ModMem:
  266.             case ModImm:
  267.               BAsmCode[0] = 0xc0 | AdrPart;
  268.               memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  269.               CodeLen = 1 + AdrCnt;
  270.               break;
  271.             case ModS:
  272.               BAsmCode[0] = 0x06;
  273.               CodeLen = 1;
  274.               break;
  275.             case ModE:
  276.               BAsmCode[0] = 0x40;
  277.               CodeLen = 1;
  278.               break;
  279.           }
  280.         }
  281.         else
  282.         {
  283.           DecodeAdr(2, MModMem | MModImm | MModReg | MModT, 1);
  284.           switch (AdrMode)
  285.           {
  286.             case ModMem:
  287.             case ModImm:
  288.               BAsmCode[0] = 0x80 | AdrPart;
  289.               memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  290.               CodeLen = 1 + AdrCnt;
  291.               break;
  292.             case ModReg:
  293.               BAsmCode[0] = 0x30 | AdrPart;
  294.               CodeLen = 1;
  295.               break;
  296.             case ModT:
  297.               BAsmCode[0] = 0x0b;
  298.               CodeLen = 1;
  299.               break;
  300.           }
  301.         }
  302.         break;
  303.       case ModReg:
  304.         BAsmCode[0] = AdrPart;
  305.         DecodeAdr(2, MModAcc | MModImm, 0);
  306.         switch (AdrMode)
  307.         {
  308.           case ModAcc:
  309.             BAsmCode[0] |= 0x44;
  310.             CodeLen = 1;
  311.             break;
  312.           case ModImm:
  313.             BAsmCode[0] |= 0x24;
  314.             memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  315.             CodeLen = 1 + AdrCnt;
  316.             break;
  317.         }
  318.         break;
  319.       case ModT:
  320.         DecodeAdr(2, MModAcc | MModMem | MModImm, 1);
  321.         switch (AdrMode)
  322.         {
  323.           case ModAcc:
  324.             BAsmCode[0] = 0x09;
  325.             CodeLen = 1;
  326.             break;
  327.           case ModMem:
  328.           case ModImm:
  329.             BAsmCode[0] = 0xa0 | AdrPart;
  330.             memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  331.             CodeLen = 1 + AdrCnt;
  332.             break;
  333.         }
  334.         break;
  335.       case ModE:
  336.         DecodeAdr(2, MModAcc, 0);
  337.         switch (AdrMode)
  338.         {
  339.           case ModAcc:
  340.             BAsmCode[0] = 0x48;
  341.             CodeLen = 1;
  342.             break;
  343.         }
  344.         break;
  345.       case ModS:
  346.         DecodeAdr(2, MModAcc, 0);
  347.         switch (AdrMode)
  348.         {
  349.           case ModAcc:
  350.             BAsmCode[0] = 0x07;
  351.             CodeLen = 1;
  352.             break;
  353.         }
  354.         break;
  355.     }
  356.   }
  357. }
  358.  
  359. static void DecodeST(Word Index)
  360. {
  361.   UNUSED(Index);
  362.  
  363.   if (ChkArgCnt(1, 3))
  364.   {
  365.     DecodeAdr(1, MModAcc, 0);
  366.     switch (AdrMode)
  367.     {
  368.       case ModAcc:
  369.         DecodeAdr(2, MModMem, 1);
  370.         switch (AdrMode)
  371.         {
  372.           case ModMem:
  373.             BAsmCode[0] = 0x88 | ((1 - OpSize) << 6) | AdrPart;
  374.             memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  375.             CodeLen = 1 + AdrCnt;
  376.             break;
  377.         }
  378.         break;
  379.     }
  380.   }
  381. }
  382.  
  383. static void DecodeXCH(Word Index)
  384. {
  385.   UNUSED(Index);
  386.  
  387.   if (ChkArgCnt(2, 2))
  388.   {
  389.     DecodeAdr(1, MModE | MModAcc | MModReg, 0);
  390.     switch (AdrMode)
  391.     {
  392.       case ModE:
  393.         DecodeAdr(2, MModAcc, 0);
  394.         if (AdrMode == ModAcc)
  395.           BAsmCode[CodeLen++] = 0x01;
  396.         break;
  397.       case ModAcc:
  398.         DecodeAdr(2, MModE | MModReg, 0);
  399.         switch (AdrMode)
  400.         {
  401.           case ModE:
  402.             BAsmCode[CodeLen++] = 0x01;
  403.             break;
  404.           case ModReg:
  405.             BAsmCode[CodeLen++] = 0x4c | AdrPart;
  406.             break;
  407.         }
  408.         break;
  409.       case ModReg:
  410.         BAsmCode[0] = 0x4c | AdrPart;
  411.         DecodeAdr(2, MModAcc, 0);
  412.         if (AdrMode == ModAcc)
  413.           CodeLen = 1;
  414.         break;
  415.     }
  416.   }
  417. }
  418.  
  419. static void DecodePLI(Word Index)
  420. {
  421.   UNUSED(Index);
  422.  
  423.   if (ChkArgCnt(2, 2))
  424.   {
  425.     DecodeAdr(1, MModReg, 0);
  426.     if (AdrMode == ModReg)
  427.     {
  428.       if (AdrPart == 1) WrError(ErrNum_InvAddrMode);
  429.       else
  430.       {
  431.         BAsmCode[0] = 0x20 | AdrPart;
  432.         DecodeAdr(2, MModImm, 0);
  433.         if (AdrMode == ModImm)
  434.         {
  435.           memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  436.           CodeLen = 1 + AdrCnt;
  437.         }
  438.       }
  439.     }
  440.   }
  441. }
  442.  
  443. static void DecodeSSM(Word Code)
  444. {
  445.   UNUSED(Code);
  446.  
  447.   switch (ArgCnt)
  448.   {
  449.     case 0:
  450.       BAsmCode[0] = 0x2e;
  451.       CodeLen = 1;
  452.       break;
  453.     case 1:
  454.       if ((!GetReg16(ArgStr[1].str.p_str, BAsmCode + 0)) || (BAsmCode[0] < 2)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  455.       else
  456.       {
  457.         BAsmCode[0] |= 0x2c;
  458.         CodeLen = 1;
  459.       }
  460.       break;
  461.     default:
  462.       (void)ChkArgCnt(0, 1);
  463.   }
  464. }
  465.  
  466. static void DecodeADDSUB(Word Index)
  467. {
  468.   if (ChkArgCnt(1, 3))
  469.   {
  470.     DecodeAdr(1, MModAcc, 0);
  471.     switch (AdrMode)
  472.     {
  473.       case ModAcc:
  474.         /* EA <-> E implicitly give operand size conflict, we don't have to check it here */
  475.  
  476.         DecodeAdr(2, MModMem | MModImm | MModE, 1);
  477.         switch (AdrMode)
  478.         {
  479.           case ModMem:
  480.           case ModImm:
  481.             BAsmCode[0] = Index | ((1 - OpSize) << 6) | AdrPart;
  482.             memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  483.             CodeLen = 1 + AdrCnt;
  484.             break;
  485.           case ModE:
  486.             BAsmCode[0] = Index - 0x40;
  487.             CodeLen = 1;
  488.             break;
  489.         }
  490.     }
  491.   }
  492. }
  493.  
  494. static void DecodeMulDiv(Word Index)
  495. {
  496.   if (ChkArgCnt(2, 2))
  497.   {
  498.     OpSize = 1;
  499.     DecodeAdr(1, MModAcc, 0);
  500.     if (AdrMode == ModAcc)
  501.     {
  502.       DecodeAdr(2, MModT, 0);
  503.       if (AdrMode == ModT)
  504.       {
  505.         BAsmCode[0] = Index;
  506.         CodeLen = 1;
  507.       }
  508.     }
  509.   }
  510. }
  511.  
  512. static void DecodeLogic(Word Index)
  513. {
  514.   if (ChkArgCnt(1, 3))
  515.   {
  516.     OpSize = 0;
  517.     DecodeAdr(1, MModAcc | MModS, 0);
  518.     switch (AdrMode)
  519.     {
  520.       case ModAcc:
  521.         DecodeAdr(2, MModMem | MModImm | MModE, 1);
  522.         switch (AdrMode)
  523.         {
  524.           case ModMem:
  525.           case ModImm:
  526.             BAsmCode[0] = Index | AdrPart;
  527.             memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  528.             CodeLen = 1 + AdrCnt;
  529.             break;
  530.           case ModE:
  531.             BAsmCode[0] = Index - 0x80;
  532.             CodeLen = 1;
  533.             break;
  534.         }
  535.         break;
  536.       case ModS:
  537.         if (Index == 0xe0) WrError(ErrNum_InvAddrMode);
  538.         else
  539.         {
  540.           DecodeAdr(2, MModImm, 0);
  541.           if (AdrMode == ModImm)
  542.           {
  543.             BAsmCode[0] = (Index == 0xd0) ? 0x39 : 0x3b;
  544.             BAsmCode[1] = *AdrVals;
  545.             CodeLen = 2;
  546.           }
  547.         }
  548.         break;
  549.     }
  550.   }
  551. }
  552.  
  553. static void DecodeShift(Word Index)
  554. {
  555.   ShiftOrder *POrder = ShiftOrders + Index;
  556.  
  557.   if (ChkArgCnt(1, 1))
  558.   {
  559.     DecodeAdr(1, MModAcc, 0);
  560.     if (AdrMode == ModAcc)
  561.     {
  562.       if ((OpSize == 1) && (!POrder->Code16)) WrError(ErrNum_InvAddrMode);
  563.       else
  564.         BAsmCode[CodeLen++] = OpSize ? POrder->Code16 : POrder->Code;
  565.     }
  566.   }
  567. }
  568.  
  569. static void DecodeStack(Word Index)
  570. {
  571.   if (ChkArgCnt(1, 1))
  572.   {
  573.     DecodeAdr(1, MModAcc | MModReg, 0);
  574.     switch (AdrMode)
  575.     {
  576.       case ModAcc:
  577.         BAsmCode[0] = 0x0a - (OpSize << 1);
  578.         if (Index)
  579.           BAsmCode[0] = (BAsmCode[0] | 0x30) ^ 2;
  580.         CodeLen++;
  581.         break;
  582.       case ModReg:
  583.         if (AdrPart == 1) WrError(ErrNum_InvAddrMode);
  584.         else
  585.           BAsmCode[CodeLen++] = 0x54 | Index | AdrPart;
  586.         break;
  587.     }
  588.   }
  589. }
  590.  
  591. static void DecodeIDLD(Word Index)
  592. {
  593.   if (ChkArgCnt(2, 3))
  594.   {
  595.     DecodeAdr(1, MModAcc, 0);
  596.     if (AdrMode == ModAcc)
  597.     {
  598.       if (OpSize == 1) WrError(ErrNum_InvAddrMode);
  599.       else
  600.       {
  601.         DecodeAdr(2, MModMem, 1);
  602.         if (AdrMode == ModMem)
  603.         {
  604.           BAsmCode[0] = 0x90 | Index | AdrPart;
  605.           memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  606.           CodeLen = 1 + AdrCnt;
  607.         }
  608.       }
  609.     }
  610.   }
  611. }
  612.  
  613. static void DecodeJMPJSR(Word Index)
  614. {
  615.   Word Address;
  616.   Boolean OK;
  617.  
  618.   if (ChkArgCnt(1, 1))
  619.   {
  620.     Address = (EvalStrIntExpression(&ArgStr[1], UInt16, &OK) - 1) & 0xffff;
  621.     if (OK)
  622.     {
  623.       BAsmCode[CodeLen++] = Index;
  624.       BAsmCode[CodeLen++] = Lo(Address);
  625.       BAsmCode[CodeLen++] = Hi(Address);
  626.     }
  627.   }
  628. }
  629.  
  630. static void DecodeCALL(Word Index)
  631. {
  632.   Boolean OK;
  633.  
  634.   UNUSED(Index);
  635.  
  636.   if (ChkArgCnt(1, 1))
  637.   {
  638.     BAsmCode[0] = 0x10 | EvalStrIntExpression(&ArgStr[1], UInt4, &OK);
  639.     if (OK)
  640.       CodeLen = 1;
  641.   }
  642. }
  643.  
  644. static void DecodeBranch(Word Code)
  645. {
  646.   /* allow both syntaxes for PC-relative addressing */
  647.  
  648.   if (ArgCnt == 1)
  649.   {
  650.     const char PCArg[] = "PC";
  651.  
  652.     AppendArg(strlen(PCArg));
  653.     strcpy(ArgStr[ArgCnt].str.p_str, PCArg);
  654.   }
  655.  
  656.   if (ChkArgCnt(2, 2))
  657.   {
  658.     DecodeAdr(1, MModMem, 2); /* !! regard pre-increment after branch */
  659.     if (AdrMode == ModMem)
  660.     {
  661.       if ((AdrPart == 1) || (AdrPart > 3)) WrError(ErrNum_InvAddrMode);
  662.       else if ((Code < 0x60) && (AdrPart != 0))  WrError(ErrNum_InvAddrMode);
  663.       else
  664.       {
  665.         BAsmCode[0] = Code | AdrPart;
  666.         memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  667.         CodeLen = 1 + AdrCnt;
  668.       }
  669.     }
  670.   }
  671. }
  672.  
  673. /*---------------------------------------------------------------------------*/
  674.  
  675. static void AddFixed(const char *NName, Byte NCode)
  676. {
  677.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  678. }
  679.  
  680. static void AddBranch(const char *NName, Byte NCode)
  681. {
  682.   AddInstTable(InstTable, NName, NCode, DecodeBranch);
  683. }
  684.  
  685. static void AddShift(const char *NName, Byte NCode, Byte NCode16)
  686. {
  687.   if (InstrZ >= ShiftOrderCnt)
  688.     exit(0);
  689.   ShiftOrders[InstrZ].Code = NCode;
  690.   ShiftOrders[InstrZ].Code16 = NCode16;
  691.   AddInstTable(InstTable, NName, InstrZ++, DecodeShift);
  692. }
  693.  
  694. static void InitFields(void)
  695. {
  696.   InstTable = CreateInstTable(53);
  697.  
  698.   AddFixed("RET", 0x5c);
  699.   AddFixed("NOP", 0x00);
  700.  
  701.   ShiftOrders = (ShiftOrder*) malloc(sizeof(ShiftOrder) * ShiftOrderCnt); InstrZ = 0;
  702.   AddShift("SR" , 0x3c, 0x0c);
  703.   AddShift("SRL", 0x3d, 0x00);
  704.   AddShift("RR" , 0x3e, 0x00);
  705.   AddShift("RRL", 0x3f, 0x00);
  706.   AddShift("SL" , 0x0e, 0x0f);
  707.  
  708.   AddInstTable(InstTable, "LD",     0, DecodeLD);
  709.   AddInstTable(InstTable, "ST",     0, DecodeST);
  710.   AddInstTable(InstTable, "XCH",    0, DecodeXCH);
  711.   AddInstTable(InstTable, "PLI",    0, DecodePLI);
  712.   AddInstTable(InstTable, "SSM",    0, DecodeSSM);
  713.  
  714.   AddInstTable(InstTable, "ADD", 0xb0, DecodeADDSUB);
  715.   AddInstTable(InstTable, "SUB", 0xb8, DecodeADDSUB);
  716.  
  717.   AddInstTable(InstTable, "MPY", 0x2c, DecodeMulDiv);
  718.   AddInstTable(InstTable, "DIV", 0x0d, DecodeMulDiv);
  719.  
  720.   AddInstTable(InstTable, "AND", 0xd0, DecodeLogic);
  721.   AddInstTable(InstTable, "OR",  0xd8, DecodeLogic);
  722.   AddInstTable(InstTable, "XOR", 0xe0, DecodeLogic);
  723.  
  724.   AddInstTable(InstTable, "PUSH",0x00, DecodeStack);
  725.   AddInstTable(InstTable, "POP", 0x08, DecodeStack);
  726.  
  727.   AddInstTable(InstTable, "ILD" ,0x00, DecodeIDLD);
  728.   AddInstTable(InstTable, "DLD", 0x08, DecodeIDLD);
  729.  
  730.   AddInstTable(InstTable, "JMP" ,0x24, DecodeJMPJSR);
  731.   AddInstTable(InstTable, "JSR", 0x20, DecodeJMPJSR);
  732.   AddInstTable(InstTable, "CALL",   0, DecodeCALL);
  733.  
  734.   AddBranch("BND", 0x2d);
  735.   AddBranch("BRA", 0x74);
  736.   AddBranch("BP" , 0x64);
  737.   AddBranch("BZ" , 0x6c);
  738.   AddBranch("BNZ", 0x7c);
  739. }
  740.  
  741. static void DeinitFields(void)
  742. {
  743.   DestroyInstTable(InstTable);
  744.   free(ShiftOrders);
  745. }
  746.  
  747. /*---------------------------------------------------------------------------*/
  748.  
  749. static void MakeCode_807x(void)
  750. {
  751.    CodeLen=0; DontPrint=False; OpSize = -1;
  752.  
  753.    /* zu ignorierendes */
  754.  
  755.    if (Memo("")) return;
  756.  
  757.    if (DecodeIntelPseudo(False)) return;
  758.  
  759.    if (!LookupInstTable(InstTable, OpPart.str.p_str))
  760.      WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  761. }
  762.  
  763. static Boolean IsDef_807x(void)
  764. {
  765.    return False;
  766. }
  767.  
  768. static void SwitchFrom_807x(void)
  769. {
  770.    DeinitFields();
  771. }
  772.  
  773. static void SwitchTo_807x(void)
  774. {
  775.    const TFamilyDescr *FoundDescr;
  776.  
  777.    FoundDescr = FindFamilyByName("807x");
  778.  
  779.    TurnWords = False;
  780.    SetIntConstMode(eIntConstModeC);
  781.  
  782.    PCSymbol="$"; HeaderID = FoundDescr->Id; NOPCode = 0x00;
  783.    DivideChars = ","; HasAttrs = False;
  784.  
  785.    ValidSegs = 1 << SegCode;
  786.    Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  787.    SegLimits[SegCode] = 0xffff;
  788.  
  789.    MakeCode = MakeCode_807x; IsDef = IsDef_807x;
  790.    SwitchFrom = SwitchFrom_807x; InitFields();
  791. }
  792.  
  793. /*---------------------------------------------------------------------------*/
  794.  
  795. void code807x_init(void)
  796. {
  797.   CPU8070 = AddCPU("8070", SwitchTo_807x);
  798. }
  799.