Subversion Repositories pentevo

Rev

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

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