Subversion Repositories pentevo

Rev

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

  1. /* code77230.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* Makroassembler AS                                                         */
  6. /*                                                                           */
  7. /* Codegenerator NEC uPD77230                                                */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. /*---------------------------------------------------------------------------*/
  12. /* Includes */
  13.  
  14. #include "stdinc.h"
  15. #include <string.h>
  16. #include <ctype.h>
  17.  
  18. #include "strutil.h"
  19. #include "nls.h"
  20. #include "be_le.h"
  21. #include "ieeefloat.h"
  22. #include "bpemu.h"
  23.  
  24. #include "asmdef.h"
  25. #include "asmsub.h"
  26. #include "asmpars.h"
  27. #include "asmitree.h"
  28. #include "headids.h"
  29. #include "codevars.h"
  30. #include "codepseudo.h"
  31. #include "onoff_common.h"
  32. #include "errmsg.h"
  33. #include "chartrans.h"
  34.  
  35. #include "code77230.h"
  36.  
  37. /*---------------------------------------------------------------------------*/
  38. /* Definitionen */
  39.  
  40. #define CaseCnt 17
  41.  
  42. typedef struct
  43. {
  44.   LongWord Code;
  45. } FixedOrder;
  46.  
  47. typedef struct
  48. {
  49.   const char *Name;
  50.   LongWord Code;
  51. } Register;
  52.  
  53. enum
  54. {
  55.   InstrLDI, InstrBranch,
  56.   InstrALU, InstrMove,
  57.   InstrM0, InstrM1, InstrDP0, InstrDP1,
  58.   InstrEA, InstrRP, InstrFC, InstrLC,
  59.   InstrBASE0, InstrBASE1, InstrRPC,
  60.   InstrP2, InstrP3, InstrEM, InstrBM,
  61.   InstrL, InstrRW, InstrWT, InstrNF, InstrWI,
  62.   InstrFIS, InstrFD, InstrSHV, InstrRPS, InstrNAL, InstrCnt
  63. };
  64.  
  65. static LongWord CaseMasks[CaseCnt] =
  66. {
  67.   (1l << InstrLDI),
  68.   (1l << InstrBranch) | (1l << InstrMove),
  69.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrM0) | (1l << InstrM1) | (1l << InstrDP0) | (1l << InstrDP1),
  70.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrEA) | (1l << InstrDP0) | (1l << InstrDP1),
  71.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrRP) | (1l << InstrM0) | (1l << InstrDP0) | (1l << InstrFC),
  72.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrRP) | (1l << InstrM1) | (1l << InstrDP1) | (1l << InstrFC),
  73.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrRP) | (1l << InstrM0) | (1l << InstrM1) | (1l << InstrL) | (1l << InstrFC),
  74.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrBASE0) | (1l << InstrBASE1) | (1l << InstrFC),
  75.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrRPC) | (1l << InstrL) | (1l << InstrFC),
  76.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrP3) | (1l << InstrP2) | (1l << InstrEM) | (1l << InstrBM) | (1l << InstrL) | (1l << InstrFC),
  77.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrRW) | (1l << InstrL) | (1l << InstrFC),
  78.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrWT) | (1l << InstrL) | (1l << InstrFC),
  79.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrNF) | (1l << InstrWI) | (1l << InstrL) | (1l << InstrFC),
  80.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrFIS) | (1l << InstrFD) | (1l << InstrL),
  81.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrSHV),
  82.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrRPS),
  83.   (1l << InstrALU) | (1l << InstrMove) | (1l << InstrNAL)
  84. };
  85.  
  86. static CPUVar CPU77230;
  87. static LongWord InstrMask;
  88. static Boolean Error;
  89. static LongWord *InstrComps, *InstrDefs;
  90.  
  91. static Register *SrcRegs, *ALUSrcRegs, *DestRegs;
  92. static FixedOrder *JmpOrders, *ALU1Orders, *ALU2Orders;
  93.  
  94. /*---------------------------------------------------------------------------*/
  95. /* Hilfsroutinen */
  96.  
  97. static int DiscCnt, SplittedArg;
  98. static char *DiscPtr;
  99.  
  100. static Boolean SplitArgs(int Count)
  101. {
  102.   char *p, *p1, *p2;
  103.  
  104.   SplittedArg = DiscCnt = Count;
  105.  
  106.   if (Count == 0)
  107.   {
  108.     if (ArgCnt > 0)
  109.     {
  110.       DiscPtr = ArgStr[1].str.p_str - 1;
  111.       SplittedArg = 1;
  112.     }
  113.     else
  114.       DiscPtr = NULL;
  115.     return True;
  116.   }
  117.  
  118.   if (!ChkArgCnt(Count, ArgCntMax))
  119.   {
  120.     Error = True;
  121.     return False;
  122.   }
  123.  
  124.   for (p = ArgStr[SplittedArg].str.p_str; isspace(((usint)*p) & 0xff); p++);
  125.   p1 = QuotPos(p, ' ');
  126.   p2 = QuotPos(p, '\t');
  127.   DiscPtr = ((!p1) || ((p2) && (p2 < p1))) ? p2 : p1;
  128.   if (DiscPtr)
  129.     *(DiscPtr) = '\0';
  130.  
  131.   return True;
  132. }
  133.  
  134. static void DiscardArgs(void)
  135. {
  136.   char *p, *p2;
  137.   int z;
  138.   Boolean Eaten;
  139.  
  140.   if (DiscPtr)
  141.   {
  142.     for (p = DiscPtr + 1; as_isspace(*p); p++)
  143.       if (*p == '\0') break;
  144.     for (p2 = p; !as_isspace(*p2); p2++)
  145.       if (*p2 == '\0') break;
  146.     Eaten = (*p2 == '\0');
  147.     *p2 = '\0';
  148.     strmov(OpPart.str.p_str, p);
  149.     NLS_UpString(OpPart.str.p_str);
  150.     if (Eaten)
  151.     {
  152.       for (z = 1; z < ArgCnt; z++)
  153.         strmov(ArgStr[z].str.p_str, ArgStr[z + 1].str.p_str);
  154.       ArgCnt--;
  155.     }
  156.     else
  157.     {
  158.       if (p2)
  159.         for (p2++; as_isspace(*p2); p2++);
  160.       strmov(ArgStr[SplittedArg].str.p_str, p2);
  161.     }
  162.   }
  163.   else
  164.     *OpPart.str.p_str = '\0';
  165.   if (DiscCnt > 0)
  166.   {
  167.     for (z = 0; z <= ArgCnt - DiscCnt; z++)
  168.       strmov(ArgStr[z + 1].str.p_str, ArgStr[z + DiscCnt].str.p_str);
  169.     ArgCnt -= DiscCnt - 1;
  170.   }
  171. }
  172.  
  173. static void AddComp(int Index, LongWord Value)
  174. {
  175.   if ((InstrMask & (1l << Index)) != 0)
  176.   {
  177.     WrError(ErrNum_InvParAddrMode);
  178.     Error = True;
  179.   }
  180.   else
  181.   {
  182.     InstrMask |= (1l << Index);
  183.     InstrComps[Index] = Value;
  184.   }
  185. }
  186.  
  187. static Boolean DecodeReg(char *Asc, LongWord *Erg, Register *Regs)
  188. {
  189.   int z;
  190.  
  191.   for (z = 0; Regs[z].Name; z++)
  192.     if (!as_strcasecmp(Asc, Regs[z].Name))
  193.     {
  194.       *Erg = Regs[z].Code;
  195.       return True;
  196.     }
  197.   *Erg = 0;
  198.   return False;
  199. }
  200.  
  201. /*---------------------------------------------------------------------------*/
  202. /* Dekoder fuer Routinen */
  203.  
  204. static void DecodeJmp(Word Index)
  205. {
  206.   FixedOrder *Op = JmpOrders + Index;
  207.   int acnt = Hi(Op->Code);
  208.   LongWord Adr;
  209.  
  210.   if (!SplitArgs(acnt))
  211.     return;
  212.   if (acnt == 0)
  213.   {
  214.     Adr = 0;
  215.     Error = True;
  216.   }
  217.   else
  218.     Adr = EvalStrIntExpression(&ArgStr[1], UInt13, &Error);
  219.   Error = !Error;
  220.   if (!Error)
  221.     AddComp(InstrBranch, Lo(Op->Code) + (Adr << 5));
  222.   DiscardArgs();
  223. }
  224.  
  225. static void DecodeMOV(Word Index)
  226. {
  227.   LongWord DReg, SReg;
  228.   UNUSED(Index);
  229.  
  230.   if (!SplitArgs(2))
  231.     return;
  232.   if (!DecodeReg(ArgStr[1].str.p_str, &DReg, DestRegs))
  233.   {
  234.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  235.     Error = True;
  236.   }
  237.   else if (!DecodeReg(ArgStr[2].str.p_str, &SReg, SrcRegs))
  238.   {
  239.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  240.     Error = True;
  241.   }
  242.   else
  243.     AddComp(InstrMove, (SReg << 5) + DReg);
  244.   DiscardArgs();
  245. }
  246.  
  247. static void DecodeLDI(Word Index)
  248. {
  249.   LongWord DReg, Src = 0;
  250.   UNUSED(Index);
  251.  
  252.   if (!SplitArgs(2))
  253.     return;
  254.   if (!DecodeReg(ArgStr[1].str.p_str, &DReg, DestRegs))
  255.   {
  256.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  257.     Error = True;
  258.   }
  259.   else
  260.     Src = EvalStrIntExpression(&ArgStr[2], Int24, &Error);
  261.   Error = !Error;
  262.   if (!Error)
  263.     AddComp(InstrLDI, (Src << 5) + DReg);
  264.   DiscardArgs();
  265. }
  266.  
  267. static void DecodeNOP(Word Index)
  268. {
  269.   UNUSED(Index);
  270.  
  271.   if (!SplitArgs(0))
  272.     return;
  273.   AddComp(InstrALU, 0);
  274.   DiscardArgs();
  275. }
  276.  
  277. static void DecodeALU1(Word Index)
  278. {
  279.   FixedOrder *Op = ALU1Orders + Index;
  280.   LongWord DReg;
  281.  
  282.   if (!SplitArgs(1))
  283.     return;
  284.   if ((!DecodeReg(ArgStr[1].str.p_str, &DReg, DestRegs))
  285.    || (DReg < 16) || (DReg > 23))
  286.   {
  287.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  288.     Error = True;
  289.   }
  290.   else
  291.     AddComp(InstrALU, (Op->Code << 17) + (DReg & 7));
  292.   DiscardArgs();
  293. }
  294.  
  295. static void DecodeALU2(Word Index)
  296. {
  297.   FixedOrder *Op = ALU2Orders + Index;
  298.   LongWord DReg, SReg;
  299.  
  300.   if (!SplitArgs(2)) return;
  301.   if ((!DecodeReg(ArgStr[1].str.p_str, &DReg, DestRegs))
  302.    || (DReg < 16) || (DReg > 23))
  303.   {
  304.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  305.     Error = True;
  306.   }
  307.   else if (!DecodeReg(ArgStr[2].str.p_str, &SReg, ALUSrcRegs))
  308.   {
  309.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  310.     Error = True;
  311.   }
  312.   else
  313.     AddComp(InstrALU, (Op->Code << 17) + (SReg << 3) + (DReg & 7));
  314.   DiscardArgs();
  315. }
  316.  
  317. static void DecodeM0(Word Index)
  318. {
  319.   if (!SplitArgs(0))
  320.     return;
  321.  
  322.   AddComp(InstrM0, Index);
  323.   DiscardArgs();
  324. }
  325.  
  326. static void DecodeM1(Word Index)
  327. {
  328.   if (!SplitArgs(0))
  329.     return;
  330.  
  331.   AddComp(InstrM1, Index);
  332.   DiscardArgs();
  333. }
  334.  
  335. static void DecodeDP0(Word Index)
  336. {
  337.   if (!SplitArgs(0))
  338.     return;
  339.  
  340.   AddComp(InstrDP0, Index);
  341.   DiscardArgs();
  342. }
  343.  
  344. static void DecodeDP1(Word Index)
  345. {
  346.   if (!SplitArgs(0))
  347.     return;
  348.  
  349.   AddComp(InstrDP1, Index);
  350.   DiscardArgs();
  351. }
  352.  
  353. static void DecodeEA(Word Index)
  354. {
  355.   if (!SplitArgs(0))
  356.     return;
  357.  
  358.   AddComp(InstrEA, Index);
  359.   DiscardArgs();
  360. }
  361.  
  362. static void DecodeFC(Word Index)
  363. {
  364.   if (!SplitArgs(0))
  365.     return;
  366.  
  367.   AddComp(InstrFC, Index);
  368.   DiscardArgs();
  369. }
  370.  
  371. static void DecodeRP(Word Index)
  372. {
  373.   if (!SplitArgs(0))
  374.     return;
  375.  
  376.   AddComp(InstrRP, Index);
  377.   DiscardArgs();
  378. }
  379.  
  380. static void DecodeL(Word Index)
  381. {
  382.   if (!SplitArgs(0))
  383.     return;
  384.  
  385.   AddComp(InstrL, Index);
  386.   DiscardArgs();
  387. }
  388.  
  389. static void DecodeBASE(Word Index)
  390. {
  391.   LongWord Value;
  392.  
  393.   if (!SplitArgs(1))
  394.     return;
  395.   Value = EvalStrIntExpression(&ArgStr[1], UInt3, &Error);
  396.   Error = !Error;
  397.   if (!Error)
  398.     AddComp(Index, Value);
  399.   DiscardArgs();
  400. }
  401.  
  402. static void DecodeRPC(Word Index)
  403. {
  404.   LongWord Value;
  405.   tSymbolFlags Flags;
  406.  
  407.   UNUSED(Index);
  408.  
  409.   if (!SplitArgs(1))
  410.     return;
  411.  
  412.   Value = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt4, &Error, &Flags);
  413.   if (mFirstPassUnknown(Flags))
  414.     Value &= 7;
  415.   Error = (Value > 9) ? True : !Error;
  416.   if (!Error)
  417.     AddComp(InstrRPC, Value);
  418.   DiscardArgs();
  419. }
  420.  
  421. static void DecodeP2(Word Index)
  422. {
  423.   if (!SplitArgs(0))
  424.     return;
  425.  
  426.   AddComp(InstrP2, Index);
  427.   DiscardArgs();
  428. }
  429.  
  430. static void DecodeP3(Word Index)
  431. {
  432.   if (!SplitArgs(0))
  433.     return;
  434.  
  435.   AddComp(InstrP3, Index);
  436.   DiscardArgs();
  437. }
  438.  
  439. static void DecodeBM(Word Index)
  440. {
  441.   /* Wenn EM-Feld schon da war, muss es EI gewesen sein */
  442.  
  443.   if (!SplitArgs(0))
  444.     return;
  445.  
  446.   if ((InstrMask & (1 << InstrEM)) != 0)
  447.   {
  448.     Error = (InstrComps[InstrEM] == 0);
  449.     if (Error) WrError(ErrNum_InvParAddrMode);
  450.     else
  451.       AddComp(InstrBM, Index);
  452.   }
  453.   else
  454.     AddComp(InstrBM, Index);
  455.   DiscardArgs();
  456. }
  457.  
  458. static void DecodeEM(Word Index)
  459. {
  460.   /* Wenn BM-Feld schon da war, muss es EI sein */
  461.  
  462.   if (!SplitArgs(0))
  463.     return;
  464.  
  465.   if ((InstrMask & (1 << InstrBM)) != 0)
  466.   {
  467.     Error = (Index == 0);
  468.     if (Error)
  469.       WrError(ErrNum_InvParAddrMode);
  470.     else
  471.       AddComp(InstrEM, Index);
  472.   }
  473.   else
  474.   {
  475.     AddComp(InstrEM, Index);
  476.     if (Index == 0)
  477.       InstrComps[InstrBM] = 3;
  478.   }
  479.   DiscardArgs();
  480. }
  481.  
  482. static void DecodeRW(Word Index)
  483. {
  484.   if (!SplitArgs(0))
  485.     return;
  486.  
  487.   AddComp(InstrRW, Index);
  488.   DiscardArgs();
  489. }
  490.  
  491. static void DecodeWT(Word Index)
  492. {
  493.   if (!SplitArgs(0))
  494.     return;
  495.  
  496.   AddComp(InstrWT, Index);
  497.   DiscardArgs();
  498. }
  499.  
  500. static void DecodeNF(Word Index)
  501. {
  502.   if (!SplitArgs(0))
  503.     return;
  504.  
  505.   AddComp(InstrNF, Index);
  506.   DiscardArgs();
  507. }
  508.  
  509. static void DecodeWI(Word Index)
  510. {
  511.   if (!SplitArgs(0))
  512.     return;
  513.  
  514.   AddComp(InstrWI, Index);
  515.   DiscardArgs();
  516. }
  517.  
  518. static void DecodeFIS(Word Index)
  519. {
  520.   if (!SplitArgs(0))
  521.     return;
  522.  
  523.   AddComp(InstrFIS, Index);
  524.   DiscardArgs();
  525. }
  526.  
  527. static void DecodeFD(Word Index)
  528. {
  529.   if (!SplitArgs(0))
  530.     return;
  531.  
  532.   AddComp(InstrFD, Index);
  533.   DiscardArgs();
  534. }
  535.  
  536. static void DecodeSHV(Word Index)
  537. {
  538.   LongWord Value;
  539.   tSymbolFlags Flags;
  540.  
  541.   if (!SplitArgs(1))
  542.     return;
  543.  
  544.   Value = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt6, &Error, &Flags);
  545.   if (mFirstPassUnknown(Flags))
  546.     Value &= 31;
  547.   Error = (Value > 46) ? True : !Error;
  548.   if (!Error)
  549.     AddComp(InstrSHV, (Index << 6) + Value);
  550.   DiscardArgs();
  551. }
  552.  
  553. static void DecodeRPS(Word Index)
  554. {
  555.   LongWord Value;
  556.   UNUSED(Index);
  557.  
  558.   if (!SplitArgs(1))
  559.     return;
  560.   Value = EvalStrIntExpression(&ArgStr[1], UInt9, &Error);
  561.   Error = !Error;
  562.   if (!Error)
  563.     AddComp(InstrRPS, Value);
  564.   DiscardArgs();
  565. }
  566.  
  567. static void DecodeNAL(Word Index)
  568. {
  569.   LongWord Value;
  570.   tSymbolFlags Flags;
  571.  
  572.   UNUSED(Index);
  573.  
  574.   if (!SplitArgs(1))
  575.     return;
  576.  
  577.   Value = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt13, &Error, &Flags);
  578.   Error = !Error;
  579.   if (!Error)
  580.   {
  581.     if (ChkSamePage(Value, EProgCounter(), 9, Flags))
  582.       AddComp(InstrNAL, Value & 0x1ff);
  583.   }
  584.   DiscardArgs();
  585. }
  586.  
  587. static Boolean DecodePseudo(void)
  588. {
  589.   LongWord temp;
  590.   LongInt sign, mant, expo, Size;
  591.  
  592.   if (Memo("DW"))
  593.   {
  594.     if (ChkArgCnt(1, ArgCntMax))
  595.     {
  596.       TempResult t;
  597.       Boolean OK = True;
  598.       tStrComp *pArg;
  599.  
  600.       as_tempres_ini(&t);
  601.       forallargs(pArg, OK)
  602.       {
  603.         EvalStrExpression(pArg, &t);
  604.         switch(t.Typ)
  605.         {
  606.           case TempString:
  607.             if (MultiCharToInt(&t, 4))
  608.               goto ToInt;
  609.  
  610.             if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &t.Contents.str, pArg))
  611.               OK = False;
  612.             else
  613.               OK = !string_2_dasm_code(&t.Contents.str, Packing ? 4 : 1, True);
  614.             break;
  615.           case TempInt:
  616.           ToInt:
  617.             if (!RangeCheck(t.Contents.Int, Int32))
  618.             {
  619.               WrStrErrorPos(ErrNum_OverRange, pArg);
  620.               OK = False;
  621.               break;
  622.             }
  623.             DAsmCode[CodeLen++] = t.Contents.Int;
  624.             break;
  625.           case TempFloat:
  626.             if (!FloatRangeCheck(t.Contents.Float, Float32))
  627.             {
  628.               WrStrErrorPos(ErrNum_OverRange, pArg);
  629.               OK = False;
  630.               break;
  631.             }
  632.             Double_2_ieee4(t.Contents.Float, (Byte*) &temp, HostBigEndian);
  633.             sign = (temp >> 31) & 1;
  634.             expo = (temp >> 23) & 255;
  635.             mant = temp & 0x7fffff;
  636.             if ((mant == 0) && (expo == 0))
  637.               DAsmCode[CodeLen++] = 0x80000000;
  638.             else
  639.             {
  640.               if (expo > 0)
  641.               {
  642.                 mant |= 0x800000;
  643.                 expo -= 127;
  644.               }
  645.               else
  646.                 expo -= 126;
  647.               if (mant >= 0x800000)
  648.               {
  649.                 mant = mant >> 1;
  650.                 expo += 1;
  651.               }
  652.               if (sign == 1)
  653.                 mant = ((mant ^ 0xffffff) + 1);
  654.               DAsmCode[CodeLen++] = ((expo & 0xff) << 24) | (mant & 0xffffff);
  655.             }
  656.             break;
  657.           default:
  658.             OK = False;
  659.         }
  660.       }
  661.       if (!OK)
  662.         CodeLen = 0;
  663.       as_tempres_free(&t);
  664.     }
  665.     return True;
  666.   }
  667.  
  668.   if (Memo("DS"))
  669.   {
  670.     if (ChkArgCnt(1, 1))
  671.     {
  672.       tSymbolFlags Flags;
  673.       Boolean OK;
  674.  
  675.       Size = EvalStrIntExpressionWithFlags(&ArgStr[1], Int16, &OK, &Flags);
  676.       if (mFirstPassUnknown(Flags))
  677.       {
  678.         WrError(ErrNum_FirstPassCalc);
  679.         OK = False;
  680.       }
  681.       if (OK)
  682.       {
  683.         DontPrint = True;
  684.         if (!Size)
  685.           WrError(ErrNum_NullResMem);
  686.         CodeLen = Size;
  687.         BookKeeping();
  688.       }
  689.     }
  690.     return True;
  691.   }
  692.  
  693.   return FALSE;
  694. }
  695.  
  696. /*---------------------------------------------------------------------------*/
  697. /* Codetabellenverwaltung */
  698.  
  699. static void AddJmp(const char *NName, LongWord NCode)
  700. {
  701.   order_array_rsv_end(JmpOrders, FixedOrder);
  702.   JmpOrders[InstrZ].Code = NCode;
  703.   AddInstTable(InstTable, NName, InstrZ++, DecodeJmp);
  704. }
  705.  
  706. static void AddALU1(const char *NName, LongWord NCode)
  707. {
  708.   order_array_rsv_end(ALU1Orders, FixedOrder);
  709.   ALU1Orders[InstrZ].Code = NCode;
  710.   AddInstTable(InstTable, NName, InstrZ++, DecodeALU1);
  711. }
  712.  
  713. static void AddALU2(const char *NName, LongWord NCode)
  714. {
  715.   order_array_rsv_end(ALU2Orders, FixedOrder);
  716.   ALU2Orders[InstrZ].Code = NCode;
  717.   AddInstTable(InstTable, NName, InstrZ++, DecodeALU2);
  718. }
  719.  
  720. static void AddSrcReg(const char *NName, LongWord NCode)
  721. {
  722.   order_array_rsv_end(SrcRegs, Register);
  723.   SrcRegs[InstrZ].Name = NName;
  724.   SrcRegs[InstrZ++].Code = NCode;
  725. }
  726.  
  727. static void AddALUSrcReg(const char *NName, LongWord NCode)
  728. {
  729.   order_array_rsv_end(ALUSrcRegs, Register);
  730.   ALUSrcRegs[InstrZ].Name = NName;
  731.   ALUSrcRegs[InstrZ++].Code = NCode;
  732. }
  733.  
  734. static void AddDestReg(const char *NName, LongWord NCode)
  735. {
  736.   order_array_rsv_end(DestRegs, Register);
  737.   DestRegs[InstrZ].Name = NName;
  738.   DestRegs[InstrZ++].Code = NCode;
  739. }
  740.  
  741. static void InitFields(void)
  742. {
  743.   InstTable = CreateInstTable(201);
  744.  
  745.   AddInstTable(InstTable, "MOV", 0, DecodeMOV);
  746.   AddInstTable(InstTable, "LDI", 0, DecodeLDI);
  747.   AddInstTable(InstTable, "NOP", 0, DecodeNOP);
  748.  
  749.   AddInstTable(InstTable, "SPCBP0", 1, DecodeM0);
  750.   AddInstTable(InstTable, "SPCIX0", 2, DecodeM0);
  751.   AddInstTable(InstTable, "SPCBI0", 3, DecodeM0);
  752.  
  753.   AddInstTable(InstTable, "SPCBP1", 1, DecodeM1);
  754.   AddInstTable(InstTable, "SPCIX1", 2, DecodeM1);
  755.   AddInstTable(InstTable, "SPCBI1", 3, DecodeM1);
  756.  
  757.   AddInstTable(InstTable, "INCBP0", 1, DecodeDP0);
  758.   AddInstTable(InstTable, "DECBP0", 2, DecodeDP0);
  759.   AddInstTable(InstTable, "CLRBP0", 3, DecodeDP0);
  760.   AddInstTable(InstTable, "STIX0" , 4, DecodeDP0);
  761.   AddInstTable(InstTable, "INCIX0", 5, DecodeDP0);
  762.   AddInstTable(InstTable, "DECIX0", 6, DecodeDP0);
  763.   AddInstTable(InstTable, "CLRIX0", 7, DecodeDP0);
  764.  
  765.   AddInstTable(InstTable, "INCBP1", 1, DecodeDP1);
  766.   AddInstTable(InstTable, "DECBP1", 2, DecodeDP1);
  767.   AddInstTable(InstTable, "CLRBP1", 3, DecodeDP1);
  768.   AddInstTable(InstTable, "STIX1" , 4, DecodeDP1);
  769.   AddInstTable(InstTable, "INCIX1", 5, DecodeDP1);
  770.   AddInstTable(InstTable, "DECIX1", 6, DecodeDP1);
  771.   AddInstTable(InstTable, "CLRIX1", 7, DecodeDP1);
  772.  
  773.   AddInstTable(InstTable, "INCAR" , 1, DecodeEA);
  774.   AddInstTable(InstTable, "DECAR" , 2, DecodeEA);
  775.  
  776.   AddInstTable(InstTable, "XCHPSW", 1, DecodeFC);
  777.  
  778.   AddInstTable(InstTable, "INCRP" , 1, DecodeRP);
  779.   AddInstTable(InstTable, "DECRP" , 2, DecodeRP);
  780.   AddInstTable(InstTable, "INCBRP", 3, DecodeRP);
  781.  
  782.   AddInstTable(InstTable, "DECLC" , 1, DecodeL);
  783.  
  784.   AddInstTable(InstTable, "MCNBP0", InstrBASE0, DecodeBASE);
  785.   AddInstTable(InstTable, "MCNBP1", InstrBASE1, DecodeBASE);
  786.  
  787.   AddInstTable(InstTable, "BITRP" , 0, DecodeRPC);
  788.  
  789.   AddInstTable(InstTable, "CLRP2" , 0, DecodeP2);
  790.   AddInstTable(InstTable, "SETP2" , 1, DecodeP2);
  791.  
  792.   AddInstTable(InstTable, "CLRP3" , 0, DecodeP3);
  793.   AddInstTable(InstTable, "SETP3" , 1, DecodeP3);
  794.  
  795.   AddInstTable(InstTable, "DI"    , 0, DecodeEM);
  796.   AddInstTable(InstTable, "EI"    , 1, DecodeEM);
  797.   AddInstTable(InstTable, "CLRBM" , 1, DecodeBM);
  798.   AddInstTable(InstTable, "SETBM" , 2, DecodeBM);
  799.  
  800.   AddInstTable(InstTable, "RD"    , 1, DecodeRW);
  801.   AddInstTable(InstTable, "WR"    , 2, DecodeRW);
  802.  
  803.   AddInstTable(InstTable, "WRBORD", 1, DecodeWT);
  804.   AddInstTable(InstTable, "WRBL24", 2, DecodeWT);
  805.   AddInstTable(InstTable, "WRBL23", 3, DecodeWT);
  806.   AddInstTable(InstTable, "WRBEL8", 4, DecodeWT);
  807.   AddInstTable(InstTable, "WRBL8E", 5, DecodeWT);
  808.   AddInstTable(InstTable, "WRBXCH", 6, DecodeWT);
  809.   AddInstTable(InstTable, "WRBBRV", 7, DecodeWT);
  810.  
  811.   AddInstTable(InstTable, "TRNORM", 2, DecodeNF);
  812.   AddInstTable(InstTable, "RDNORM", 4, DecodeNF);
  813.   AddInstTable(InstTable, "FLTFIX", 6, DecodeNF);
  814.   AddInstTable(InstTable, "FIXMA" , 7, DecodeNF);
  815.  
  816.   AddInstTable(InstTable, "BWRL24", 1, DecodeWI);
  817.   AddInstTable(InstTable, "BWRORD", 2, DecodeWI);
  818.  
  819.   AddInstTable(InstTable, "SPCPSW0", 1, DecodeFIS);
  820.   AddInstTable(InstTable, "SPCPSW1", 2, DecodeFIS);
  821.   AddInstTable(InstTable, "CLRPSW0", 4, DecodeFIS);
  822.   AddInstTable(InstTable, "CLRPSW1", 5, DecodeFIS);
  823.   AddInstTable(InstTable, "CLRPSW" , 6, DecodeFIS);
  824.  
  825.   AddInstTable(InstTable, "SPIE", 1, DecodeFD);
  826.   AddInstTable(InstTable, "IESP", 2, DecodeFD);
  827.  
  828.   AddInstTable(InstTable, "SETSVL", 0, DecodeSHV);
  829.   AddInstTable(InstTable, "SETSVR", 1, DecodeSHV);
  830.  
  831.   AddInstTable(InstTable, "SPCRA", 0, DecodeRPS);
  832.   AddInstTable(InstTable, "JBLK" , 0, DecodeNAL);
  833.  
  834.   InstrZ = 0;
  835.   AddJmp("JMP"   , 0x0100); AddJmp("CALL"  , 0x0101); AddJmp("RET"   , 0x0002);
  836.   AddJmp("JNZRP" , 0x0103); AddJmp("JZ0"   , 0x0104); AddJmp("JNZ0"  , 0x0105);
  837.   AddJmp("JZ1"   , 0x0106); AddJmp("JNZ1"  , 0x0107); AddJmp("JC0"   , 0x0108);
  838.   AddJmp("JNC0"  , 0x0109); AddJmp("JC1"   , 0x010a); AddJmp("JNC1"  , 0x010b);
  839.   AddJmp("JS0"   , 0x010c); AddJmp("JNS0"  , 0x010d); AddJmp("JS1"   , 0x010e);
  840.   AddJmp("JNS1"  , 0x010f); AddJmp("JV0"   , 0x0110); AddJmp("JNV0"  , 0x0111);
  841.   AddJmp("JV1"   , 0x0112); AddJmp("JNV1"  , 0x0113); AddJmp("JEV0"  , 0x0114);
  842.   AddJmp("JEV1"  , 0x0115); AddJmp("JNFSI" , 0x0116); AddJmp("JNESO" , 0x0117);
  843.   AddJmp("JIP0"  , 0x0118); AddJmp("JIP1"  , 0x0119); AddJmp("JNZIX0", 0x011a);
  844.   AddJmp("JNZIX1", 0x011b); AddJmp("JNZBP0", 0x011c); AddJmp("JNZBP1", 0x011d);
  845.   AddJmp("JRDY"  , 0x011e); AddJmp("JRQM"  , 0x011f);
  846.  
  847.   InstrZ = 0;
  848.   AddALU1("INC"  , 0x01); AddALU1("DEC"  , 0x02); AddALU1("ABS"  , 0x03);
  849.   AddALU1("NOT"  , 0x04); AddALU1("NEG"  , 0x05); AddALU1("SHLC" , 0x06);
  850.   AddALU1("SHRC" , 0x07); AddALU1("ROL"  , 0x08); AddALU1("ROR"  , 0x09);
  851.   AddALU1("SHLM" , 0x0a); AddALU1("SHRM" , 0x0b); AddALU1("SHRAM", 0x0c);
  852.   AddALU1("CLR"  , 0x0d); AddALU1("NORM" , 0x0e); AddALU1("CVT"  , 0x0f);
  853.  
  854.   InstrZ = 0;
  855.   AddALU2("ADD"  , 0x10); AddALU2("SUB"  , 0x11); AddALU2("ADDC" , 0x12);
  856.   AddALU2("SUBC" , 0x13); AddALU2("CMP"  , 0x14); AddALU2("AND"  , 0x15);
  857.   AddALU2("OR"   , 0x16); AddALU2("XOR"  , 0x17); AddALU2("ADDF" , 0x18);
  858.   AddALU2("SUBF" , 0x19);
  859.  
  860.   InstrZ = 0;
  861.   AddSrcReg("NON" , 0x00); AddSrcReg("RP"  , 0x01); AddSrcReg("PSW0" , 0x02);
  862.   AddSrcReg("PSW1", 0x03); AddSrcReg("SVR" , 0x04); AddSrcReg("SR"   , 0x05);
  863.   AddSrcReg("LC"  , 0x06); AddSrcReg("STX" , 0x07); AddSrcReg("M"    , 0x08);
  864.   AddSrcReg("ML"  , 0x09); AddSrcReg("ROM" , 0x0a); AddSrcReg("TR"   , 0x0b);
  865.   AddSrcReg("AR"  , 0x0c); AddSrcReg("SI"  , 0x0d); AddSrcReg("DR"   , 0x0e);
  866.   AddSrcReg("DRS" , 0x0f); AddSrcReg("WR0" , 0x10); AddSrcReg("WR1"  , 0x11);
  867.   AddSrcReg("WR2" , 0x12); AddSrcReg("WR3" , 0x13); AddSrcReg("WR4"  , 0x14);
  868.   AddSrcReg("WR5" , 0x15); AddSrcReg("WR6" , 0x16); AddSrcReg("WR7"  , 0x17);
  869.   AddSrcReg("RAM0", 0x18); AddSrcReg("RAM1", 0x19); AddSrcReg("BP0"  , 0x1a);
  870.   AddSrcReg("BP1" , 0x1b); AddSrcReg("IX0" , 0x1c); AddSrcReg("IX1"  , 0x1d);
  871.   AddSrcReg("K"   , 0x1e); AddSrcReg("L"   , 0x1f); AddSrcReg(NULL   , 0);
  872.  
  873.   InstrZ = 0;
  874.   AddALUSrcReg("IB"  , 0x00); AddALUSrcReg("M"   , 0x01);
  875.   AddALUSrcReg("RAM0", 0x02); AddALUSrcReg("RAM1", 0x03);
  876.   AddALUSrcReg(NULL  , 0);
  877.  
  878.   InstrZ = 0;
  879.   AddDestReg("NON" , 0x00); AddDestReg("RP"  , 0x01); AddDestReg("PSW0" , 0x02);
  880.   AddDestReg("PSW1", 0x03); AddDestReg("SVR" , 0x04); AddDestReg("SR"   , 0x05);
  881.   AddDestReg("LC"  , 0x06); AddDestReg("STK" , 0x07); AddDestReg("LKR0" , 0x08);
  882.   AddDestReg("KLR1", 0x09); AddDestReg("TRE" , 0x0a); AddDestReg("TR"   , 0x0b);
  883.   AddDestReg("AR"  , 0x0c); AddDestReg("SO"  , 0x0d); AddDestReg("DR"   , 0x0e);
  884.   AddDestReg("DRS" , 0x0f); AddDestReg("WR0" , 0x10); AddDestReg("WR1"  , 0x11);
  885.   AddDestReg("WR2" , 0x12); AddDestReg("WR3" , 0x13); AddDestReg("WR4"  , 0x14);
  886.   AddDestReg("WR5" , 0x15); AddDestReg("WR6" , 0x16); AddDestReg("WR7"  , 0x17);
  887.   AddDestReg("RAM0", 0x18); AddDestReg("RAM1", 0x19); AddDestReg("BP0"  , 0x1a);
  888.   AddDestReg("BP1" , 0x1b); AddDestReg("IX0" , 0x1c); AddDestReg("IX1"  , 0x1d);
  889.   AddDestReg("K"   , 0x1e); AddDestReg("L"   , 0x1f); AddDestReg(NULL   , 0);
  890.  
  891.   InstrComps = (LongWord*) malloc(sizeof(LongWord) * InstrCnt);
  892.   InstrDefs = (LongWord*) malloc(sizeof(LongWord) * InstrCnt);
  893.   for (InstrZ = 0; InstrZ < InstrCnt; InstrDefs[InstrZ++] = 0xffffffff);
  894.   InstrDefs[InstrALU] = 0;
  895.   InstrDefs[InstrMove] = 0;
  896.   InstrDefs[InstrBM] = 0;
  897.   InstrDefs[InstrEM] = 0;
  898.   InstrDefs[InstrDP0] = 0;
  899.   InstrDefs[InstrDP1] = 0;
  900.   InstrDefs[InstrEA] = 0;
  901.   InstrDefs[InstrFC] = 0;
  902.   InstrDefs[InstrFD] = 0;
  903.   InstrDefs[InstrFIS] = 0;
  904.   InstrDefs[InstrL] = 0;
  905.   InstrDefs[InstrM0] = 0;
  906.   InstrDefs[InstrM1] = 0;
  907.   InstrDefs[InstrNF] = 0;
  908.   InstrDefs[InstrRP] = 0;
  909.   InstrDefs[InstrRW] = 0;
  910.   InstrDefs[InstrWI] = 0;
  911.   InstrDefs[InstrWT] = 0;
  912. }
  913.  
  914. static void DeinitFields(void)
  915. {
  916.   DestroyInstTable(InstTable);
  917.  
  918.   order_array_free(SrcRegs);
  919.   order_array_free(ALUSrcRegs);
  920.   order_array_free(DestRegs);
  921.  
  922.   order_array_free(JmpOrders);
  923.   order_array_free(ALU1Orders);
  924.   order_array_free(ALU2Orders);
  925.  
  926.   free(InstrComps);
  927.   free(InstrDefs);
  928. }
  929.  
  930. /*---------------------------------------------------------------------------*/
  931. /* Callbacks */
  932.  
  933. static void MakeCode_77230(void)
  934. {
  935.   int z, z2;
  936.   LongWord Diff;
  937.  
  938.   /* Nullanweisung */
  939.  
  940.   if (Memo("") && !*AttrPart.str.p_str && (ArgCnt == 0))
  941.     return;
  942.  
  943.   /* Pseudoanweisungen */
  944.  
  945.   if (DecodePseudo())
  946.     return;
  947.  
  948.   /* solange dekodieren, bis keine Operanden mehr da oder Fehler */
  949.  
  950.   Error = False;
  951.   InstrMask = 0;
  952.   memset(InstrComps, 0, sizeof(LongWord) * InstrCnt);
  953.   do
  954.   {
  955.     if (!LookupInstTable(InstTable, OpPart.str.p_str))
  956.     {
  957.       WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  958.       Error = True;
  959.     }
  960.   }
  961.   while (!Error && (*OpPart.str.p_str != '\0'));
  962.  
  963.   /* passende Verknuepfung suchen */
  964.  
  965.   if (!Error)
  966.   {
  967.     for (z = 0; z < CaseCnt; z++)
  968.     {
  969.       /* Bits ermitteln, die nur in einer Maske vorhanden sind */
  970.  
  971.       Diff = InstrMask^CaseMasks[z];
  972.  
  973.       /* Fall nur moeglich, wenn Bits im aktuellen Fall gesetzt sind, die
  974.          der Fall nicht hat */
  975.  
  976.       if ((Diff & InstrMask) == 0)
  977.       {
  978.         /* ist irgendein Feld unbenutzt, fuer das wir keinen Default haben? */
  979.  
  980.         for (z2 = 0; z2 < InstrCnt; z2++)
  981.           if (((Diff & (1l << z2)) != 0) && (InstrDefs[z2] == 0xffffffff))
  982.             break;
  983.         if (z2 == InstrCnt)
  984.           break;
  985.       }
  986.     }
  987.  
  988.     switch (z)
  989.     {
  990.       case 0: /* nur LDI */
  991.         DAsmCode[0] = 0xe0000000 + InstrComps[InstrLDI];
  992.         CodeLen = 1;
  993.         break;
  994.       case 1: /* JMP + MOV */
  995.         DAsmCode[0] = 0xd0000000 + (InstrComps[InstrBranch] << 10)
  996.                                  + InstrComps[InstrMove];
  997.         CodeLen = 1;
  998.         break;
  999.       case 2: /* ALU + MOV + M0 + M1 + DP0 + DP1 */
  1000.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1001.                     + (InstrComps[InstrDP1] << 15) + (InstrComps[InstrDP0] << 18)
  1002.                     + (InstrComps[InstrM1] << 21) + (InstrComps[InstrM0] << 23);
  1003.         CodeLen = 1;
  1004.         break;
  1005.       case 3: /* ALU + MOV + EA + DP0 + DP1 */
  1006.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1007.                     + (InstrComps[InstrDP1] << 15) + (InstrComps[InstrDP0] << 18)
  1008.                     + (InstrComps[InstrEA] << 21) + 0x02000000;
  1009.         CodeLen = 1;
  1010.         break;
  1011.       case 4: /* ALU + MOV + RP + M0 + DP0 + FC */
  1012.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1013.                     + (InstrComps[InstrRP] << 21) + (InstrComps[InstrFC] << 15)
  1014.                     + (InstrComps[InstrM0] << 19) + (InstrComps[InstrDP0] << 16)
  1015.                     + 0x02800000;
  1016.         CodeLen = 1;
  1017.         break;
  1018.       case 5: /* ALU + MOV + RP + M1 + DP1 + FC */
  1019.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1020.                     + (InstrComps[InstrRP] << 21) + (InstrComps[InstrFC] << 15)
  1021.                     + (InstrComps[InstrM1] << 19) + (InstrComps[InstrDP1] << 16)
  1022.                     + 0x03000000;
  1023.         CodeLen = 1;
  1024.         break;
  1025.       case 6: /* ALU + MOV + RP + M0 + M1 + L + FC */
  1026.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1027.                     + (InstrComps[InstrRP] << 21) + (InstrComps[InstrL] << 16)
  1028.                     + (InstrComps[InstrM0] << 19) + (InstrComps[InstrM1] << 17)
  1029.                     + (InstrComps[InstrFC] << 15) + 0x03800000;
  1030.         CodeLen = 1;
  1031.         break;
  1032.       case 7: /* ALU + MOV + BASE0 + BASE1 + FC */
  1033.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1034.                     + (InstrComps[InstrBASE0] << 19) + (InstrComps[InstrBASE1] << 16)
  1035.                     + (InstrComps[InstrFC] << 15) + 0x04000000;
  1036.         CodeLen = 1;
  1037.         break;
  1038.       case 8: /* ALU + MOV + RPC + L+ FC */
  1039.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1040.                     + (InstrComps[InstrRPC] << 18) + (InstrComps[InstrL] << 16)
  1041.                     + (InstrComps[InstrFC] << 15) + 0x04400000;
  1042.         CodeLen = 1;
  1043.         break;
  1044.       case 9: /* ALU + MOV + P2 + P3 + EM + BM + L + FC */
  1045.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1046.                     + (InstrComps[InstrP2] << 20) + (InstrComps[InstrP3] << 21)
  1047.                     + (InstrComps[InstrEM] << 19) + (InstrComps[InstrBM] << 17)
  1048.                     + (InstrComps[InstrL] << 16) + (InstrComps[InstrFC] << 15)
  1049.                     + 0x04800000;
  1050.         CodeLen = 1;
  1051.         break;
  1052.       case 10: /* ALU + MOV + RW + L + FC */
  1053.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1054.                     + (InstrComps[InstrRW] << 20) + (InstrComps[InstrL] << 16)
  1055.                     + (InstrComps[InstrFC] << 15) + 0x04c00000;
  1056.         CodeLen = 1;
  1057.         break;
  1058.       case 11: /* ALU + MOV + WT + L + FC */
  1059.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1060.                     + (InstrComps[InstrWT] << 19) + (InstrComps[InstrL] << 16)
  1061.                     + (InstrComps[InstrFC] << 15) + 0x05000000;
  1062.         CodeLen = 1;
  1063.         break;
  1064.       case 12: /* ALU + MOV + NF + WI + L + FC */
  1065.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1066.                     + (InstrComps[InstrNF] << 19) + (InstrComps[InstrWI] << 17)
  1067.                     + (InstrComps[InstrL] << 16) + (InstrComps[InstrFC] << 15)
  1068.                     + 0x05400000;
  1069.         CodeLen = 1;
  1070.         break;
  1071.       case 13: /* ALU + MOV + FIS + FD + L */
  1072.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1073.                     + (InstrComps[InstrFIS] << 19) + (InstrComps[InstrFD] << 17)
  1074.                     + (InstrComps[InstrL] << 16) + 0x05800000;
  1075.         CodeLen = 1;
  1076.         break;
  1077.       case 14: /* ALU + MOV + SHV */
  1078.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1079.                     + (InstrComps[InstrSHV] << 15) + 0x05c00000;
  1080.         CodeLen = 1;
  1081.         break;
  1082.       case 15: /* ALU + MOV + RPS */
  1083.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1084.                     + (InstrComps[InstrRPS] << 15) + 0x06000000;
  1085.         CodeLen = 1;
  1086.         break;
  1087.       case 16: /* ALU + MOV + NAL */
  1088.         DAsmCode[0] = (InstrComps[InstrALU] << 10) + InstrComps[InstrMove]
  1089.                     + (InstrComps[InstrNAL] << 15) + 0x07000000;
  1090.         CodeLen = 1;
  1091.         break;
  1092.       default:
  1093.         WrError(ErrNum_InvParAddrMode);
  1094.     }
  1095.   }
  1096. }
  1097.  
  1098. static Boolean IsDef_77230(void)
  1099. {
  1100.   return False;
  1101. }
  1102.  
  1103. static void SwitchFrom_77230(void)
  1104. {
  1105.   DeinitFields();
  1106. }
  1107.  
  1108. static void SwitchTo_77230(void)
  1109. {
  1110.   const TFamilyDescr *FoundDescr;
  1111.  
  1112.   FoundDescr = FindFamilyByName("77230");
  1113.  
  1114.   TurnWords = False;
  1115.   SetIntConstMode(eIntConstModeIntel);
  1116.   PCSymbol = "$";
  1117.   HeaderID = FoundDescr->Id;
  1118.   NOPCode = 0x00000000;
  1119.   DivideChars = ",";
  1120.   HasAttrs = False;
  1121.  
  1122.   ValidSegs = (1 << SegCode) | (1 << SegXData) | (1 << SegYData) | (1 << SegRData);
  1123.   Grans[SegCode ] = 4; ListGrans[SegCode ] = 4; SegInits[SegCode ] = 0;
  1124.   SegLimits[SegCode ] = 0x1fff;
  1125.   Grans[SegXData] = 4; ListGrans[SegXData] = 4; SegInits[SegXData] = 0;
  1126.   SegLimits[SegXData] = 0x1ff;
  1127.   Grans[SegYData] = 4; ListGrans[SegYData] = 4; SegInits[SegYData] = 0;
  1128.   SegLimits[SegYData] = 0x1ff;
  1129.   Grans[SegRData] = 4; ListGrans[SegRData] = 4; SegInits[SegRData] = 0;
  1130.   SegLimits[SegRData] = 0x3ff;
  1131.  
  1132.   onoff_packing_add(True);
  1133.  
  1134.   MakeCode = MakeCode_77230;
  1135.   IsDef = IsDef_77230;
  1136.   SwitchFrom = SwitchFrom_77230;
  1137.  
  1138.   InitFields();
  1139. }
  1140.  
  1141. /*---------------------------------------------------------------------------*/
  1142. /* Initialisierung */
  1143.  
  1144. void code77230_init(void)
  1145. {
  1146.   CPU77230 = AddCPU("77230", SwitchTo_77230);
  1147. }
  1148.