Subversion Repositories pentevo

Rev

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

  1. /* code370.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator 370-Familie                                                 */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12.  
  13. #include <ctype.h>
  14. #include <string.h>
  15.  
  16. #include "bpemu.h"
  17. #include "strutil.h"
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmitree.h"
  22. #include "intformat.h"
  23. #include "intpseudo.h"
  24. #include "codevars.h"
  25. #include "errmsg.h"
  26.  
  27. #include "code370.h"
  28.  
  29. typedef struct
  30. {
  31.   char *Name;
  32.   Word Code;
  33. } FixedOrder;
  34.  
  35. enum
  36. {
  37.   ModNone = -1,
  38.   ModAccA = 0,       /* A */
  39.   ModAccB = 1,       /* B */
  40.   ModReg = 2,        /* Rn */
  41.   ModPort = 3,       /* Pn */
  42.   ModAbs = 4,        /* nnnn */
  43.   ModBRel = 5,       /* nnnn(B) */
  44.   ModSPRel = 6,      /* nn(SP) */
  45.   ModIReg = 7,       /* @Rn */
  46.   ModRegRel = 8,     /* nn(Rn) */
  47.   ModImm = 9,        /* #nn */
  48.   ModImmBRel = 10,   /* #nnnn(B) */
  49.   ModImmRegRel = 11  /* #nn(Rm) */
  50. };
  51.  
  52. #define MModAccA (1 << ModAccA)
  53. #define MModAccB (1 << ModAccB)
  54. #define MModReg (1 << ModReg)
  55. #define MModPort (1 << ModPort)
  56. #define MModAbs (1 << ModAbs)
  57. #define MModBRel (1 << ModBRel)
  58. #define MModSPRel (1 << ModSPRel)
  59. #define MModIReg (1 << ModIReg)
  60. #define MModRegRel (1 << ModRegRel)
  61. #define MModImm (1 << ModImm)
  62. #define MModImmBRel (1 << ModImmBRel)
  63. #define MModImmRegRel (1 << ModImmRegRel)
  64.  
  65. static CPUVar CPU37010, CPU37020, CPU37030, CPU37040, CPU37050;
  66.  
  67. static Byte OpSize;
  68. static ShortInt AdrType;
  69. static Byte AdrVals[2];
  70.  
  71. /****************************************************************************/
  72.  
  73. static char *HasDisp(char *Asc)
  74. {
  75.   char *p;
  76.   int Lev;
  77.  
  78.   if ((*Asc) && (Asc[strlen(Asc) - 1] == ')'))
  79.   {
  80.     p = Asc + strlen(Asc) - 2;
  81.     Lev = 0;
  82.     while ((p >= Asc) && (Lev != -1))
  83.     {
  84.       switch (*p)
  85.       {
  86.         case '(': Lev--; break;
  87.         case ')': Lev++; break;
  88.       }
  89.       if (Lev != -1)
  90.         p--;
  91.     }
  92.     if (p < Asc)
  93.     {
  94.       WrXError(ErrNum_BrackErr, Asc);
  95.       return NULL;
  96.     }
  97.   }
  98.   else
  99.     p = NULL;
  100.  
  101.   return p;
  102. }
  103.  
  104. static void DecodeAdrRel(const tStrComp *pArg, Word Mask, Boolean AddrRel)
  105. {
  106.   Integer HVal;
  107.   char *p;
  108.   Boolean OK;
  109.  
  110.   AdrType = ModNone;
  111.   AdrCnt = 0;
  112.  
  113.   if (!as_strcasecmp(pArg->str.p_str, "A"))
  114.   {
  115.     if (Mask & MModAccA)
  116.       AdrType = ModAccA;
  117.     else if (Mask & MModReg)
  118.     {
  119.       AdrCnt = 1;
  120.       AdrVals[0] = 0;
  121.       AdrType = ModReg;
  122.     }
  123.     else
  124.     {
  125.       AdrCnt = 2;
  126.       AdrVals[0] = 0;
  127.       AdrVals[1] = 0;
  128.       AdrType = ModAbs;
  129.     }
  130.     goto chk;
  131.   }
  132.  
  133.   if (!as_strcasecmp(pArg->str.p_str, "B"))
  134.   {
  135.     if (Mask & MModAccB)
  136.       AdrType = ModAccB;
  137.     else if (Mask & MModReg)
  138.     {
  139.       AdrCnt = 1;
  140.       AdrVals[0] = 1;
  141.       AdrType = ModReg;
  142.     }
  143.     else
  144.     {
  145.       AdrCnt = 2;
  146.       AdrVals[0] = 0;
  147.       AdrVals[1] = 1;
  148.       AdrType = ModAbs;
  149.     }
  150.     goto chk;
  151.   }
  152.  
  153.   if (*pArg->str.p_str == '#')
  154.   {
  155.     tStrComp Arg;
  156.  
  157.     StrCompRefRight(&Arg, pArg, 1);
  158.     p = HasDisp(Arg.str.p_str);
  159.     if (!p)
  160.     {
  161.       switch (OpSize)
  162.       {
  163.         case 0:
  164.           AdrVals[0] = EvalStrIntExpression(&Arg, Int8, &OK);
  165.           break;
  166.         case 1:
  167.           HVal = EvalStrIntExpression(&Arg, Int16, &OK);
  168.           AdrVals[0] = Hi(HVal); AdrVals[1] = Lo(HVal);
  169.           break;
  170.       }
  171.       if (OK)
  172.       {
  173.         AdrCnt = 1 + OpSize;
  174.         AdrType = ModImm;
  175.       }
  176.     }
  177.     else
  178.     {
  179.       tStrComp Left, Right;
  180.       tSymbolFlags Flags;
  181.  
  182.       StrCompSplitRef(&Left, &Right, &Arg, p);
  183.       HVal = EvalStrIntExpressionWithFlags(&Left, Int16, &OK, &Flags);
  184.       if (OK)
  185.       {
  186.         *p = '(';
  187.         if (!as_strcasecmp(p, "(B)"))
  188.         {
  189.           AdrVals[0] = Hi(HVal);
  190.           AdrVals[1] = Lo(HVal);
  191.           AdrCnt = 2;
  192.           AdrType = ModImmBRel;
  193.         }
  194.         else
  195.         {
  196.           if (mFirstPassUnknown(Flags))
  197.             HVal &= 127;
  198.           if (ChkRange(HVal, -128, 127))
  199.           {
  200.             AdrVals[0] = HVal & 0xff;
  201.             AdrCnt = 1;
  202.             AdrVals[1] = EvalStrIntExpression(&Arg, UInt8, &OK);
  203.             if (OK)
  204.             {
  205.               AdrCnt = 2;
  206.               AdrType = ModImmRegRel;
  207.             }
  208.           }
  209.         }
  210.       }
  211.     }
  212.     goto chk;
  213.   }
  214.  
  215.   if (*pArg->str.p_str == '@')
  216.   {
  217.     AdrVals[0] = EvalStrIntExpressionOffs(pArg, 1, Int8, &OK);
  218.     if (OK)
  219.     {
  220.       AdrCnt = 1;
  221.       AdrType = ModIReg;
  222.     }
  223.     goto chk;
  224.   }
  225.  
  226.   p = HasDisp(pArg->str.p_str);
  227.  
  228.   if (!p)
  229.   {
  230.     HVal = EvalStrIntExpression(pArg, Int16, &OK);
  231.     if (OK)
  232.     {
  233.       if (((Mask & MModReg) != 0) && (Hi(HVal) == 0))
  234.       {
  235.         AdrVals[0] = Lo(HVal);
  236.         AdrCnt = 1;
  237.         AdrType = ModReg;
  238.       }
  239.       else if (((Mask & MModPort) != 0) && (Hi(HVal) == 0x10))
  240.       {
  241.         AdrVals[0] = Lo(HVal);
  242.         AdrCnt = 1;
  243.         AdrType = ModPort;
  244.       }
  245.       else
  246.       {
  247.         if (AddrRel)
  248.           HVal -= EProgCounter() + 3;
  249.         AdrVals[0] = Hi(HVal);
  250.         AdrVals[1] = Lo(HVal);
  251.         AdrCnt = 2;
  252.         AdrType = ModAbs;
  253.       }
  254.     }
  255.     goto chk;
  256.   }
  257.   else
  258.   {
  259.     tStrComp Left, Right;
  260.     tSymbolFlags Flags;
  261.  
  262.     StrCompSplitRef(&Left, &Right, pArg, p);
  263.     HVal = EvalStrIntExpressionWithFlags(&Left, Int16, &OK, &Flags);
  264.     if (mFirstPassUnknown(Flags))
  265.       HVal &= 0x7f;
  266.     if (OK)
  267.     {
  268.       StrCompShorten (&Right, 1);
  269.       if (!as_strcasecmp(Right.str.p_str, "B"))
  270.       {
  271.         if (AddrRel)
  272.           HVal -= EProgCounter() + 3;
  273.         AdrVals[0] = Hi(HVal);
  274.         AdrVals[1] = Lo(HVal);
  275.         AdrCnt = 2;
  276.         AdrType = ModBRel;
  277.       }
  278.       else if (!as_strcasecmp(Right.str.p_str, "SP"))
  279.       {
  280.         if (AddrRel)
  281.           HVal -= EProgCounter() + 3;
  282.         if (HVal > 127) WrError(ErrNum_OverRange);
  283.         else if (HVal < -128) WrError(ErrNum_UnderRange);
  284.         else
  285.         {
  286.           AdrVals[0] = HVal & 0xff;
  287.           AdrCnt = 1;
  288.           AdrType = ModSPRel;
  289.         }
  290.       }
  291.       else
  292.       {
  293.         if (HVal > 127) WrError(ErrNum_OverRange);
  294.         else if (HVal < -128) WrError(ErrNum_UnderRange);
  295.         else
  296.         {
  297.           AdrVals[0] = HVal & 0xff;
  298.           AdrVals[1] = EvalStrIntExpression(&Right, Int8, &OK);
  299.           if (OK)
  300.           {
  301.             AdrCnt = 2;
  302.             AdrType = ModRegRel;
  303.           }
  304.         }
  305.       }
  306.     }
  307.     goto chk;
  308.   }
  309.  
  310. chk:
  311.   if ((AdrType != ModNone) && (!(Mask & (1 << AdrType))))
  312.   {
  313.     WrError(ErrNum_InvAddrMode);
  314.     AdrType = ModNone;
  315.     AdrCnt = 0;
  316.   }
  317. }
  318.  
  319. static void DecodeAdr(const tStrComp *pArg, Word Mask)
  320. {
  321.   DecodeAdrRel(pArg, Mask, FALSE);
  322. }
  323.  
  324. static void PutCode(Word Code)
  325. {
  326.   if (Hi(Code) == 0)
  327.   {
  328.     CodeLen = 1;
  329.     BAsmCode[0] = Code;
  330.   }
  331.   else
  332.   {
  333.     CodeLen = 2;
  334.     BAsmCode[0] = Hi(Code);
  335.     BAsmCode[1] = Lo(Code);
  336.   }
  337. }
  338.  
  339. static void DissectBitValue(LargeWord Symbol, Word *pAddr, Byte *pBit)
  340. {
  341.   *pAddr = Symbol & 0xffff;
  342.   *pBit = (Symbol >> 16) & 7;
  343. }
  344.  
  345. static void DissectBit_370(char *pDest, size_t DestSize, LargeWord Symbol)
  346. {
  347.   Word Addr;
  348.   Byte Bit;
  349.  
  350.   DissectBitValue(Symbol, &Addr, &Bit);
  351.  
  352.   if (Addr < 2)
  353.     as_snprintf(pDest, DestSize, "%c", HexStartCharacter + Addr);
  354.   else
  355.     as_snprintf(pDest, DestSize, "%~0.*u%s",
  356.                 ListRadixBase, (unsigned)Addr, GetIntConstIntelSuffix(ListRadixBase));
  357.   as_snprcatf(pDest, DestSize, ".%c", Bit + '0');
  358. }
  359.  
  360. static Boolean DecodeBitExpr(int Start, int Stop, LongWord *pResult)
  361. {
  362.   Boolean OK;
  363.  
  364.   if (Start == Stop)
  365.   {
  366.     *pResult = EvalStrIntExpression(&ArgStr[Start], UInt19, &OK);
  367.     return OK;
  368.   }
  369.   else
  370.   {
  371.     Byte Bit;
  372.     Word Addr;
  373.  
  374.     Bit = EvalStrIntExpression(&ArgStr[Start], UInt3, &OK);
  375.     if (!OK)
  376.       return OK;
  377.  
  378.     if ((!as_strcasecmp(ArgStr[Stop].str.p_str, "A")) || (!as_strcasecmp(ArgStr[Stop].str.p_str, "B")))
  379.     {
  380.       Addr = toupper(*ArgStr[Stop].str.p_str) - 'A';
  381.       OK = True;
  382.     }
  383.     else
  384.     {
  385.       tSymbolFlags Flags;
  386.  
  387.       Addr = EvalStrIntExpressionWithFlags(&ArgStr[Stop], UInt16, &OK, &Flags);
  388.       if (!OK)
  389.         return OK;
  390.       if (mFirstPassUnknown(Flags))
  391.         Addr &= 0xff;
  392.       if (Addr & 0xef00) /* 00h...0ffh, 1000h...10ffh allowed */
  393.       {
  394.         WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[Stop]);
  395.         return False;
  396.       }
  397.     }
  398.  
  399.     *pResult = (((LongWord)Bit) << 16) + Addr;
  400.     return True;
  401.   }
  402. }
  403.  
  404. /****************************************************************************/
  405.  
  406. static void DecodeFixed(Word Code)
  407. {
  408.   if (ChkArgCnt(0, 0))
  409.     PutCode(Code);
  410. }
  411.  
  412. static void DecodeDBIT(Word Code)
  413. {
  414.   LongWord Value;
  415.  
  416.   UNUSED(Code);
  417.  
  418.   if (ChkArgCnt(1, 2) && DecodeBitExpr(1, ArgCnt, &Value))
  419.   {
  420.     PushLocHandle(-1);
  421.     EnterIntSymbol(&LabPart, Value, SegBData, False);
  422.     *ListLine = '=';
  423.     DissectBit_370(ListLine + 1, STRINGSIZE - 1, Value);
  424.     PopLocHandle();
  425.   }
  426. }
  427.  
  428. static void DecodeMOV(Word Code)
  429. {
  430.   UNUSED(Code);
  431.  
  432.   if (ChkArgCnt(2, 2))
  433.   {
  434.     DecodeAdr(&ArgStr[2], MModAccB + MModReg + MModPort + MModAbs + MModIReg + MModBRel
  435.                        + MModSPRel + MModRegRel + MModAccA);
  436.     switch (AdrType)
  437.     {
  438.       case ModAccA:
  439.         DecodeAdr(&ArgStr[1], MModReg + MModAbs + MModIReg + MModBRel + MModRegRel
  440.                            + MModSPRel + MModAccB + MModPort + MModImm);
  441.         switch (AdrType)
  442.         {
  443.           case ModReg:
  444.             BAsmCode[0] = 0x12;
  445.             BAsmCode[1] = AdrVals[0];
  446.             CodeLen = 2;
  447.             break;
  448.           case ModAbs:
  449.             BAsmCode[0] = 0x8a;
  450.             memcpy(BAsmCode + 1, AdrVals, 2);
  451.             CodeLen = 3;
  452.             break;
  453.           case ModIReg:
  454.             BAsmCode[0] = 0x9a;
  455.             BAsmCode[1] = AdrVals[0];
  456.             CodeLen = 2;
  457.             break;
  458.           case ModBRel:
  459.             BAsmCode[0] = 0xaa;
  460.             memcpy(BAsmCode + 1, AdrVals, 2);
  461.             CodeLen = 3;
  462.             break;
  463.           case ModRegRel:
  464.             BAsmCode[0] = 0xf4;
  465.             BAsmCode[1] = 0xea;
  466.             memcpy(BAsmCode + 2, AdrVals, 2);
  467.             CodeLen = 4;
  468.             break;
  469.           case ModSPRel:
  470.             BAsmCode[0] = 0xf1;
  471.             BAsmCode[1] = AdrVals[0];
  472.             CodeLen = 2;
  473.             break;
  474.           case ModAccB:
  475.             BAsmCode[0] = 0x62;
  476.             CodeLen = 1;
  477.             break;
  478.           case ModPort:
  479.             BAsmCode[0] = 0x80;
  480.             BAsmCode[1] = AdrVals[0];
  481.             CodeLen = 2;
  482.             break;
  483.           case ModImm:
  484.             BAsmCode[0] = 0x22;
  485.             BAsmCode[1] = AdrVals[0];
  486.             CodeLen = 2;
  487.             break;
  488.         }
  489.         break;
  490.       case ModAccB:
  491.         DecodeAdr(&ArgStr[1], MModAccA + MModReg + MModPort + MModImm);
  492.         switch (AdrType)
  493.         {
  494.           case ModAccA:
  495.             BAsmCode[0] = 0xc0;
  496.             CodeLen = 1;
  497.             break;
  498.           case ModReg:
  499.             BAsmCode[0] = 0x32;
  500.             BAsmCode[1] = AdrVals[0];
  501.             CodeLen = 2;
  502.             break;
  503.           case ModPort:
  504.             BAsmCode[0] = 0x91;
  505.             BAsmCode[1] = AdrVals[0];
  506.             CodeLen = 2;
  507.             break;
  508.           case ModImm:
  509.             BAsmCode[0] = 0x52;
  510.             BAsmCode[1] = AdrVals[0];
  511.             CodeLen = 2;
  512.             break;
  513.         }
  514.         break;
  515.       case ModReg:
  516.         BAsmCode[1] = BAsmCode[2] = AdrVals[0];
  517.         DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModReg + MModPort + MModImm);
  518.         switch (AdrType)
  519.         {
  520.           case ModAccA:
  521.             BAsmCode[0] = 0xd0;
  522.             CodeLen = 2;
  523.             break;
  524.           case ModAccB:
  525.             BAsmCode[0] = 0xd1;
  526.             CodeLen = 2;
  527.             break;
  528.           case ModReg:
  529.             BAsmCode[0] = 0x42;
  530.             BAsmCode[1] = AdrVals[0];
  531.             CodeLen = 3;
  532.             break;
  533.           case ModPort:
  534.             BAsmCode[0] = 0xa2;
  535.             BAsmCode[1] = AdrVals[0];
  536.             CodeLen = 3;
  537.             break;
  538.           case ModImm:
  539.             BAsmCode[0] = 0x72;
  540.             BAsmCode[1] = AdrVals[0];
  541.             CodeLen = 3;
  542.             break;
  543.         }
  544.         break;
  545.       case ModPort:
  546.         BAsmCode[1] = BAsmCode[2] = AdrVals[0];
  547.         DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModReg + MModImm);
  548.         switch (AdrType)
  549.         {
  550.           case ModAccA:
  551.             BAsmCode[0] = 0x21;
  552.             CodeLen = 2;
  553.             break;
  554.           case ModAccB:
  555.             BAsmCode[0] = 0x51;
  556.             CodeLen = 2;
  557.             break;
  558.           case ModReg:
  559.             BAsmCode[0] = 0x71;
  560.             BAsmCode[1] = AdrVals[0];
  561.             CodeLen = 3;
  562.             break;
  563.           case ModImm:
  564.             BAsmCode[0] = 0xf7;
  565.             BAsmCode[1] = AdrVals[0];
  566.             CodeLen = 3;
  567.             break;
  568.         }
  569.         break;
  570.       case ModAbs:
  571.         memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  572.         DecodeAdr(&ArgStr[1], MModAccA);
  573.         if (AdrType != ModNone)
  574.         {
  575.           BAsmCode[0] = 0x8b;
  576.           CodeLen = 3;
  577.         }
  578.         break;
  579.       case ModIReg:
  580.         BAsmCode[1] = AdrVals[0];
  581.         DecodeAdr(&ArgStr[1], MModAccA);
  582.         if (AdrType != ModNone)
  583.         {
  584.           BAsmCode[0] = 0x9b;
  585.           CodeLen = 2;
  586.         }
  587.         break;
  588.       case ModBRel:
  589.         memcpy(BAsmCode + 1, AdrVals, AdrCnt);
  590.         DecodeAdr(&ArgStr[1], MModAccA);
  591.         if (AdrType != ModNone)
  592.         {
  593.           BAsmCode[0] = 0xab;
  594.           CodeLen = 3;
  595.         }
  596.         break;
  597.       case ModSPRel:
  598.         BAsmCode[1] = AdrVals[0];
  599.         DecodeAdr(&ArgStr[1], MModAccA);
  600.         if (AdrType != ModNone)
  601.         {
  602.           BAsmCode[0] = 0xf2;
  603.           CodeLen = 2;
  604.         }
  605.         break;
  606.       case ModRegRel:
  607.         memcpy(BAsmCode + 2, AdrVals, AdrCnt);
  608.         DecodeAdr(&ArgStr[1], MModAccA);
  609.         if (AdrType != ModNone)
  610.         {
  611.           BAsmCode[0] = 0xf4;
  612.           BAsmCode[1] = 0xeb;
  613.           CodeLen = 4;
  614.         }
  615.         break;
  616.     }
  617.   }
  618. }
  619.  
  620. static void DecodeMOVW(Word Code)
  621. {
  622.   UNUSED(Code);
  623.  
  624.   OpSize = 1;
  625.   if (ChkArgCnt(2, 2))
  626.   {
  627.     DecodeAdr(&ArgStr[2], MModReg);
  628.     if (AdrType != ModNone)
  629.     {
  630.       Byte AdrVal = AdrVals[0];
  631.  
  632.       DecodeAdr(&ArgStr[1], MModReg + MModImm + MModImmBRel + MModImmRegRel);
  633.       switch (AdrType)
  634.       {
  635.         case ModReg:
  636.           BAsmCode[0] = 0x98;
  637.           BAsmCode[1] = AdrVals[0];
  638.           BAsmCode[2] = AdrVal;
  639.           CodeLen = 3;
  640.           break;
  641.         case ModImm:
  642.           BAsmCode[0] = 0x88;
  643.           memcpy(BAsmCode + 1, AdrVals, 2);
  644.           BAsmCode[3] = AdrVal;
  645.           CodeLen = 4;
  646.           break;
  647.         case ModImmBRel:
  648.           BAsmCode[0] = 0xa8;
  649.           memcpy(BAsmCode + 1, AdrVals, 2);
  650.           BAsmCode[3] = AdrVal;
  651.           CodeLen = 4;
  652.           break;
  653.         case ModImmRegRel:
  654.           BAsmCode[0] = 0xf4;
  655.           BAsmCode[1] = 0xe8;
  656.           memcpy(BAsmCode + 2, AdrVals, 2);
  657.           BAsmCode[4] = AdrVal;
  658.           CodeLen = 5;
  659.           break;
  660.       }
  661.     }
  662.   }
  663. }
  664.  
  665. static void DecodeRel8(Word Code)
  666. {
  667.   if (ChkArgCnt(1, 1))
  668.   {
  669.     Boolean OK;
  670.     tSymbolFlags Flags;
  671.     Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[1], Int16, &OK, &Flags) - (EProgCounter() + 2);
  672.  
  673.     if (OK)
  674.     {
  675.       if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) || (AdrInt < -128))) WrError(ErrNum_JmpDistTooBig);
  676.       else
  677.       {
  678.         CodeLen = 2;
  679.         BAsmCode[0] = Code;
  680.         BAsmCode[1] = AdrInt & 0xff;
  681.       }
  682.     }
  683.   }
  684. }
  685.  
  686. static void DecodeCMP(Word Code)
  687. {
  688.   UNUSED(Code);
  689.  
  690.   if (ChkArgCnt(2, 2))
  691.   {
  692.     DecodeAdr(&ArgStr[2], MModAccA + MModAccB + MModReg);
  693.     switch (AdrType)
  694.     {
  695.       case ModAccA:
  696.         DecodeAdr(&ArgStr[1], MModAbs + MModIReg + MModBRel + MModRegRel + MModSPRel + MModAccB + MModReg + MModImm);
  697.         switch (AdrType)
  698.         {
  699.           case ModAbs:
  700.             BAsmCode[0] = 0x8d;
  701.             memcpy(BAsmCode + 1, AdrVals, 2);
  702.             CodeLen = 3;
  703.             break;
  704.           case ModIReg:
  705.             BAsmCode[0] = 0x9d;
  706.             BAsmCode[1] = AdrVals[0];
  707.             CodeLen = 2;
  708.             break;
  709.           case ModBRel:
  710.             BAsmCode[0] = 0xad;
  711.             memcpy(BAsmCode + 1, AdrVals, 2);
  712.             CodeLen = 3;
  713.             break;
  714.           case ModRegRel:
  715.             BAsmCode[0] = 0xf4;
  716.             BAsmCode[1] = 0xed;
  717.             memcpy(BAsmCode + 2, AdrVals, 2);
  718.             CodeLen = 4;
  719.             break;
  720.           case ModSPRel:
  721.             BAsmCode[0] = 0xf3;
  722.             BAsmCode[1] = AdrVals[0];
  723.             CodeLen = 2;
  724.             break;
  725.           case ModAccB:
  726.             BAsmCode[0] = 0x6d;
  727.             CodeLen = 1;
  728.             break;
  729.           case ModReg:
  730.             BAsmCode[0] = 0x1d;
  731.             BAsmCode[1] = AdrVals[0];
  732.             CodeLen = 2;
  733.             break;
  734.           case ModImm:
  735.             BAsmCode[0] = 0x2d;
  736.             BAsmCode[1] = AdrVals[0];
  737.             CodeLen = 2;
  738.             break;
  739.         }
  740.         break;
  741.       case ModAccB:
  742.         DecodeAdr(&ArgStr[1], MModReg + MModImm);
  743.         switch (AdrType)
  744.         {
  745.           case ModReg:
  746.             BAsmCode[0] = 0x3d;
  747.             BAsmCode[1] = AdrVals[0];
  748.             CodeLen = 2;
  749.             break;
  750.           case ModImm:
  751.             BAsmCode[0] = 0x5d;
  752.             BAsmCode[1] = AdrVals[0];
  753.             CodeLen = 2;
  754.             break;
  755.         }
  756.         break;
  757.       case ModReg:
  758.         BAsmCode[2] = AdrVals[0];
  759.         DecodeAdr(&ArgStr[1], MModReg + MModImm);
  760.         switch (AdrType)
  761.         {
  762.           case ModReg:
  763.             BAsmCode[0] = 0x4d;
  764.             BAsmCode[1] = AdrVals[0];
  765.             CodeLen = 3;
  766.             break;
  767.           case ModImm:
  768.             BAsmCode[0] = 0x7d;
  769.             BAsmCode[1] = AdrVals[0];
  770.             CodeLen = 3;
  771.             break;
  772.         }
  773.         break;
  774.     }
  775.   }
  776. }
  777.  
  778. static void DecodeALU1(Word Code)
  779. {
  780.   if (ChkArgCnt(2, 2))
  781.   {
  782.     DecodeAdr(&ArgStr[2], MModAccA + MModAccB + MModReg);
  783.     switch (AdrType)
  784.     {
  785.       case ModAccA:
  786.         DecodeAdr(&ArgStr[1], MModAccB + MModReg + MModImm);
  787.         switch (AdrType)
  788.         {
  789.           case ModAccB:
  790.             CodeLen = 1;
  791.             BAsmCode[0] = 0x60 + Code;
  792.             break;
  793.           case ModReg:
  794.             CodeLen = 2;
  795.             BAsmCode[0] = 0x10 + Code;
  796.             BAsmCode[1] = AdrVals[0];
  797.             break;
  798.           case ModImm:
  799.             CodeLen = 2;
  800.             BAsmCode[0] = 0x20 + Code;
  801.             BAsmCode[1] = AdrVals[0];
  802.             break;
  803.         }
  804.         break;
  805.       case ModAccB:
  806.         DecodeAdr(&ArgStr[1], MModReg + MModImm);
  807.         switch (AdrType)
  808.         {
  809.           case ModReg:
  810.             CodeLen = 2;
  811.             BAsmCode[0] = 0x30 + Code;
  812.             BAsmCode[1] = AdrVals[0];
  813.             break;
  814.           case ModImm:
  815.             CodeLen = 2;
  816.             BAsmCode[0] = 0x50 + Code;
  817.             BAsmCode[1] = AdrVals[0];
  818.             break;
  819.         }
  820.         break;
  821.       case ModReg:
  822.         BAsmCode[2] = AdrVals[0];
  823.         DecodeAdr(&ArgStr[1], MModReg + MModImm);
  824.         switch (AdrType)
  825.         {
  826.           case ModReg:
  827.             CodeLen = 3;
  828.             BAsmCode[0] = 0x40 + Code;
  829.             BAsmCode[1] = AdrVals[0];
  830.             break;
  831.           case ModImm:
  832.             CodeLen = 3;
  833.             BAsmCode[0] = 0x70 + Code;
  834.             BAsmCode[1] = AdrVals[0];
  835.             break;
  836.         }
  837.         break;
  838.     }
  839.   }
  840. }
  841.  
  842. static void DecodeALU2(Word Code)
  843. {
  844.   Boolean Rela = Hi(Code) != 0;
  845.   Code &= 0xff;
  846.  
  847.   if (ChkArgCnt(Rela ? 3 : 2, Rela ? 3 : 2))
  848.   {
  849.     DecodeAdr(&ArgStr[2], MModAccA + MModAccB + MModReg + MModPort);
  850.     switch (AdrType)
  851.     {
  852.       case ModAccA:
  853.         DecodeAdr(&ArgStr[1], MModAccB + MModReg + MModImm);
  854.         switch (AdrType)
  855.         {
  856.           case ModAccB:
  857.             BAsmCode[0] = 0x60 + Code;
  858.             CodeLen = 1;
  859.             break;
  860.           case ModReg:
  861.             BAsmCode[0] = 0x10 + Code;
  862.             BAsmCode[1] = AdrVals[0];
  863.             CodeLen = 2;
  864.             break;
  865.           case ModImm:
  866.             BAsmCode[0] = 0x20 + Code;
  867.             BAsmCode[1] = AdrVals[0];
  868.             CodeLen = 2;
  869.             break;
  870.         }
  871.         break;
  872.       case ModAccB:
  873.         DecodeAdr(&ArgStr[1], MModReg + MModImm);
  874.         switch (AdrType)
  875.         {
  876.           case ModReg:
  877.             BAsmCode[0] = 0x30 + Code;
  878.             BAsmCode[1] = AdrVals[0];
  879.             CodeLen = 2;
  880.             break;
  881.           case ModImm:
  882.             BAsmCode[0] = 0x50 + Code;
  883.             BAsmCode[1] = AdrVals[0];
  884.             CodeLen = 2;
  885.             break;
  886.         }
  887.         break;
  888.       case ModReg:
  889.         BAsmCode[2] = AdrVals[0];
  890.         DecodeAdr(&ArgStr[1], MModReg + MModImm);
  891.         switch (AdrType)
  892.         {
  893.           case ModReg:
  894.             BAsmCode[0] = 0x40 + Code;
  895.             BAsmCode[1] = AdrVals[0];
  896.             CodeLen = 3;
  897.             break;
  898.           case ModImm:
  899.             BAsmCode[0] = 0x70 + Code;
  900.             BAsmCode[1] = AdrVals[0];
  901.             CodeLen = 3;
  902.             break;
  903.         }
  904.         break;
  905.       case ModPort:
  906.         BAsmCode[1] = AdrVals[0];
  907.         DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModImm);
  908.         switch (AdrType)
  909.         {
  910.           case ModAccA:
  911.             BAsmCode[0] = 0x80 + Code;
  912.             CodeLen = 2;
  913.             break;
  914.           case ModAccB:
  915.             BAsmCode[0] = 0x90 + Code;
  916.             CodeLen = 2;
  917.             break;
  918.           case ModImm:
  919.             BAsmCode[0] = 0xa0 + Code;
  920.             BAsmCode[2] = BAsmCode[1];
  921.             BAsmCode[1] = AdrVals[0];
  922.             CodeLen = 3;
  923.             break;
  924.         }
  925.         break;
  926.     }
  927.     if ((CodeLen != 0) && (Rela))
  928.     {
  929.       Boolean OK;
  930.       tSymbolFlags Flags;
  931.       Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[3], UInt16, &OK, &Flags) - (EProgCounter() + CodeLen + 1);
  932.  
  933.       if (!OK)
  934.         CodeLen = 0;
  935.       else if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) || (AdrInt < -128)))
  936.       {
  937.         WrError(ErrNum_JmpDistTooBig);
  938.         CodeLen = 0;
  939.       }
  940.       else
  941.         BAsmCode[CodeLen++] = AdrInt & 0xff;
  942.     }
  943.   }
  944. }
  945.  
  946. static void DecodeJmp(Word Code)
  947. {
  948.   Boolean AddrRel = Hi(Code) != 0;
  949.   Code &= 0xff;
  950.  
  951.   if (ChkArgCnt(1, 1))
  952.   {
  953.     DecodeAdrRel(&ArgStr[1], MModAbs + MModIReg + MModBRel + MModRegRel, AddrRel);
  954.     switch (AdrType)
  955.     {
  956.       case ModAbs:
  957.         CodeLen = 3;
  958.         BAsmCode[0] = 0x80 + Code;
  959.         memcpy(BAsmCode + 1, AdrVals, 2);
  960.         break;
  961.       case ModIReg:
  962.         CodeLen = 2;
  963.         BAsmCode[0] = 0x90 + Code;
  964.         BAsmCode[1] = AdrVals[0];
  965.         break;
  966.       case ModBRel:
  967.         CodeLen = 3;
  968.         BAsmCode[0] = 0xa0 + Code;
  969.         memcpy(BAsmCode + 1, AdrVals, 2);
  970.         break;
  971.       case ModRegRel:
  972.         CodeLen = 4;
  973.         BAsmCode[0] = 0xf4;
  974.         BAsmCode[1] = 0xe0 + Code;
  975.         memcpy(BAsmCode + 2, AdrVals, 2);
  976.         break;
  977.     }
  978.   }
  979. }
  980.  
  981. static void DecodeABReg(Word Code)
  982. {
  983.   int IsDJNZ = Hi(Code) & 1;
  984.   Boolean IsStack = (Code & 0x200) || False;
  985.  
  986.   Code &= 0xff;
  987.  
  988.   if (!ChkArgCnt(1 + IsDJNZ, 1 + IsDJNZ));
  989.   else if (!as_strcasecmp(ArgStr[1].str.p_str, "ST"))
  990.   {
  991.     if (IsStack)
  992.     {
  993.       BAsmCode[0] = 0xf3 + Code;
  994.       CodeLen = 1;
  995.     }
  996.     else
  997.       WrError(ErrNum_InvAddrMode);
  998.   }
  999.   else
  1000.   {
  1001.     DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModReg);
  1002.     switch (AdrType)
  1003.     {
  1004.       case ModAccA:
  1005.         BAsmCode[0] = 0xb0 + Code;
  1006.         CodeLen = 1;
  1007.         break;
  1008.       case ModAccB:
  1009.         BAsmCode[0] = 0xc0 + Code;
  1010.         CodeLen = 1;
  1011.         break;
  1012.       case ModReg:
  1013.         BAsmCode[0] = 0xd0 + Code;
  1014.         BAsmCode[CodeLen + 1] = AdrVals[0];
  1015.         CodeLen = 2;
  1016.         break;
  1017.     }
  1018.     if ((IsDJNZ) && (CodeLen != 0))
  1019.     {
  1020.       Boolean OK;
  1021.       tSymbolFlags Flags;
  1022.       Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[2], Int16, &OK, &Flags) - (EProgCounter() + CodeLen + 1);
  1023.  
  1024.       if (!OK)
  1025.         CodeLen = 0;
  1026.       else if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) || (AdrInt < -128)))
  1027.       {
  1028.         WrError(ErrNum_JmpDistTooBig);
  1029.         CodeLen = 0;
  1030.       }
  1031.       else
  1032.         BAsmCode[CodeLen++] = AdrInt & 0xff;
  1033.     }
  1034.   }
  1035. }
  1036.  
  1037. static void DecodeBit(Word Code)
  1038. {
  1039.   int Rela = Hi(Code);
  1040.   LongWord BitExpr;
  1041.  
  1042.   Code &= 0xff;
  1043.  
  1044.   if (ChkArgCnt(1 + Rela, 2 + Rela)
  1045.    && DecodeBitExpr(1, ArgCnt - Rela, &BitExpr))
  1046.   {
  1047.     Boolean OK;
  1048.     Word Addr;
  1049.     Byte Bit;
  1050.  
  1051.     DissectBitValue(BitExpr, &Addr, &Bit);
  1052.  
  1053.     BAsmCode[1] = 1 << Bit;
  1054.     BAsmCode[2] = Lo(Addr);
  1055.     switch (Hi(Addr))
  1056.     {
  1057.       case 0x00:
  1058.         BAsmCode[0] = 0x70 + Code;
  1059.         CodeLen = 3;
  1060.         break;
  1061.       case 0x10:
  1062.         BAsmCode[0] = 0xa0 + Code;
  1063.         CodeLen = 3;
  1064.         break;
  1065.       default:
  1066.         WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[ArgCnt - 1]);
  1067.     }
  1068.     if ((CodeLen != 0) && Rela)
  1069.     {
  1070.       tSymbolFlags Flags;
  1071.       Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[ArgCnt], Int16, &OK, &Flags) - (EProgCounter() + CodeLen + 1);
  1072.  
  1073.       if (!OK)
  1074.         CodeLen = 0;
  1075.       else if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) || (AdrInt < -128)))
  1076.       {
  1077.         WrError(ErrNum_JmpDistTooBig);
  1078.         CodeLen = 0;
  1079.       }
  1080.       else
  1081.         BAsmCode[CodeLen++] = AdrInt & 0xff;
  1082.     }
  1083.   }
  1084. }
  1085.  
  1086. static void DecodeDIV(Word Code)
  1087. {
  1088.   UNUSED(Code);
  1089.  
  1090.   if (ChkArgCnt(2, 2))
  1091.   {
  1092.     DecodeAdr(&ArgStr[2], MModAccA);
  1093.     if (AdrType != ModNone)
  1094.     {
  1095.       DecodeAdr(&ArgStr[1], MModReg);
  1096.       if (AdrType != ModNone)
  1097.       {
  1098.         BAsmCode[0] = 0xf4;
  1099.         BAsmCode[1] = 0xf8;
  1100.         BAsmCode[2] = AdrVals[0];
  1101.         CodeLen = 3;
  1102.       }
  1103.     }
  1104.   }
  1105. }
  1106.  
  1107. static void DecodeINCW(Word Code)
  1108. {
  1109.   UNUSED(Code);
  1110.  
  1111.   if (ChkArgCnt(2, 2))
  1112.   {
  1113.     DecodeAdr(&ArgStr[2], MModReg);
  1114.     if (AdrType != ModNone)
  1115.     {
  1116.       BAsmCode[2] = AdrVals[0];
  1117.       DecodeAdr(&ArgStr[1], MModImm);
  1118.       if (AdrType != ModNone)
  1119.       {
  1120.         BAsmCode[0] = 0x70;
  1121.         BAsmCode[1] = AdrVals[0];
  1122.         CodeLen = 3;
  1123.       }
  1124.     }
  1125.   }
  1126. }
  1127.  
  1128. static void DecodeLDST(Word Code)
  1129. {
  1130.   UNUSED(Code);
  1131.  
  1132.   if (ChkArgCnt(1, 1))
  1133.   {
  1134.     DecodeAdr(&ArgStr[1], MModImm);
  1135.     if (AdrType != ModNone)
  1136.     {
  1137.       BAsmCode[0] = 0xf0;
  1138.       BAsmCode[1] = AdrVals[0];
  1139.       CodeLen = 2;
  1140.     }
  1141.   }
  1142. }
  1143.  
  1144. static void DecodeTRAP(Word Code)
  1145. {
  1146.   UNUSED(Code);
  1147.  
  1148.   if (ChkArgCnt(1, 1))
  1149.   {
  1150.     Boolean OK;
  1151.  
  1152.     BAsmCode[0] = EvalStrIntExpression(&ArgStr[1], Int4, &OK);
  1153.     if (OK)
  1154.     {
  1155.       BAsmCode[0] = 0xef - BAsmCode[0];
  1156.       CodeLen = 1;
  1157.     }
  1158.   }
  1159. }
  1160.  
  1161. static void DecodeTST(Word Code)
  1162. {
  1163.   UNUSED(Code);
  1164.  
  1165.   if (ChkArgCnt(1, 1))
  1166.   {
  1167.     DecodeAdr(&ArgStr[1], MModAccA + MModAccB);
  1168.     switch (AdrType)
  1169.     {
  1170.       case ModAccA:
  1171.         BAsmCode[0] = 0xb0;
  1172.         CodeLen = 1;
  1173.         break;
  1174.       case ModAccB:
  1175.         BAsmCode[0] = 0xc6;
  1176.         CodeLen = 1;
  1177.         break;
  1178.     }
  1179.   }
  1180. }
  1181.  
  1182. /****************************************************************************/
  1183.  
  1184. static void InitFixed(const char *NName, Word NCode)
  1185. {
  1186.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  1187. }
  1188.  
  1189. static void InitRel8(const char *NName, Word NCode)
  1190. {
  1191.   AddInstTable(InstTable, NName, NCode, DecodeRel8);
  1192. }
  1193.  
  1194. static void InitALU1(const char *NName, Word NCode)
  1195. {
  1196.   AddInstTable(InstTable, NName, NCode, DecodeALU1);
  1197. }
  1198.  
  1199. static void InitALU2(const char *NName, Word NCode)
  1200. {
  1201.   AddInstTable(InstTable, NName, NCode, DecodeALU2);
  1202. }
  1203.  
  1204. static void InitJmp(const char *NName, Word NCode)
  1205. {
  1206.   AddInstTable(InstTable, NName, NCode, DecodeJmp);
  1207. }
  1208.  
  1209. static void InitABReg(const char *NName, Word NCode)
  1210. {
  1211.   AddInstTable(InstTable, NName, NCode, DecodeABReg);
  1212. }
  1213.  
  1214. static void InitBit(const char *NName, Word NCode)
  1215. {
  1216.   AddInstTable(InstTable, NName, NCode, DecodeBit);
  1217. }
  1218.  
  1219. static void InitFields(void)
  1220. {
  1221.   InstTable = CreateInstTable(203);
  1222.   AddInstTable(InstTable, "MOV", 0, DecodeMOV);
  1223.   AddInstTable(InstTable, "MOVW", 0, DecodeMOVW);
  1224.   AddInstTable(InstTable, "CMP", 0, DecodeCMP);
  1225.   AddInstTable(InstTable, "DIV", 0, DecodeDIV);
  1226.   AddInstTable(InstTable, "INCW", 0, DecodeINCW);
  1227.   AddInstTable(InstTable, "LDST", 0, DecodeLDST);
  1228.   AddInstTable(InstTable, "TRAP", 0, DecodeTRAP);
  1229.   AddInstTable(InstTable, "TST", 0, DecodeTST);
  1230.   AddInstTable(InstTable, "DBIT", 0, DecodeDBIT);
  1231.  
  1232.   InitFixed("CLRC" , 0x00b0); InitFixed("DINT" , 0xf000);
  1233.   InitFixed("EINT" , 0xf00c); InitFixed("EINTH", 0xf004);
  1234.   InitFixed("EINTL", 0xf008); InitFixed("IDLE" , 0x00f6);
  1235.   InitFixed("LDSP" , 0x00fd); InitFixed("NOP"  , 0x00ff);
  1236.   InitFixed("RTI"  , 0x00fa); InitFixed("RTS"  , 0x00f9);
  1237.   InitFixed("SETC" , 0x00f8); InitFixed("STSP" , 0x00fe);
  1238.  
  1239.   InitRel8("JMP", 0x00); InitRel8("JC" , 0x03); InitRel8("JEQ", 0x02);
  1240.   InitRel8("JG" , 0x0e); InitRel8("JGE", 0x0d); InitRel8("JHS", 0x0b);
  1241.   InitRel8("JL" , 0x09); InitRel8("JLE", 0x0a); InitRel8("JLO", 0x0f);
  1242.   InitRel8("JN" , 0x01); InitRel8("JNC", 0x07); InitRel8("JNE", 0x06);
  1243.   InitRel8("JNV", 0x0c); InitRel8("JNZ", 0x06); InitRel8("JP" , 0x04);
  1244.   InitRel8("JPZ", 0x05); InitRel8("JV" , 0x08); InitRel8("JZ" , 0x02);
  1245.  
  1246.   InitALU1("ADC",  9); InitALU1("ADD",  8);
  1247.   InitALU1("DAC", 14); InitALU1("DSB", 15);
  1248.   InitALU1("SBB", 11); InitALU1("SUB", 10); InitALU1("MPY", 12);
  1249.  
  1250.   InitALU2("AND" ,  3); InitALU2("BTJO",  0x0106);
  1251.   InitALU2("BTJZ",  0x0107); InitALU2("OR"  ,  4); InitALU2("XOR",  5);
  1252.  
  1253.   InitJmp("BR"  , 12); InitJmp("CALL" , 14);
  1254.   InitJmp("JMPL", 0x0109); InitJmp("CALLR", 0x010f);
  1255.  
  1256.   InitABReg("CLR"  ,  5); InitABReg("COMPL", 11); InitABReg("DEC"  ,  2);
  1257.   InitABReg("INC"  ,  3); InitABReg("INV"  ,  4); InitABReg("POP"  , 0x0209);
  1258.   InitABReg("PUSH" , 0x0208); InitABReg("RL"   , 14); InitABReg("RLC"  , 15);
  1259.   InitABReg("RR"   , 12); InitABReg("RRC"  , 13); InitABReg("SWAP" ,  7);
  1260.   InitABReg("XCHB" ,  6); InitABReg("DJNZ" , 0x010a);
  1261.  
  1262.   InitBit("CMPBIT",  5); InitBit("JBIT0" ,  0x0107); InitBit("JBIT1" ,  0x0106);
  1263.   InitBit("SBIT0" ,  3); InitBit("SBIT1" ,  4);
  1264. }
  1265.  
  1266. static void DeinitFields(void)
  1267. {
  1268.   DestroyInstTable(InstTable);
  1269. }
  1270.  
  1271. /****************************************************************************/
  1272.  
  1273. static void MakeCode_370(void)
  1274. {
  1275.   CodeLen = 0;
  1276.   DontPrint = False;
  1277.   OpSize = 0;
  1278.  
  1279.   /* zu ignorierendes */
  1280.  
  1281.   if (Memo(""))
  1282.     return;
  1283.  
  1284.   /* Pseudoanweisungen */
  1285.  
  1286.   if (DecodeIntelPseudo(True))
  1287.     return;
  1288.  
  1289.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  1290.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  1291. }
  1292.  
  1293. static Boolean IsDef_370(void)
  1294. {
  1295.   return (Memo("DBIT"));
  1296. }
  1297.  
  1298. static void InternSymbol_370(char *Asc,  TempResult *Erg)
  1299. {
  1300.   Boolean OK;
  1301.   String h;
  1302.   LargeInt Num;
  1303.  
  1304.   as_tempres_set_none(Erg);
  1305.   if ((strlen(Asc) < 2) || ((as_toupper(*Asc) != 'R') && (as_toupper(*Asc) != 'P')))
  1306.     return;
  1307.  
  1308.   strcpy(h, Asc + 1);
  1309.   if ((*h == '0') && (strlen(h) > 1))
  1310.     *h = '$';
  1311.   Num = ConstLongInt(h, &OK, 10);
  1312.   if (!OK || (Num < 0) || (Num > 255))
  1313.     return;
  1314.  
  1315.   if (as_toupper(*Asc) == 'P')
  1316.     Num += 0x1000;
  1317.   as_tempres_set_int(Erg, Num);
  1318. }
  1319.  
  1320. static void SwitchFrom_370(void)
  1321. {
  1322.   DeinitFields();
  1323. }
  1324.  
  1325. static void SwitchTo_370(void)
  1326. {
  1327.   TurnWords = False;
  1328.   SetIntConstMode(eIntConstModeIntel);
  1329.  
  1330.   PCSymbol = "$";
  1331.   HeaderID = 0x49;
  1332.   NOPCode = 0xff;
  1333.   DivideChars = ",";
  1334.   HasAttrs = False;
  1335.  
  1336.   ValidSegs = 1 << SegCode;
  1337.   Grans[SegCode ] = 1;
  1338.   ListGrans[SegCode ] = 1;
  1339.   SegInits[SegCode ] = 0;
  1340.   SegLimits[SegCode] = 0xffff;
  1341.  
  1342.   MakeCode = MakeCode_370;
  1343.   IsDef = IsDef_370;
  1344.   SwitchFrom = SwitchFrom_370;
  1345.   InternSymbol = InternSymbol_370;
  1346.   DissectBit = DissectBit_370;
  1347.  
  1348.   InitFields();
  1349. }
  1350.  
  1351. void code370_init(void)
  1352. {
  1353.   CPU37010 = AddCPU("370C010" , SwitchTo_370);
  1354.   CPU37020 = AddCPU("370C020" , SwitchTo_370);
  1355.   CPU37030 = AddCPU("370C030" , SwitchTo_370);
  1356.   CPU37040 = AddCPU("370C040" , SwitchTo_370);
  1357.   CPU37050 = AddCPU("370C050" , SwitchTo_370);
  1358. }
  1359.