Subversion Repositories pentevo

Rev

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

  1. /* codeace.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegeneratormodul ACE-Familie                                            */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12.  
  13. #include <string.h>
  14.  
  15. #include "bpemu.h"
  16. #include "strutil.h"
  17. #include "chunks.h"
  18. #include "headids.h"
  19. #include "asmdef.h"
  20. #include "asmsub.h"
  21. #include "asmpars.h"
  22. #include "asmitree.h"
  23. #include "codepseudo.h"
  24. #include "intpseudo.h"
  25. #include "codevars.h"
  26. #include "errmsg.h"
  27.  
  28. #include "codeace.h"
  29.  
  30. enum
  31. {
  32.   ModNone = -1,
  33.   ModAcc = 0,
  34.   ModX = 1,
  35.   ModXInd = 2,
  36.   ModXDisp = 3,
  37.   ModDir = 4,
  38.   ModImm = 5
  39. };
  40.  
  41. #define MModAcc (1 << ModAcc)
  42. #define MModX (1 << ModX)
  43. #define MModXInd (1 << ModXInd)
  44. #define MModXDisp (1 << ModXDisp)
  45. #define MModDir (1 << ModDir)
  46. #define MModImm (1 << ModImm)
  47.  
  48. typedef struct
  49. {
  50.   Byte ImmCode, DirCode, IndCode, DispCode;
  51. } AriOrder;
  52.  
  53. typedef struct
  54. {
  55.   Byte AccCode, XCode, DirCode;
  56. } SingOrder;
  57.  
  58. typedef struct
  59. {
  60.   Byte AccCode, XIndCode, DirCode;
  61. } BitOrder;
  62.  
  63. enum { D_CPUACE1101, D_CPUACE1202 };
  64.  
  65. static CPUVar CPUACE1101, CPUACE1202;
  66.  
  67. static AriOrder *AriOrders;
  68. static SingOrder *SingOrders;
  69. static BitOrder *BitOrders;
  70.  
  71. static ShortInt AdrMode;
  72. static Byte AdrVal;
  73. static Word WAdrVal;
  74. static Boolean BigFlag, OpSize;
  75.  
  76. /*---------------------------------------------------------------------------*/
  77.  
  78. static void ChkAdr(Word Mask)
  79. {
  80.   if ((AdrMode == ModXDisp) && !ChkMinCPUExt(CPUACE1202, ErrNum_AddrModeNotSupported))
  81.     AdrMode = ModNone;
  82.   else if ((AdrMode != ModNone) && ((Mask & (1 << AdrMode)) == 0))
  83.   {
  84.     AdrMode = ModNone; WrError(ErrNum_InvAddrMode);
  85.   }
  86. }
  87.  
  88. static void DecodeAdr(const tStrComp *pArg, Word Mask)
  89. {
  90.   Boolean OK, DispOcc, XOcc;
  91.   int ArgLen;
  92.   char *p;
  93.  
  94.   AdrMode = ModNone;
  95.  
  96.   /* Register ? */
  97.  
  98.   if (!as_strcasecmp(pArg->str.p_str, "A"))
  99.    AdrMode = ModAcc;
  100.  
  101.   else if (!as_strcasecmp(pArg->str.p_str, "X"))
  102.    AdrMode = ModX;
  103.  
  104.   /* immediate ? */
  105.  
  106.   else if (*pArg->str.p_str== '#')
  107.   {
  108.     if (OpSize)
  109.       WAdrVal = EvalStrIntExpressionOffs(pArg, 1, Int12, &OK);
  110.     else
  111.       AdrVal = EvalStrIntExpressionOffs(pArg, 1, Int8, &OK);
  112.     if (OK) AdrMode = ModImm;
  113.   }
  114.  
  115.   /* indirekt ? */
  116.  
  117.   else if (*pArg->str.p_str == '[')
  118.   {
  119.     ArgLen = strlen(pArg->str.p_str);
  120.     if (pArg->str.p_str[ArgLen - 1] != ']') WrError(ErrNum_InvAddrMode);
  121.     else
  122.     {
  123.       tStrComp Arg, Remainder;
  124.  
  125.       StrCompRefRight(&Arg, pArg, 1);
  126.       StrCompShorten(&Arg, 1);
  127.       DispOcc = XOcc = False;
  128.       do
  129.       {
  130.         p = QuotPos(Arg.str.p_str, ',');
  131.         if (p)
  132.           StrCompSplitRef(&Arg, &Remainder, &Arg, p);
  133.         KillPrefBlanksStrComp(&Arg);
  134.         KillPostBlanksStrComp(&Arg);
  135.         if (!as_strcasecmp(Arg.str.p_str, "X"))
  136.           if (XOcc)
  137.           {
  138.             WrError(ErrNum_InvAddrMode); break;
  139.           }
  140.           else
  141.             XOcc = True;
  142.         else if (DispOcc)
  143.         {
  144.           WrError(ErrNum_InvAddrMode); break;
  145.         }
  146.         else
  147.         {
  148.           AdrVal = EvalStrIntExpressionOffs(&Arg, !!(*Arg.str.p_str == '#'), UInt8, &OK);
  149.           if (!OK) break;
  150.           DispOcc = True;
  151.         }
  152.         if (p)
  153.           Arg = Remainder;
  154.       }
  155.       while (p);
  156.       if (!p)
  157.         AdrMode = (DispOcc && (AdrVal != 0)) ? ModXDisp : ModXInd;
  158.     }
  159.   }
  160.  
  161.   /* direkt */
  162.  
  163.   else
  164.   {
  165.     if (OpSize)
  166.       WAdrVal = EvalStrIntExpression(pArg, UInt12, &OK);
  167.     else
  168.       AdrVal = EvalStrIntExpression(pArg, UInt8, &OK);
  169.     if (OK) AdrMode = ModDir;
  170.   }
  171.  
  172.   ChkAdr(Mask);
  173. }
  174.  
  175. /*---------------------------------------------------------------------------*/
  176.  
  177. static void DecodeFixed(Word Code)
  178. {
  179.   if (ChkArgCnt(0, 0))
  180.   {
  181.     BAsmCode[0] = Code;
  182.     CodeLen = 1;
  183.   }
  184. }
  185.  
  186. static void DecodeAri(Word Index)
  187. {
  188.   AriOrder *porder = AriOrders + Index;
  189.  
  190.   if (ChkArgCnt(2, 2))
  191.   {
  192.     DecodeAdr(&ArgStr[1], MModAcc);
  193.     if (AdrMode != ModNone)
  194.     {
  195.       DecodeAdr(&ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp);
  196.       switch (AdrMode)
  197.       {
  198.         case ModImm:
  199.           BAsmCode[0] = porder->ImmCode;
  200.           BAsmCode[1] = AdrVal;
  201.           CodeLen = 2;
  202.           break;
  203.         case ModDir:
  204.           BAsmCode[0] = porder->DirCode;
  205.           BAsmCode[1] = AdrVal;
  206.           CodeLen = 2;
  207.           break;
  208.         case ModXInd:
  209.           BAsmCode[0] = porder->IndCode;
  210.           CodeLen = 1;
  211.           break;
  212.         case ModXDisp:
  213.           BAsmCode[0] = porder->DispCode;
  214.           BAsmCode[1] = AdrVal;
  215.           CodeLen = 2;
  216.           break;
  217.       }
  218.     }
  219.   }
  220. }
  221.  
  222. static void DecodeSing(Word Index)
  223. {
  224.   SingOrder *porder = SingOrders + Index;
  225.  
  226.   if (ChkArgCnt(1, 1))
  227.   {
  228.     DecodeAdr(&ArgStr[1], MModDir | MModX | MModAcc);
  229.     switch (AdrMode)
  230.     {
  231.       case ModDir:
  232.         BAsmCode[0] = porder->DirCode;
  233.         BAsmCode[1] = AdrVal;
  234.         CodeLen = 2;
  235.         break;
  236.       case ModAcc:
  237.         BAsmCode[0] = porder->AccCode;
  238.         CodeLen = 1;
  239.         break;
  240.       case ModX:
  241.         BAsmCode[0] = porder->XCode;
  242.         CodeLen = 1;
  243.         break;
  244.     }
  245.   }
  246. }
  247.  
  248. static void DecodeBit(Word Index)
  249. {
  250.   Byte Bit, Mask;
  251.   BitOrder *porder = BitOrders + Index;
  252.   Boolean OK;
  253.  
  254.   if (ChkArgCnt(2, 2))
  255.   {
  256.     Bit = EvalStrIntExpression(&ArgStr[1], UInt8, &OK);
  257.     if (OK)
  258.     {
  259.       Mask = 0;
  260.       if (porder->AccCode != 0xff) Mask |= MModAcc;
  261.       if (porder->XIndCode != 0xff) Mask |= MModXInd;
  262.       if (porder->DirCode != 0xff) Mask |= MModDir;
  263.       DecodeAdr(&ArgStr[2], Mask);
  264.       switch (AdrMode)
  265.       {
  266.         case ModAcc:
  267.           BAsmCode[0] = porder->AccCode;
  268.           if (porder->AccCode & 7)
  269.           {
  270.             BAsmCode[1] = 1 << Bit;
  271.             if (porder->AccCode & 1)
  272.               BAsmCode[1] = 255 - BAsmCode[1];
  273.             CodeLen = 2;
  274.           }
  275.           else
  276.           {
  277.             BAsmCode[0] |= Bit;
  278.             CodeLen = 1;
  279.           }
  280.           break;
  281.         case ModXInd:
  282.           BAsmCode[0] = porder->XIndCode + Bit;
  283.           CodeLen = 1;
  284.           break;
  285.         case ModDir:
  286.           BAsmCode[0] = porder->DirCode + Bit;
  287.           BAsmCode[1] = AdrVal;
  288.           CodeLen = 2;
  289.           break;
  290.       }
  291.     }
  292.   }
  293. }
  294.  
  295. static void DecodeIFEQ(Word Index)
  296. {
  297.   UNUSED(Index);
  298.  
  299.   if (ChkArgCnt(2, 2))
  300.   {
  301.     DecodeAdr(&ArgStr[1], MModAcc | MModX | MModDir);
  302.     switch (AdrMode)
  303.     {
  304.       case ModAcc:
  305.         DecodeAdr(&ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp);
  306.         switch (AdrMode)
  307.         {
  308.           case ModImm:
  309.             BAsmCode[0] = 0x65;
  310.             BAsmCode[1] = AdrVal;
  311.             CodeLen = 2;
  312.             break;
  313.           case ModDir:
  314.             BAsmCode[0] = 0x56;
  315.             BAsmCode[1] = AdrVal;
  316.             CodeLen = 2;
  317.             break;
  318.           case ModXInd:
  319.             BAsmCode[0] = 0x09;
  320.             CodeLen = 1;
  321.             break;
  322.           case ModXDisp:
  323.             BAsmCode[0] = 0x76;
  324.             BAsmCode[1] = AdrVal;
  325.             CodeLen = 2;
  326.             break;
  327.         }
  328.         break;
  329.       case ModX:
  330.         OpSize = True;
  331.         DecodeAdr(&ArgStr[2], MModImm);
  332.         switch (AdrMode)
  333.         {
  334.           case ModImm:
  335.             BAsmCode[0] = 0x26;
  336.             BAsmCode[1] = Lo(WAdrVal);
  337.             BAsmCode[2] = Hi(WAdrVal);
  338.             CodeLen = 3;
  339.             break;
  340.         }
  341.         break;
  342.       case ModDir:
  343.         BAsmCode[1] = AdrVal;
  344.         DecodeAdr(&ArgStr[2], MModImm);
  345.         switch (AdrMode)
  346.         {
  347.           case ModImm:
  348.             BAsmCode[0] = 0x20;
  349.             BAsmCode[2] = AdrVal;
  350.             CodeLen = 3;
  351.             break;
  352.         }
  353.         break;
  354.     }
  355.   }
  356. }
  357.  
  358. static void DecodeIFGT(Word Index)
  359. {
  360.   UNUSED(Index);
  361.  
  362.   if (ChkArgCnt(2, 2))
  363.   {
  364.     DecodeAdr(&ArgStr[1], MModAcc | MModX);
  365.     switch (AdrMode)
  366.     {
  367.       case ModAcc:
  368.         DecodeAdr(&ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp);
  369.         switch (AdrMode)
  370.         {
  371.           case ModImm:
  372.             BAsmCode[0] = 0x67;
  373.             BAsmCode[1] = AdrVal;
  374.             CodeLen = 2;
  375.             break;
  376.           case ModDir:
  377.             BAsmCode[0] = 0x55;
  378.             BAsmCode[1] = AdrVal;
  379.             CodeLen = 2;
  380.             break;
  381.           case ModXInd:
  382.             BAsmCode[0] = 0x0a;
  383.             CodeLen = 1;
  384.             break;
  385.           case ModXDisp:
  386.             BAsmCode[0] = 0x77;
  387.             BAsmCode[1] = AdrVal;
  388.             CodeLen = 2;
  389.             break;
  390.         }
  391.         break;
  392.       case ModX:
  393.         OpSize = True;
  394.         DecodeAdr(&ArgStr[2], MModImm);
  395.         switch (AdrMode)
  396.         {
  397.           case ModImm:
  398.             BAsmCode[0] = 0x27;
  399.             BAsmCode[1] = Lo(WAdrVal);
  400.             BAsmCode[2] = Hi(WAdrVal);
  401.             CodeLen = 3;
  402.             break;
  403.         }
  404.         break;
  405.     }
  406.   }
  407. }
  408.  
  409. static void DecodeIFLT(Word Index)
  410. {
  411.   UNUSED(Index);
  412.  
  413.   if (ChkArgCnt(2, 2))
  414.   {
  415.     DecodeAdr(&ArgStr[1], MModX);
  416.     switch (AdrMode)
  417.     {
  418.       case ModX:
  419.         OpSize = True;
  420.         DecodeAdr(&ArgStr[2], MModImm);
  421.         switch (AdrMode)
  422.         {
  423.           case ModImm:
  424.             BAsmCode[0] = 0x28;
  425.             BAsmCode[1] = Lo(WAdrVal);
  426.             BAsmCode[2] = Hi(WAdrVal);
  427.             CodeLen = 3;
  428.             break;
  429.         }
  430.         break;
  431.     }
  432.   }
  433. }
  434.  
  435. static void DecodeJMPJSR(Word Index)
  436. {
  437.   if (ChkArgCnt(1, 1))
  438.   {
  439.     OpSize = True;
  440.     DecodeAdr(&ArgStr[1], MModDir | MModXDisp);
  441.     switch (AdrMode)
  442.     {
  443.       case ModDir:
  444.         BAsmCode[0] = 0x24 - Index;
  445.         BAsmCode[1] = Lo(WAdrVal);
  446.         BAsmCode[2] = Hi(WAdrVal);
  447.         CodeLen = 3;
  448.         break;
  449.       case ModXDisp:
  450.         BAsmCode[0] = 0x7e + Index;
  451.         BAsmCode[1] = AdrVal;
  452.         CodeLen = 2;
  453.         break;
  454.     }
  455.   }
  456. }
  457.  
  458. static void DecodeJP(Word Index)
  459. {
  460.   LongInt Dist;
  461.   Boolean OK;
  462.   tSymbolFlags Flags;
  463.  
  464.   UNUSED(Index);
  465.  
  466.   if (ChkArgCnt(1, 1))
  467.   {
  468.     Dist = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt12, &OK, &Flags) - (EProgCounter() + 1);
  469.     if (OK)
  470.     {
  471.       if (!mSymbolQuestionable(Flags) && ((Dist > 31) || (Dist < -31))) WrError(ErrNum_JmpDistTooBig);
  472.       else
  473.       {
  474.         BAsmCode[0] = (Dist >= 0) ? 0xe0 + Dist : 0xc0 - Dist;
  475.         CodeLen = 1;
  476.       }
  477.     }
  478.   }
  479. }
  480.  
  481. static void DecodeLD(Word Index)
  482. {
  483.   UNUSED(Index);
  484.  
  485.   if (ChkArgCnt(2, 2))
  486.   {
  487.     DecodeAdr(&ArgStr[1], MModAcc | MModX | MModDir);
  488.     switch (AdrMode)
  489.     {
  490.       case ModAcc:
  491.         DecodeAdr(&ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp);
  492.         switch (AdrMode)
  493.         {
  494.           case ModImm:
  495.             BAsmCode[0] = 0x51;
  496.             BAsmCode[1] = AdrVal;
  497.             CodeLen = 2;
  498.             break;
  499.           case ModDir:
  500.             BAsmCode[0] = 0x46;
  501.             BAsmCode[1] = AdrVal;
  502.             CodeLen = 2;
  503.             break;
  504.           case ModXInd:
  505.             BAsmCode[0] = 0x0e;
  506.             CodeLen = 1;
  507.             break;
  508.           case ModXDisp:
  509.             BAsmCode[0] = 0x52;
  510.             BAsmCode[1] = AdrVal;
  511.             CodeLen = 2;
  512.             break;
  513.         }
  514.         break;
  515.       case ModX:
  516.         OpSize = True;
  517.         DecodeAdr(&ArgStr[2], MModImm);
  518.         switch (AdrMode)
  519.         {
  520.           case ModImm:
  521.             BAsmCode[0] = 0x25;
  522.             BAsmCode[1] = Lo(WAdrVal);
  523.             BAsmCode[2] = Hi(WAdrVal);
  524.             CodeLen = 3;
  525.             break;
  526.         }
  527.         break;
  528.       case ModDir:
  529.         BAsmCode[1] = AdrVal;
  530.         DecodeAdr(&ArgStr[2], MModImm | MModDir);
  531.         switch (AdrMode)
  532.         {
  533.           case ModImm:
  534.             BAsmCode[0] = 0x21;
  535.             BAsmCode[2] = AdrVal;
  536.             CodeLen = 3;
  537.             break;
  538.           case ModDir:
  539.             BAsmCode[0] = 0x22;
  540.             BAsmCode[2] = BAsmCode[1];
  541.             BAsmCode[1] = AdrVal;
  542.             CodeLen = 3;
  543.             break;
  544.         }
  545.         break;
  546.     }
  547.   }
  548. }
  549.  
  550. static void DecodeRotate(Word Index)
  551. {
  552.   if (ChkArgCnt(1, 1))
  553.   {
  554.     DecodeAdr(&ArgStr[1], MModAcc | MModDir);
  555.     switch (AdrMode)
  556.     {
  557.       case ModAcc:
  558.         BAsmCode[0] = 0x15 - Index - Index;
  559.         CodeLen = 1;
  560.         break;
  561.       case ModDir:
  562.         BAsmCode[0] = 0x79 + Index;
  563.         BAsmCode[1] = AdrVal;
  564.         CodeLen = 2;
  565.         break;
  566.     }
  567.   }
  568. }
  569.  
  570. static void DecodeST(Word Index)
  571. {
  572.   UNUSED(Index);
  573.  
  574.   if (ChkArgCnt(2, 2))
  575.   {
  576.     DecodeAdr(&ArgStr[1], MModAcc);
  577.     switch (AdrMode)
  578.     {
  579.       case ModAcc:
  580.         DecodeAdr(&ArgStr[2], MModDir | MModXInd | MModXDisp);
  581.         switch (AdrMode)
  582.         {
  583.           case ModDir:
  584.             BAsmCode[0] = 0x47;
  585.             BAsmCode[1] = AdrVal;
  586.             CodeLen = 2;
  587.             break;
  588.           case ModXInd:
  589.             BAsmCode[0] = 0x11;
  590.             CodeLen = 1;
  591.             break;
  592.           case ModXDisp:
  593.             BAsmCode[0] = 0x40;
  594.             BAsmCode[1] = AdrVal;
  595.             CodeLen = 2;
  596.             break;
  597.         }
  598.         break;
  599.     }
  600.   }
  601. }
  602.  
  603. static void DecodeSFR(Word Code)
  604. {
  605.   UNUSED(Code);
  606.  
  607.   CodeEquate(SegCode, 0, 0xff);
  608. }
  609.  
  610. /*---------------------------------------------------------------------------*/
  611.  
  612. static void AddFixed(const char *NName, Byte NCode)
  613. {
  614.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  615. }
  616.  
  617. static void AddAri(const char *NName, Byte NImm, Byte NDir, Byte NInd, Byte NDisp)
  618. {
  619.   order_array_rsv_end(AriOrders, AriOrder);
  620.   AriOrders[InstrZ].ImmCode = NImm;
  621.   AriOrders[InstrZ].DirCode = NDir;
  622.   AriOrders[InstrZ].IndCode = NInd;
  623.   AriOrders[InstrZ].DispCode = NDisp;
  624.   AddInstTable(InstTable, NName, InstrZ++, DecodeAri);
  625. }
  626.  
  627. static void AddSing(const char *NName, Byte NAcc, Byte NX, Byte NDir)
  628. {
  629.   order_array_rsv_end(SingOrders, SingOrder);
  630.   SingOrders[InstrZ].AccCode = NAcc;
  631.   SingOrders[InstrZ].XCode = NX;
  632.   SingOrders[InstrZ].DirCode = NDir;
  633.   AddInstTable(InstTable, NName, InstrZ++, DecodeSing);
  634. }
  635.  
  636. static void AddBit(const char *NName, Byte NAcc, Byte NIndX, Byte NDir)
  637. {
  638.   order_array_rsv_end(BitOrders, BitOrder);
  639.   BitOrders[InstrZ].AccCode = NAcc;
  640.   BitOrders[InstrZ].XIndCode = NIndX;
  641.   BitOrders[InstrZ].DirCode = NDir;
  642.   AddInstTable(InstTable, NName, InstrZ++, DecodeBit);
  643. }
  644.  
  645. static void InitFields(void)
  646. {
  647.   InstTable = CreateInstTable(101);
  648.  
  649.   InstrZ = 0;
  650.   AddFixed("IFC"  ,0x19);  AddFixed("IFNC" ,0x1f);  AddFixed("INTR" ,0x00);
  651.   AddFixed("INVC" ,0x12);  AddFixed("NOP"  ,0x1c);  AddFixed("RC"   ,0x1e);
  652.   AddFixed("RET"  ,0x17);  AddFixed("RETI" ,0x18);  AddFixed("SC"   ,0x1d);
  653.  
  654.   InstrZ = 0;
  655.   AddAri("ADC" , 0x60, 0x42, 0x02, 0x70);
  656.   AddAri("ADD" , 0x66, 0x43, 0x03, 0x71);
  657.   AddAri("AND" , 0x61, 0x50, 0x04, 0x72);
  658.   AddAri("IFNE", 0x57, 0x54, 0x0b, 0x78);
  659.   AddAri("OR"  , 0x62, 0x44, 0x05, 0x73);
  660.   AddAri("SUBC", 0x63, 0x53, 0x06, 0x74);
  661.   AddAri("XOR" , 0x64, 0x45, 0x07, 0x75);
  662.  
  663.   InstrZ = 0;
  664.   AddSing("CLR" , 0x16, 0x0f, 0x7d);
  665.   AddSing("DEC" , 0x1a, 0x0c, 0x7b);
  666.   AddSing("INC" , 0x1b, 0x0d, 0x7c);
  667.  
  668.   InstrZ = 0;
  669.   AddBit("IFBIT", 0xa0, 0xa8, 0x58);
  670.   AddBit("LDC"  , 0xff, 0xff, 0x80);
  671.   AddBit("RBIT" , 0x61, 0xb8, 0x68);
  672.   AddBit("SBIT" , 0x62, 0xb0, 0x48);
  673.   AddBit("STC"  , 0xff, 0xff, 0x88);
  674.  
  675.   AddInstTable(InstTable, "IFEQ", 0, DecodeIFEQ);
  676.   AddInstTable(InstTable, "IFGT", 0, DecodeIFGT);
  677.   AddInstTable(InstTable, "IFLT", 0, DecodeIFLT);
  678.   AddInstTable(InstTable, "JMP" , 0, DecodeJMPJSR);
  679.   AddInstTable(InstTable, "JSR" , 1, DecodeJMPJSR);
  680.   AddInstTable(InstTable, "JP"  , 0, DecodeJP);
  681.   AddInstTable(InstTable, "LD"  , 0, DecodeLD);
  682.   AddInstTable(InstTable, "RLC" , 0, DecodeRotate);
  683.   AddInstTable(InstTable, "RRC" , 1, DecodeRotate);
  684.   AddInstTable(InstTable, "ST"  , 0, DecodeST);
  685.   AddInstTable(InstTable, "SFR" , 0, DecodeSFR);
  686. }
  687.  
  688. static void DeinitFields(void)
  689. {
  690.   DestroyInstTable(InstTable);
  691.   order_array_free(AriOrders);
  692.   order_array_free(SingOrders);
  693.   order_array_free(BitOrders);
  694. }
  695.  
  696. /*---------------------------------------------------------------------------*/
  697.  
  698. static void MakeCode_ACE(void)
  699. {
  700.   CodeLen = 0; DontPrint = False; BigFlag = False; OpSize = False;
  701.  
  702.   /* zu ignorierendes */
  703.  
  704.   if (Memo("")) return;
  705.  
  706.   /* Pseudoanweisungen */
  707.  
  708.   if (DecodeIntelPseudo(BigFlag)) return;
  709.  
  710.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  711.    WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  712. }
  713.  
  714. static Boolean IsDef_ACE(void)
  715. {
  716.   return (Memo("SFR"));
  717. }
  718.  
  719. static void SwitchFrom_ACE(void)
  720. {
  721.   DeinitFields();
  722. }
  723.  
  724. static void SwitchTo_ACE(void)
  725. {
  726.   const TFamilyDescr *Descr;
  727.  
  728.   TurnWords = False;
  729.   SetIntConstMode(eIntConstModeIntel);
  730.  
  731.   Descr = FindFamilyByName("ACE");
  732.   PCSymbol = "$";
  733.   HeaderID = Descr->Id;
  734.   NOPCode = 0x1c;
  735.   DivideChars = ",";
  736.   HasAttrs = False;
  737.  
  738.   ValidSegs = (1 << SegCode);
  739.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegLimits[SegCode] = 0xfff;
  740.  
  741.   switch (MomCPU - CPUACE1101)
  742.   {
  743.     case D_CPUACE1101:
  744.       SegInits[SegCode] = 0xc00;
  745.       break;
  746.     case D_CPUACE1202:
  747.       SegInits[SegCode] = 0x800;
  748.       break;
  749.   }
  750.  
  751.   MakeCode = MakeCode_ACE;
  752.   IsDef = IsDef_ACE;
  753.   SwitchFrom = SwitchFrom_ACE;
  754.   InitFields();
  755. }
  756.  
  757. void codeace_init(void)
  758. {
  759.   CPUACE1101 = AddCPU("ACE1101", SwitchTo_ACE);
  760.   CPUACE1202 = AddCPU("ACE1202", SwitchTo_ACE);
  761. }
  762.