Subversion Repositories pentevo

Rev

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

  1. /* codecop8.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegeneratormodul COP8-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 "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmitree.h"
  22. #include "codepseudo.h"
  23. #include "intpseudo.h"
  24. #include "natpseudo.h"
  25. #include "codevars.h"
  26. #include "errmsg.h"
  27.  
  28. #include "codecop8.h"
  29.  
  30. #define ModNone (-1)
  31. #define ModAcc 0
  32. #define MModAcc (1 << ModAcc)
  33. #define ModBInd 1
  34. #define MModBInd (1 << ModBInd)
  35. #define ModBInc 2
  36. #define MModBInc (1 << ModBInc)
  37. #define ModBDec 3
  38. #define MModBDec (1 << ModBDec)
  39. #define ModXInd 4
  40. #define MModXInd (1 << ModXInd)
  41. #define ModXInc 5
  42. #define MModXInc (1 << ModXInc)
  43. #define ModXDec 6
  44. #define MModXDec (1 << ModXDec)
  45. #define ModDir 7
  46. #define MModDir (1 << ModDir)
  47. #define ModImm 8
  48. #define MModImm (1 << ModImm)
  49.  
  50. #define DirPrefix 0xbd
  51. #define BReg 0xfe
  52.  
  53. #define BitOrderCnt 3
  54.  
  55. static CPUVar CPUCOP87L84;
  56.  
  57. typedef struct
  58. {
  59.   ShortInt Mode;
  60.   Byte Val;
  61.   tSymbolFlags ValSymFlags;
  62. } tAdrResult;
  63.  
  64. /*---------------------------------------------------------------------------*/
  65.  
  66. static ShortInt DecodeAdr(const tStrComp *pArg, Word Mask, tAdrResult *pResult)
  67. {
  68.   static const char ModStrings[ModXDec + 1][5] =
  69.   {
  70.     "A", "[B]", "[B+]", "[B-]",
  71.     "[X]", "[X+]", "[X-]"
  72.   };
  73.  
  74.   int z;
  75.   tEvalResult EvalResult;
  76.  
  77.   pResult->Mode = ModNone;
  78.  
  79.    /* indirekt/Akku */
  80.  
  81.   for (z = ModAcc; z <= ModXDec; z++)
  82.     if (!as_strcasecmp(pArg->str.p_str, ModStrings[z]))
  83.     {
  84.       pResult->Mode = z;
  85.       goto chk;
  86.     }
  87.  
  88.   /* immediate */
  89.  
  90.   if (*pArg->str.p_str == '#')
  91.   {
  92.     pResult->Val = EvalStrIntExpressionOffsWithResult(pArg, 1, Int8, &EvalResult);
  93.     if (EvalResult.OK)
  94.     {
  95.       pResult->Mode = ModImm;
  96.       pResult->ValSymFlags = EvalResult.Flags;
  97.     }
  98.     goto chk;
  99.   }
  100.  
  101.   /* direkt */
  102.  
  103.   pResult->Val = EvalStrIntExpressionWithResult(pArg, Int8, &EvalResult);
  104.   if (EvalResult.OK)
  105.   {
  106.     pResult->Mode = ModDir;
  107.     pResult->ValSymFlags = EvalResult.Flags;
  108.     ChkSpace(SegData, EvalResult.AddrSpaceMask);
  109.   }
  110.  
  111. chk:
  112.   if ((pResult->Mode != ModNone) && !(Mask & (1 << pResult->Mode)))
  113.   {
  114.     pResult->Mode = ModNone; WrError(ErrNum_InvAddrMode);
  115.   }
  116.   return pResult->Mode;
  117. }
  118.  
  119. /*---------------------------------------------------------------------------*/
  120.  
  121. static void DecodeFixed(Word Code)
  122. {
  123.   if (ChkArgCnt(0, 0))
  124.   {
  125.     BAsmCode[0] = Code;
  126.     CodeLen = 1;
  127.   }
  128. }
  129.  
  130. static void DecodeLD(Word Code)
  131. {
  132.   UNUSED(Code);
  133.  
  134.   if (ChkArgCnt(2, 2))
  135.   {
  136.     tAdrResult DestResult;
  137.  
  138.     switch (DecodeAdr(&ArgStr[1], MModAcc | MModDir | MModBInd | MModBInc | MModBDec, &DestResult))
  139.     {
  140.       case ModAcc:
  141.       {
  142.         tAdrResult SrcResult;
  143.  
  144.         switch(DecodeAdr(&ArgStr[2], MModDir | MModImm | MModBInd | MModXInd | MModBInc | MModXInc | MModBDec | MModXDec, &SrcResult))
  145.         {
  146.           case ModDir:
  147.             BAsmCode[0] = 0x9d;
  148.             BAsmCode[1] = SrcResult.Val;
  149.             CodeLen = 2;
  150.             break;
  151.           case ModImm:
  152.             BAsmCode[0] = 0x98;
  153.             BAsmCode[1] = SrcResult.Val;
  154.             CodeLen = 2;
  155.             break;
  156.           case ModBInd:
  157.             BAsmCode[0] = 0xae;
  158.             CodeLen = 1;
  159.             break;
  160.           case ModXInd:
  161.             BAsmCode[0] = 0xbe;
  162.             CodeLen = 1;
  163.             break;
  164.           case ModBInc:
  165.             BAsmCode[0] = 0xaa;
  166.             CodeLen = 1;
  167.             break;
  168.           case ModXInc:
  169.             BAsmCode[0] = 0xba;
  170.             CodeLen = 1;
  171.             break;
  172.           case ModBDec:
  173.             BAsmCode[0] = 0xab;
  174.             CodeLen = 1;
  175.             break;
  176.           case ModXDec:
  177.             BAsmCode[0] = 0xbb;
  178.             CodeLen = 1;
  179.             break;
  180.         }
  181.         break;
  182.       }
  183.       case ModDir:
  184.       {
  185.         tAdrResult SrcResult;
  186.  
  187.         if (DecodeAdr(&ArgStr[2], MModImm, &SrcResult) == ModImm)
  188.         {
  189.           if (DestResult.Val == BReg)
  190.           {
  191.             if (SrcResult.Val <= 15)
  192.             {
  193.               BAsmCode[0] = 0x5f - SrcResult.Val;
  194.               CodeLen = 1;
  195.             }
  196.             else
  197.             {
  198.               BAsmCode[0] = 0x9f;
  199.               BAsmCode[1] = SrcResult.Val;
  200.               CodeLen = 2;
  201.             }
  202.           }
  203.           else if (DestResult.Val >= 0xf0)
  204.           {
  205.             BAsmCode[0] = DestResult.Val - 0x20;
  206.             BAsmCode[1] = SrcResult.Val;
  207.             CodeLen = 2;
  208.           }
  209.           else
  210.           {
  211.             BAsmCode[0] = 0xbc;
  212.             BAsmCode[1] = DestResult.Val;
  213.             BAsmCode[2] = SrcResult.Val;
  214.             CodeLen = 3;
  215.           }
  216.         }
  217.         break;
  218.       }
  219.       case ModBInd:
  220.       {
  221.         tAdrResult SrcResult;
  222.  
  223.         if (DecodeAdr(&ArgStr[2], MModImm, &SrcResult) != ModNone)
  224.         {
  225.           BAsmCode[0] = 0x9e;
  226.           BAsmCode[1] = SrcResult.Val;
  227.           CodeLen = 2;
  228.         }
  229.         break;
  230.       }
  231.       case ModBInc:
  232.       {
  233.         tAdrResult SrcResult;
  234.  
  235.         if (DecodeAdr(&ArgStr[2], MModImm, &SrcResult) != ModNone)
  236.         {
  237.           BAsmCode[0] = 0x9a;
  238.           BAsmCode[1] = SrcResult.Val;
  239.           CodeLen = 2;
  240.         }
  241.         break;
  242.       }
  243.       case ModBDec:
  244.       {
  245.         tAdrResult SrcResult;
  246.  
  247.         if (DecodeAdr(&ArgStr[2], MModImm, &SrcResult) != ModNone)
  248.         {
  249.           BAsmCode[0] = 0x9b;
  250.           BAsmCode[1] = SrcResult.Val;
  251.           CodeLen = 2;
  252.         }
  253.         break;
  254.       }
  255.     }
  256.   }
  257. }
  258.  
  259. static void DecodeX(Word Code)
  260. {
  261.   UNUSED(Code);
  262.  
  263.   if (ChkArgCnt(2, 2))
  264.   {
  265.     tStrComp *pAccArg, *pMemArg;
  266.     tAdrResult DestResult;
  267.  
  268.     if (as_strcasecmp(ArgStr[1].str.p_str, "A"))
  269.     {
  270.       pAccArg = &ArgStr[2];
  271.       pMemArg = &ArgStr[1];
  272.     }
  273.     else
  274.     {
  275.       pAccArg = &ArgStr[1];
  276.       pMemArg = &ArgStr[2];
  277.     }
  278.     if (DecodeAdr(pAccArg, MModAcc, &DestResult) != ModNone)
  279.     {
  280.       tAdrResult SrcResult;
  281.  
  282.       switch (DecodeAdr(pMemArg, MModDir | MModBInd | MModXInd | MModBInc | MModXInc | MModBDec | MModXDec, &SrcResult))
  283.       {
  284.         case ModDir:
  285.           BAsmCode[0] = 0x9c;
  286.           BAsmCode[1] = SrcResult.Val;
  287.           CodeLen = 2;
  288.           break;
  289.         case ModBInd:
  290.           BAsmCode[0] = 0xa6;
  291.           CodeLen = 1;
  292.           break;
  293.         case ModBInc:
  294.           BAsmCode[0] = 0xa2;
  295.           CodeLen = 1;
  296.           break;
  297.         case ModBDec:
  298.           BAsmCode[0] = 0xa3;
  299.           CodeLen = 1;
  300.           break;
  301.         case ModXInd:
  302.           BAsmCode[0] = 0xb6;
  303.           CodeLen = 1;
  304.           break;
  305.         case ModXInc:
  306.           BAsmCode[0] = 0xb2;
  307.           CodeLen = 1;
  308.           break;
  309.         case ModXDec:
  310.           BAsmCode[0] = 0xb3;
  311.           CodeLen = 1;
  312.           break;
  313.       }
  314.     }
  315.   }
  316. }
  317.  
  318. static void DecodeAcc(Word Code)
  319. {
  320.   if (ChkArgCnt(1, 1))
  321.   {
  322.     tAdrResult DestResult;
  323.  
  324.     if (DecodeAdr(&ArgStr[1], MModAcc, &DestResult) == ModAcc)
  325.     {
  326.       BAsmCode[0] = Code;
  327.       CodeLen = 1;
  328.     }
  329.   }
  330. }
  331.  
  332. static void DecodeAccMem(Word Code)
  333. {
  334.   if (ChkArgCnt(2, 2))
  335.   {
  336.     tAdrResult DestResult;
  337.  
  338.     if (DecodeAdr(&ArgStr[1], MModAcc, &DestResult) != ModNone)
  339.     {
  340.       tAdrResult SrcResult;
  341.  
  342.       switch (DecodeAdr(&ArgStr[2], MModDir | MModImm | MModBInd, &SrcResult))
  343.       {
  344.         case ModBInd:
  345.           BAsmCode[0] = Code;
  346.           CodeLen = 1;
  347.           break;
  348.         case ModImm:
  349.           BAsmCode[0] = Code + 0x10;
  350.           BAsmCode[1] = SrcResult.Val;
  351.           CodeLen = 2;
  352.           break;
  353.         case ModDir:
  354.           BAsmCode[0] = DirPrefix;
  355.           BAsmCode[1] = SrcResult.Val;
  356.           BAsmCode[2] = Code;
  357.           CodeLen = 3;
  358.           break;
  359.       }
  360.     }
  361.   }
  362. }
  363.  
  364. static void DecodeANDSZ(Word Code)
  365. {
  366.   UNUSED(Code);
  367.  
  368.   if (ChkArgCnt(2, 2))
  369.   {
  370.     tAdrResult DestResult;
  371.  
  372.     if (DecodeAdr(&ArgStr[1], MModAcc, &DestResult) != ModNone)
  373.     {
  374.       tAdrResult SrcResult;
  375.  
  376.       if (DecodeAdr(&ArgStr[2], MModImm, &SrcResult) == ModImm)
  377.       {
  378.         BAsmCode[0] = 0x60;
  379.         BAsmCode[1] = SrcResult.Val;
  380.         CodeLen = 2;
  381.       }
  382.     }
  383.   }
  384. }
  385.  
  386. static void DecodeIFEQ(Word Code)
  387. {
  388.   UNUSED(Code);
  389.  
  390.   if (ChkArgCnt(2, 2))
  391.   {
  392.     tAdrResult DestResult;
  393.  
  394.     switch (DecodeAdr(&ArgStr[1], MModAcc | MModDir, &DestResult))
  395.     {
  396.       case ModAcc:
  397.       {
  398.         tAdrResult SrcResult;
  399.  
  400.         switch (DecodeAdr(&ArgStr[2], MModDir | MModBInd | MModImm, &SrcResult))
  401.         {
  402.           case ModDir:
  403.             BAsmCode[0] = DirPrefix;
  404.             BAsmCode[1] = SrcResult.Val;
  405.             BAsmCode[2] = 0x82;
  406.             CodeLen = 3;
  407.             break;
  408.           case ModBInd:
  409.             BAsmCode[0] = 0x82;
  410.             CodeLen = 1;
  411.             break;
  412.           case ModImm:
  413.             BAsmCode[0] = 0x92;
  414.             BAsmCode[1] = SrcResult.Val;
  415.             CodeLen = 2;
  416.             break;
  417.         }
  418.         break;
  419.       }
  420.       case ModDir:
  421.       {
  422.         tAdrResult SrcResult;
  423.  
  424.         BAsmCode[1] = DestResult.Val;
  425.         if (DecodeAdr(&ArgStr[2], MModImm, &SrcResult) == ModImm)
  426.         {
  427.           BAsmCode[0] = 0xa9;
  428.           BAsmCode[2] = SrcResult.Val;
  429.           CodeLen = 3;
  430.         }
  431.         break;
  432.       }
  433.     }
  434.   }
  435. }
  436.  
  437. static void DecodeIFNE(Word Code)
  438. {
  439.   UNUSED(Code);
  440.  
  441.   if (ChkArgCnt(2, 2))
  442.   {
  443.     tAdrResult DestResult;
  444.  
  445.     switch (DecodeAdr(&ArgStr[1], MModAcc, &DestResult))
  446.     {
  447.       case ModAcc:
  448.       {
  449.         tAdrResult SrcResult;
  450.  
  451.         switch (DecodeAdr(&ArgStr[2], MModDir | MModBInd | MModImm, &SrcResult))
  452.         {
  453.           case ModDir:
  454.             BAsmCode[0] = DirPrefix;
  455.             BAsmCode[1] = SrcResult.Val;
  456.             BAsmCode[2] = 0xb9;
  457.             CodeLen = 3;
  458.             break;
  459.           case ModBInd:
  460.             BAsmCode[0] = 0xb9;
  461.             CodeLen = 1;
  462.             break;
  463.           case ModImm:
  464.             BAsmCode[0] = 0x99;
  465.             BAsmCode[1] = SrcResult.Val;
  466.             CodeLen = 2;
  467.             break;
  468.         }
  469.         break;
  470.       }
  471.     }
  472.   }
  473. }
  474.  
  475. static void DecodeIFBNE(Word Code)
  476. {
  477.   UNUSED(Code);
  478.  
  479.   if (!ChkArgCnt(1, 1));
  480.   else if (*ArgStr[1].str.p_str != '#') WrError(ErrNum_InvAddrMode);
  481.   else
  482.   {
  483.     Boolean OK;
  484.  
  485.     BAsmCode[0] = EvalStrIntExpressionOffs(&ArgStr[1], 1, UInt4, &OK);
  486.     if (OK)
  487.     {
  488.       BAsmCode[0] += 0x40;
  489.       CodeLen = 1;
  490.     }
  491.   }
  492. }
  493.  
  494. static void DecodeBit(Word Code)
  495. {
  496.   if (ChkArgCnt(2, 2))
  497.   {
  498.     Boolean OK;
  499.  
  500.     Byte HReg = EvalStrIntExpression(&ArgStr[1], UInt3, &OK);
  501.     if (OK)
  502.     {
  503.       tAdrResult DestResult;
  504.  
  505.       switch (DecodeAdr(&ArgStr[2], MModDir | MModBInd, &DestResult))
  506.       {
  507.         case ModDir:
  508.           BAsmCode[0] = DirPrefix;
  509.           BAsmCode[1] = DestResult.Val;
  510.           BAsmCode[2] = Code + HReg;
  511.           CodeLen = 3;
  512.           break;
  513.         case ModBInd:
  514.           BAsmCode[0] = Code + HReg;
  515.           CodeLen = 1;
  516.           break;
  517.       }
  518.     }
  519.   }
  520. }
  521.  
  522. static void DecodeJMP_JSR(Word Code)
  523. {
  524.   if (ChkArgCnt(1, 1))
  525.   {
  526.     tEvalResult EvalResult;
  527.     Word AdrWord = EvalStrIntExpressionWithResult(&ArgStr[1], UInt16, &EvalResult);
  528.  
  529.     if (EvalResult.OK && ChkSamePage(EProgCounter() + 2, AdrWord, 12, EvalResult.Flags))
  530.     {
  531.       ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  532.       BAsmCode[0] = 0x20 + Code + ((AdrWord >> 8) & 15);
  533.       BAsmCode[1] = Lo(AdrWord);
  534.       CodeLen = 2;
  535.     }
  536.   }
  537. }
  538.  
  539. static void DecodeJMPL_JSRL(Word Code)
  540. {
  541.   if (ChkArgCnt(1, 1))
  542.   {
  543.     tEvalResult EvalResult;
  544.     Word AdrWord = EvalStrIntExpressionWithResult(&ArgStr[1], UInt16, &EvalResult);
  545.  
  546.     if (EvalResult.OK)
  547.     {
  548.       ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  549.       BAsmCode[0] = Code;
  550.       BAsmCode[1] = Hi(AdrWord);
  551.       BAsmCode[2] = Lo(AdrWord);
  552.       CodeLen = 3;
  553.     }
  554.   }
  555. }
  556.  
  557. static void DecodeJP(Word Code)
  558. {
  559.   UNUSED(Code);
  560.  
  561.   if (ChkArgCnt(1, 1))
  562.   {
  563.     Boolean OK;
  564.     tSymbolFlags Flags;
  565.  
  566.     Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt16, &OK, &Flags) - (EProgCounter() + 1);
  567.     if (OK)
  568.     {
  569.       if (AdrInt == 0)
  570.       {
  571.         BAsmCode[0] = NOPCode;
  572.         CodeLen = 1;
  573.         WrError(ErrNum_DistNull);
  574.       }
  575.       else if (((AdrInt > 31) || (AdrInt < -32)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);
  576.       else
  577.       {
  578.         BAsmCode[0] = AdrInt & 0xff;
  579.         CodeLen = 1;
  580.       }
  581.     }
  582.   }
  583.   return;
  584. }
  585.  
  586. static void DecodeDRSZ(Word Code)
  587. {
  588.   UNUSED(Code);
  589.  
  590.   if (ChkArgCnt(1, 1))
  591.   {
  592.     tAdrResult DestResult;
  593.  
  594.     if (DecodeAdr(&ArgStr[1], MModDir, &DestResult) == ModDir)
  595.     {
  596.       if (mFirstPassUnknown(DestResult.ValSymFlags))
  597.         DestResult.Val |= 0xf0;
  598.       if (DestResult.Val < 0xf0) WrError(ErrNum_UnderRange);
  599.       else
  600.       {
  601.         BAsmCode[0] = DestResult.Val - 0x30;
  602.         CodeLen = 1;
  603.       }
  604.     }
  605.   }
  606. }
  607.  
  608. /*---------------------------------------------------------------------------*/
  609.  
  610. static void AddFixed(const char *NName, Byte NCode)
  611. {
  612.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  613. }
  614.  
  615. static void AddAcc(const char *NName, Byte NCode)
  616. {
  617.   AddInstTable(InstTable, NName, NCode, DecodeAcc);
  618. }
  619.  
  620. static void AddAccMem(const char *NName, Byte NCode)
  621. {
  622.   AddInstTable(InstTable, NName, NCode, DecodeAccMem);
  623. }
  624.  
  625. static void AddBit(const char *NName, Byte NCode)
  626. {
  627.   AddInstTable(InstTable, NName, NCode, DecodeBit);
  628. }
  629.  
  630. static void InitFields(void)
  631. {
  632.   InstTable = CreateInstTable(103);
  633.   AddInstTable(InstTable, "LD", 0, DecodeLD);
  634.   AddInstTable(InstTable, "X", 0, DecodeX);
  635.   AddInstTable(InstTable, "ANDSZ", 0, DecodeANDSZ);
  636.   AddInstTable(InstTable, "IFEQ", 0, DecodeIFEQ);
  637.   AddInstTable(InstTable, "IFNE", 0, DecodeIFNE);
  638.   AddInstTable(InstTable, "IFBNE", 0, DecodeIFBNE);
  639.   AddInstTable(InstTable, "JMP", 0, DecodeJMP_JSR);
  640.   AddInstTable(InstTable, "JSR", 0x10, DecodeJMP_JSR);
  641.   AddInstTable(InstTable, "JMPL", 0xac, DecodeJMPL_JSRL);
  642.   AddInstTable(InstTable, "JSRL", 0xad, DecodeJMPL_JSRL);
  643.   AddInstTable(InstTable, "JP", 0, DecodeJP);
  644.   AddInstTable(InstTable, "DRSZ", 0, DecodeDRSZ);
  645.  
  646.   AddFixed("LAID" , 0xa4);  AddFixed("SC"   , 0xa1);  AddFixed("RC"   , 0xa0);
  647.   AddFixed("IFC"  , 0x88);  AddFixed("IFNC" , 0x89);  AddFixed("VIS"  , 0xb4);
  648.   AddFixed("JID"  , 0xa5);  AddFixed("RET"  , 0x8e);  AddFixed("RETSK", 0x8d);
  649.   AddFixed("RETI" , 0x8f);  AddFixed("INTR" , 0x00);  AddFixed("NOP"  , 0xb8);
  650.   AddFixed("RPND" , 0xb5);
  651.  
  652.   AddAcc("CLR"  , 0x64);  AddAcc("INC"  , 0x8a);  AddAcc("DEC"  , 0x8b);
  653.   AddAcc("DCOR" , 0x66);  AddAcc("RRC"  , 0xb0);  AddAcc("RLC"  , 0xa8);
  654.   AddAcc("SWAP" , 0x65);  AddAcc("POP"  , 0x8c);  AddAcc("PUSH" , 0x67);
  655.  
  656.   AddAccMem("ADD"  , 0x84);  AddAccMem("ADC"  , 0x80);  AddAccMem("SUBC" , 0x81);
  657.   AddAccMem("AND"  , 0x85);  AddAccMem("OR"   , 0x87);  AddAccMem("XOR"  , 0x86);
  658.   AddAccMem("IFGT" , 0x83);
  659.  
  660.   AddBit("IFBIT", 0x70); AddBit("SBIT", 0x78); AddBit("RBIT", 0x68);
  661. }
  662.  
  663. static void DeinitFields(void)
  664. {
  665.   DestroyInstTable(InstTable);
  666. }
  667.  
  668. /*---------------------------------------------------------------------------*/
  669.  
  670. static void MakeCode_COP8(void)
  671. {
  672.   CodeLen = 0; DontPrint = False;
  673.  
  674.   /* zu ignorierendes */
  675.  
  676.   if (Memo("")) return;
  677.  
  678.   /* Pseudoanweisungen */
  679.  
  680.   if (DecodeNatPseudo()) return;
  681.   if (DecodeIntelPseudo(False)) return;
  682.  
  683.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  684.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  685. }
  686.  
  687. static Boolean IsDef_COP8(void)
  688. {
  689.   return (Memo("SFR"));
  690. }
  691.  
  692. static void SwitchFrom_COP8(void)
  693. {
  694.   DeinitFields();
  695. }
  696.  
  697. static void SwitchTo_COP8(void)
  698. {
  699.   TurnWords = False;
  700.   SetIntConstMode(eIntConstModeC);
  701.  
  702.   PCSymbol = ".";
  703.   HeaderID = 0x6f;
  704.   NOPCode = 0xb8;
  705.   DivideChars = ",";
  706.   HasAttrs = False;
  707.  
  708.   ValidSegs = (1 << SegCode) | (1 << SegData);
  709.   Grans[SegCode] = 1;
  710.   ListGrans[SegCode] = 1;
  711.   SegInits[SegCode]  =0;
  712.   SegLimits[SegCode] = 0x1fff;
  713.   Grans[SegData] = 1;
  714.   ListGrans[SegData] = 1;
  715.   SegInits[SegData] = 0;
  716.   SegLimits[SegData] = 0xff;
  717.  
  718.   MakeCode = MakeCode_COP8;
  719.   IsDef = IsDef_COP8;
  720.   SwitchFrom = SwitchFrom_COP8;
  721.   InitFields();
  722. }
  723.  
  724. void codecop8_init(void)
  725. {
  726.   CPUCOP87L84 = AddCPU("COP87L84", SwitchTo_COP8);
  727. }
  728.