Subversion Repositories pentevo

Rev

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

  1. /* code7720.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* Makroassembler AS                                                         */
  6. /*                                                                           */
  7. /* Codegenerator NEC uPD772x                                                 */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <ctype.h>
  14. #include "strutil.h"
  15. #include "nls.h"
  16. #include "bpemu.h"
  17.  
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmcode.h"
  22. #include "asmitree.h"
  23. #include "headids.h"
  24. #include "codevars.h"
  25. #include "codepseudo.h"
  26. #include "onoff_common.h"
  27. #include "errmsg.h"
  28. #include "chartrans.h"
  29.  
  30. #include "code7720.h"
  31.  
  32. /*---------------------------------------------------------------------------*/
  33.  
  34. typedef struct
  35. {
  36.   const char *Name;
  37.   LongWord Code;
  38. } TReg;
  39.  
  40. typedef enum
  41. {
  42.   MoveField,
  43.   ALUField,
  44.   DPLField,
  45.   DPHField,
  46.   RPField,
  47.   RetField
  48. } OpComps;
  49.  
  50. static CPUVar CPU7720, CPU7725;
  51.  
  52. static LongWord ActCode;
  53. static Boolean InOp;
  54. static Byte UsedOpFields;
  55.  
  56. static Byte TypePos, ImmValPos, AddrPos, ALUPos, DPLPos, AccPos, ALUSrcPos;
  57. static IntType MemInt;
  58. static Word ROMEnd, DROMEnd, RAMEnd;
  59.  
  60. static TReg *DestRegs, *SrcRegs, *ALUSrcRegs;
  61.  
  62. static PInstTable OpTable;
  63.  
  64. /*---------------------------------------------------------------------------*/
  65. /* Hilfsroutinen */
  66.  
  67. static Boolean DecodeReg(char *Asc, LongWord *Code, TReg *Regs)
  68. {
  69.   int z;
  70.  
  71.   for (z = 0; Regs[z].Name; z++)
  72.     if (!as_strcasecmp(Asc, Regs[z].Name))
  73.     {
  74.       *Code = Regs[z].Code;
  75.       return True;
  76.     }
  77.  
  78.   return False;
  79. }
  80.  
  81. static Boolean ChkOpPresent(OpComps Comp)
  82. {
  83.   if ((UsedOpFields&(1l << Comp)) != 0)
  84.   {
  85.     WrError(ErrNum_InvParAddrMode); return False;
  86.   }
  87.   else
  88.   {
  89.     UsedOpFields |= 1l << Comp; return True;
  90.   }
  91. }
  92.  
  93. /*---------------------------------------------------------------------------*/
  94. /* Dekoder */
  95.  
  96. static void DecodeJmp(Word Code)
  97. {
  98.   Word Dest;
  99.   Boolean OK;
  100.  
  101.   if (ChkArgCnt(1, 1))
  102.   {
  103.     Dest = EvalStrIntExpression(&ArgStr[1], MemInt, &OK);
  104.     if (OK)
  105.     {
  106.       DAsmCode[0] = (2l << TypePos) + (((LongWord)Code) << 13) + (Dest << AddrPos);
  107.       CodeLen = 1;
  108.     }
  109.   }
  110. }
  111.  
  112. static void DecodeDATA_7720(Word Index)
  113. {
  114.   LongInt MinV, MaxV;
  115.   TempResult t;
  116.  
  117.   as_tempres_ini(&t);
  118.   UNUSED(Index);
  119.  
  120.   if (ActPC == SegCode)
  121.     MaxV = (MomCPU >= CPU7725) ? 16777215 : 8388607;
  122.   else
  123.     MaxV = 65535;
  124.   MinV = (-((MaxV + 1) >> 1));
  125.   if (ChkArgCnt(1, ArgCntMax))
  126.   {
  127.     Boolean OK = True;
  128.     tStrComp *pArg;
  129.  
  130.     forallargs(pArg, OK)
  131.     {
  132.       EvalStrExpression(pArg, &t);
  133.       if (mFirstPassUnknown(t.Flags) && (t.Typ == TempInt))
  134.         t.Contents.Int &= MaxV;
  135.  
  136.       switch (t.Typ)
  137.       {
  138.         case TempString:
  139.         {
  140.           if (MultiCharToInt(&t, 3))
  141.             goto ToInt;
  142.  
  143.           if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &t.Contents.str, pArg))
  144.             OK = False;
  145.           else if (ActPC == SegCode)
  146.             string_2_dasm_code(&t.Contents.str, Packing ? ((MomCPU >= CPU7725) ? 3 : 2) : 1, True);
  147.           else
  148.             string_2_wasm_code(&t.Contents.str, Packing ? 2 : 1, True);
  149.           break;
  150.         }
  151.         case TempInt:
  152.         ToInt:
  153.           OK = ChkRange(t.Contents.Int, MinV, MaxV);
  154.           if (OK)
  155.           {
  156.             if (ActPC == SegCode)
  157.               DAsmCode[CodeLen++] = t.Contents.Int & MaxV;
  158.             else
  159.               WAsmCode[CodeLen++] = t.Contents.Int;
  160.           }
  161.           break;
  162.         case TempFloat:
  163.           WrStrErrorPos(ErrNum_StringOrIntButFloat, pArg);
  164.           /* fall-through */
  165.         default:
  166.           OK = False;
  167.       }
  168.     }
  169.   }
  170.   as_tempres_free(&t);
  171. }
  172.  
  173. static void DecodeRES(Word Index)
  174. {
  175.   Word Size;
  176.   Boolean OK;
  177.   UNUSED(Index);
  178.  
  179.   if (ChkArgCnt(1, 1))
  180.   {
  181.     tSymbolFlags Flags;
  182.  
  183.     Size = EvalStrIntExpressionWithFlags(&ArgStr[1], Int16, &OK, &Flags);
  184.     if (mFirstPassUnknown(Flags)) WrError(ErrNum_FirstPassCalc);
  185.     if (OK && !mFirstPassUnknown(Flags))
  186.     {
  187.       DontPrint = True;
  188.       if (!Size)
  189.         WrError(ErrNum_NullResMem);
  190.       CodeLen = Size;
  191.       BookKeeping();
  192.     }
  193.   }
  194. }
  195.  
  196. static void DecodeALU2(Word Code)
  197. {
  198.   LongWord Acc = 0xff, Src;
  199.   char ch;
  200.  
  201.   if (!ChkOpPresent(ALUField))
  202.     return;
  203.  
  204.   if (!ChkArgCnt(2, 2));
  205.   else if (!DecodeReg(ArgStr[2].str.p_str, &Src, ALUSrcRegs)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  206.   else
  207.   {
  208.     if ((strlen(ArgStr[1].str.p_str) == 4) && (!as_strncasecmp(ArgStr[1].str.p_str, "ACC", 3)))
  209.     {
  210.       ch = as_toupper(ArgStr[1].str.p_str[3]);
  211.       if ((ch>='A') && (ch<='B'))
  212.         Acc = ch - 'A';
  213.     }
  214.     if (Acc == 0xff)
  215.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  216.     else
  217.       ActCode |= (((LongWord)Code) << ALUPos) + (Acc << AccPos) + (Src << ALUSrcPos);
  218.   }
  219. }
  220.  
  221. static void DecodeALU1(Word Code)
  222. {
  223.   LongWord Acc = 0xff;
  224.   char ch;
  225.  
  226.   if (!ChkOpPresent(ALUField))
  227.     return;
  228.  
  229.   if (ChkArgCnt(1, 1))
  230.   {
  231.     if ((strlen(ArgStr[1].str.p_str) == 4) && (!as_strncasecmp(ArgStr[1].str.p_str, "ACC", 3)))
  232.     {
  233.       ch = as_toupper(ArgStr[1].str.p_str[3]);
  234.       if ((ch >= 'A') && (ch <= 'B'))
  235.         Acc = ch - 'A';
  236.     }
  237.     if (Acc == 0xff)
  238.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  239.     else
  240.       ActCode |= (((LongWord)Code) << ALUPos) + (Acc << AccPos);
  241.   }
  242. }
  243.  
  244. static void DecodeNOP(Word Index)
  245. {
  246.   UNUSED(Index);
  247.  
  248.   if (!ChkOpPresent(ALUField))
  249.     return;
  250. }
  251.  
  252. static void DecodeDPL(Word Index)
  253. {
  254.   if (!ChkOpPresent(DPLField))
  255.     return;
  256.  
  257.   if (ChkArgCnt(0, 0))
  258.     ActCode |= (((LongWord)Index) << DPLPos);
  259. }
  260.  
  261. static void DecodeDPH(Word Index)
  262. {
  263.   if (!ChkOpPresent(DPHField))
  264.     return;
  265.  
  266.   if (ChkArgCnt(0, 0))
  267.     ActCode |= (((LongWord)Index) << 9);
  268. }
  269.  
  270. static void DecodeRP(Word Index)
  271. {
  272.   if (!ChkOpPresent(RPField))
  273.     return;
  274.  
  275.   if (ChkArgCnt(0, 0))
  276.     ActCode |= (((LongWord)Index) << 8);
  277. }
  278.  
  279. static void DecodeRET(Word Index)
  280. {
  281.   UNUSED(Index);
  282.  
  283.   if (!ChkOpPresent(RetField))
  284.     return;
  285.  
  286.   if (ChkArgCnt(0, 0))
  287.     ActCode |= (1l << TypePos);
  288. }
  289.  
  290. static void DecodeLDI(Word Index)
  291. {
  292.   LongWord Value;
  293.   LongWord Reg;
  294.   Boolean OK;
  295.   UNUSED(Index);
  296.  
  297.   if (!ChkArgCnt(2, 2));
  298.   else if (!DecodeReg(ArgStr[1].str.p_str, &Reg, DestRegs)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  299.   else
  300.   {
  301.     Value = EvalStrIntExpression(&ArgStr[2], Int16, &OK);
  302.     if (OK)
  303.     {
  304.       DAsmCode[0] = (3l << TypePos) + Reg + (Value << ImmValPos);
  305.       CodeLen = 1;
  306.     }
  307.   }
  308. }
  309.  
  310. static void DecodeOP(Word Index)
  311. {
  312.   char *p;
  313.   int z;
  314.   UNUSED(Index);
  315.  
  316.   UsedOpFields = 0;
  317.   ActCode = 0;
  318.  
  319.   if (ArgCnt >= 1)
  320.   {
  321.     p = FirstBlank(ArgStr[1].str.p_str);
  322.     if (p)
  323.     {
  324.       StrCompSplitLeft(&ArgStr[1], &OpPart, p);
  325.       NLS_UpString(OpPart.str.p_str);
  326.       KillPrefBlanksStrComp(&ArgStr[1]);
  327.     }
  328.     else
  329.     {
  330.       StrCompCopy(&OpPart, &ArgStr[1]);
  331.       for (z = 1; z < ArgCnt; z++)
  332.         StrCompCopy(&ArgStr[z], &ArgStr[z + 1]);
  333.       ArgCnt--;
  334.     }
  335.     if (!LookupInstTable(OpTable, OpPart.str.p_str))
  336.       WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  337.   }
  338.  
  339.   DAsmCode[0] = ActCode;
  340.   CodeLen = 1;
  341. }
  342.  
  343. static void DecodeMOV(Word Index)
  344. {
  345.   LongWord Dest, Src;
  346.   UNUSED(Index);
  347.  
  348.   if (!ChkOpPresent(MoveField))
  349.     return;
  350.  
  351.   if (!ChkArgCnt(2, 2));
  352.   else if (!DecodeReg(ArgStr[1].str.p_str, &Dest, DestRegs)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  353.   else if (!DecodeReg(ArgStr[2].str.p_str, &Src, SrcRegs)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  354.   else
  355.     ActCode |= Dest + (Src << 4);
  356. }
  357.  
  358. /*---------------------------------------------------------------------------*/
  359. /* Tabellenverwaltung */
  360.  
  361. static void AddJmp(const char *NName, Word NCode)
  362. {
  363.   if ((MomCPU < CPU7725) && (Odd(NCode)))
  364.     return;
  365.   AddInstTable(InstTable, NName, (MomCPU == CPU7725) ? NCode : NCode >> 1, DecodeJmp);
  366. }
  367.  
  368. static void AddALU2(const char *NName, Word NCode)
  369. {
  370.   AddInstTable(OpTable, NName, NCode, DecodeALU2);
  371. }
  372.  
  373. static void AddALU1(const char *NName, Word NCode)
  374. {
  375.   AddInstTable(OpTable, NName, NCode, DecodeALU1);
  376. }
  377.  
  378. static void AddDestReg(const char *NName, LongWord NCode)
  379. {
  380.   order_array_rsv_end(DestRegs, TReg);
  381.   DestRegs[InstrZ].Name = NName;
  382.   DestRegs[InstrZ++].Code = NCode;
  383. }
  384.  
  385. static void AddSrcReg(const char *NName, LongWord NCode)
  386. {
  387.   order_array_rsv_end(SrcRegs, TReg);
  388.   SrcRegs[InstrZ].Name = NName;
  389.   SrcRegs[InstrZ++].Code = NCode;
  390. }
  391.  
  392. static void AddALUSrcReg(const char *NName, LongWord NCode)
  393. {
  394.   order_array_rsv_end(ALUSrcRegs, TReg);
  395.   ALUSrcRegs[InstrZ].Name = NName;
  396.   ALUSrcRegs[InstrZ++].Code = NCode;
  397. }
  398.  
  399. static void InitFields(void)
  400. {
  401.   InstTable = CreateInstTable(101);
  402.   OpTable = CreateInstTable(79);
  403.  
  404.   AddInstTable(InstTable, "LDI", 0, DecodeLDI);
  405.   AddInstTable(InstTable, "LD", 0, DecodeLDI);
  406.   AddInstTable(InstTable, "OP", 0, DecodeOP);
  407.   AddInstTable(InstTable, "DATA", 0, DecodeDATA_7720);
  408.   AddInstTable(InstTable, "RES", 0, DecodeRES);
  409.   AddInstTable(OpTable, "MOV", 0, DecodeMOV);
  410.   AddInstTable(OpTable, "NOP", 0, DecodeNOP);
  411.   AddInstTable(OpTable, "DPNOP", 0, DecodeDPL);
  412.   AddInstTable(OpTable, "DPINC", 1, DecodeDPL);
  413.   AddInstTable(OpTable, "DPDEC", 2, DecodeDPL);
  414.   AddInstTable(OpTable, "DPCLR", 3, DecodeDPL);
  415.   AddInstTable(OpTable, "M0", 0, DecodeDPH);
  416.   AddInstTable(OpTable, "M1", 1, DecodeDPH);
  417.   AddInstTable(OpTable, "M2", 2, DecodeDPH);
  418.   AddInstTable(OpTable, "M3", 3, DecodeDPH);
  419.   AddInstTable(OpTable, "M4", 4, DecodeDPH);
  420.   AddInstTable(OpTable, "M5", 5, DecodeDPH);
  421.   AddInstTable(OpTable, "M6", 6, DecodeDPH);
  422.   AddInstTable(OpTable, "M7", 7, DecodeDPH);
  423.   if (MomCPU >= CPU7725)
  424.   {
  425.     AddInstTable(OpTable, "M8", 8, DecodeDPH);
  426.     AddInstTable(OpTable, "M9", 9, DecodeDPH);
  427.     AddInstTable(OpTable, "MA", 10, DecodeDPH);
  428.     AddInstTable(OpTable, "MB", 11, DecodeDPH);
  429.     AddInstTable(OpTable, "MC", 12, DecodeDPH);
  430.     AddInstTable(OpTable, "MD", 13, DecodeDPH);
  431.     AddInstTable(OpTable, "ME", 14, DecodeDPH);
  432.     AddInstTable(OpTable, "MF", 15, DecodeDPH);
  433.   }
  434.   AddInstTable(OpTable, "RPNOP", 0, DecodeRP);
  435.   AddInstTable(OpTable, "RPDEC", 1, DecodeRP);
  436.   AddInstTable(OpTable, "RET", 1, DecodeRET);
  437.  
  438.   AddJmp("JMP"   , 0x100); AddJmp("CALL"  , 0x140);
  439.   AddJmp("JNCA"  , 0x080); AddJmp("JCA"   , 0x082);
  440.   AddJmp("JNCB"  , 0x084); AddJmp("JCB"   , 0x086);
  441.   AddJmp("JNZA"  , 0x088); AddJmp("JZA"   , 0x08a);
  442.   AddJmp("JNZB"  , 0x08c); AddJmp("JZB"   , 0x08e);
  443.   AddJmp("JNOVA0", 0x090); AddJmp("JOVA0" , 0x092);
  444.   AddJmp("JNOVB0", 0x094); AddJmp("JOVB0" , 0x096);
  445.   AddJmp("JNOVA1", 0x098); AddJmp("JOVA1" , 0x09a);
  446.   AddJmp("JNOVB1", 0x09c); AddJmp("JOVB1" , 0x09e);
  447.   AddJmp("JNSA0" , 0x0a0); AddJmp("JSA0"  , 0x0a2);
  448.   AddJmp("JNSB0" , 0x0a4); AddJmp("JSB0"  , 0x0a6);
  449.   AddJmp("JNSA1" , 0x0a8); AddJmp("JSA1"  , 0x0aa);
  450.   AddJmp("JNSB1" , 0x0ac); AddJmp("JSB1"  , 0x0ae);
  451.   AddJmp("JDPL0" , 0x0b0); AddJmp("JDPLF" , 0x0b2);
  452.   AddJmp("JNSIAK", 0x0b4); AddJmp("JSIAK" , 0x0b6);
  453.   AddJmp("JNSOAK", 0x0b8); AddJmp("JSOAK" , 0x0ba);
  454.   AddJmp("JNRQM" , 0x0bc); AddJmp("JRQM"  , 0x0be);
  455.   AddJmp("JDPLN0", 0x0b1); AddJmp("JDPLNF" , 0x0b3);
  456.  
  457.   AddALU2("OR"  , 1); AddALU2("AND" , 2); AddALU2("XOR" , 3);
  458.   AddALU2("SUB" , 4); AddALU2("ADD" , 5); AddALU2("SBB" , 6);
  459.   AddALU2("ADC" , 7); AddALU2("CMP" ,10);
  460.  
  461.   AddALU1("DEC" ,  8); AddALU1("INC" ,  9); AddALU1("SHR1", 11);
  462.   AddALU1("SHL1", 12); AddALU1("SHL2", 13); AddALU1("SHL4", 14);
  463.   AddALU1("XCHG", 15);
  464.  
  465.   InstrZ = 0;
  466.   AddDestReg("@NON",  0); AddDestReg("@A"  ,  1);
  467.   AddDestReg("@B"  ,  2); AddDestReg("@TR" ,  3);
  468.   AddDestReg("@DP" ,  4); AddDestReg("@RP" ,  5);
  469.   AddDestReg("@DR" ,  6); AddDestReg("@SR" ,  7);
  470.   AddDestReg("@SOL",  8); AddDestReg("@SOM",  9);
  471.   AddDestReg("@K"  , 10); AddDestReg("@KLR", 11);
  472.   AddDestReg("@KLM", 12); AddDestReg("@L"  , 13);
  473.   if (MomCPU == CPU7725) AddDestReg("@TRB", 14);
  474.   AddDestReg("@MEM", 15);
  475.   AddDestReg(NULL, 0);
  476.  
  477.   InstrZ = 0;
  478.   AddSrcReg("NON" ,  0); AddSrcReg("A"   ,  1);
  479.   AddSrcReg("B"   ,  2); AddSrcReg("TR"  ,  3);
  480.   AddSrcReg("DP"  ,  4); AddSrcReg("RP"  ,  5);
  481.   AddSrcReg("RO"  ,  6); AddSrcReg("SGN" ,  7);
  482.   AddSrcReg("DR"  ,  8); AddSrcReg("DRNF",  9);
  483.   AddSrcReg("SR"  , 10); AddSrcReg("SIM" , 11);
  484.   AddSrcReg("SIL" , 12); AddSrcReg("K"   , 13);
  485.   AddSrcReg("L"   , 14); AddSrcReg("MEM" , 15);
  486.   AddSrcReg(NULL, 0);
  487.  
  488.   InstrZ = 0;
  489.   AddALUSrcReg("RAM", 0); AddALUSrcReg("IDB", 1);
  490.   AddALUSrcReg("M"  , 2); AddALUSrcReg("N"  , 3);
  491.   AddALUSrcReg(NULL, 0);
  492. }
  493.  
  494. static void DeinitFields(void)
  495. {
  496.   DestroyInstTable(InstTable);
  497.   DestroyInstTable(OpTable);
  498.   order_array_free(DestRegs);
  499.   order_array_free(SrcRegs);
  500.   order_array_free(ALUSrcRegs);
  501. }
  502.  
  503. /*---------------------------------------------------------------------------*/
  504. /* Callbacks */
  505.  
  506. static void MakeCode_7720(void)
  507. {
  508.   Boolean NextOp;
  509.  
  510.   /* Nullanweisung */
  511.  
  512.   if (Memo("") && !*AttrPart.str.p_str && (ArgCnt == 0))
  513.     return;
  514.  
  515.   /* direkte Anweisungen */
  516.  
  517.   NextOp = Memo("OP");
  518.   if (LookupInstTable(InstTable, OpPart.str.p_str))
  519.   {
  520.     InOp = NextOp; return;
  521.   }
  522.  
  523.   /* wenn eine parallele Op-Anweisung offen ist, noch deren Komponenten testen */
  524.  
  525.   if ((InOp) && (LookupInstTable(OpTable, OpPart.str.p_str)))
  526.   {
  527.     RetractWords(1);
  528.     DAsmCode[0] = ActCode;
  529.     CodeLen = 1;
  530.     return;
  531.   }
  532.  
  533.   /* Hae??? */
  534.  
  535.   WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  536. }
  537.  
  538. static Boolean IsDef_7720(void)
  539. {
  540.   return False;
  541. }
  542.  
  543. static void SwitchFrom_7720(void)
  544. {
  545.   DeinitFields();
  546. }
  547.  
  548. static void SwitchTo_7720(void)
  549. {
  550.   const TFamilyDescr *FoundDescr;
  551.  
  552.   TurnWords = False;
  553.   SetIntConstMode(eIntConstModeIntel);
  554.  
  555.   if (MomCPU == CPU7725)
  556.   {
  557.     FoundDescr = FindFamilyByName("7725");
  558.     MemInt = UInt11;
  559.     ROMEnd = 0x7ff; DROMEnd = 0x3ff; RAMEnd = 0xff;
  560.     TypePos = 22;
  561.     ImmValPos = 6;
  562.     AddrPos = 2;
  563.     ALUPos = 16;
  564.     DPLPos = 13;
  565.     AccPos = 15;
  566.     ALUSrcPos = 20;
  567.   }
  568.   else
  569.   {
  570.     FoundDescr = FindFamilyByName("7720");
  571.     MemInt = UInt9;
  572.     ROMEnd = 0x1ff; DROMEnd = 0x1ff; RAMEnd = 0x7f;
  573.     TypePos = 21;
  574.     ImmValPos = 5;
  575.     AddrPos = 4;
  576.     ALUPos = 15;
  577.     DPLPos = 12;
  578.     AccPos = 14;
  579.     ALUSrcPos = 19;
  580.   }
  581.  
  582.   PCSymbol = "$";
  583.   HeaderID = FoundDescr->Id;
  584.   NOPCode = 0x000000;
  585.   DivideChars = ",";
  586.   HasAttrs = False;
  587.  
  588.   ValidSegs = (1l << SegCode) | (1l << SegData) | (1l << SegRData);
  589.   Grans[SegCode ] = 4; ListGrans[SegCode ] = 4; SegInits[SegCode ] = 0;
  590.   SegLimits[SegCode ] = ROMEnd;
  591.   Grans[SegData ] = 2; ListGrans[SegData ] = 2; SegInits[SegData ] = 0;
  592.   SegLimits[SegData ] = RAMEnd;
  593.   Grans[SegRData] = 2; ListGrans[SegRData] = 2; SegInits[SegRData] = 0;
  594.   SegLimits[SegRData] = DROMEnd;
  595.  
  596.   MakeCode = MakeCode_7720;
  597.   IsDef = IsDef_7720;
  598.   SwitchFrom = SwitchFrom_7720;
  599.  
  600.   onoff_packing_add(True);
  601.  
  602.   InOp = False;
  603.   UsedOpFields = 0;
  604.   ActCode = 0;
  605.   InitFields();
  606. }
  607.  
  608. /*---------------------------------------------------------------------------*/
  609. /* Initialisierung */
  610.  
  611. void code7720_init(void)
  612. {
  613.   CPU7720 = AddCPU("7720", SwitchTo_7720);
  614.   CPU7725 = AddCPU("7725", SwitchTo_7720);
  615. }
  616.