From 333b605b2afd472b823aeda0adf0e8b1ea9843c0 Mon Sep 17 00:00:00 2001
From: fishsoupisgood <github@madingley.org>
Date: Mon, 27 May 2019 02:41:51 +0100
Subject: initial commit from asl-1.41r8.tar.gz

---
 code96.c | 1253 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1253 insertions(+)
 create mode 100644 code96.c

(limited to 'code96.c')

diff --git a/code96.c b/code96.c
new file mode 100644
index 0000000..7c13b58
--- /dev/null
+++ b/code96.c
@@ -0,0 +1,1253 @@
+/* code96.c */
+/*****************************************************************************/
+/* AS-Portierung                                                             */
+/*                                                                           */
+/* Codegenerator MCS/96-Familie                                              */
+/*                                                                           */
+/* Historie: 10.11.1996                                                      */
+/*           16. 3.1997 80196N/80296                                         */
+/*            3. 1.1999 ChkPC-Anpassung                                      */
+/*                                                                           */
+/*****************************************************************************/
+
+#include "stdinc.h"
+#include <string.h>
+
+#include "bpemu.h"
+#include "asmdef.h"
+#include "asmsub.h"
+#include "asmpars.h"
+#include "codepseudo.h"
+#include "codevars.h"
+
+typedef struct 
+         {
+          char *Name;
+          Byte Code;
+         } FixedOrder;
+
+typedef struct 
+         {
+          char *Name;
+          Byte Code;
+          CPUVar MinCPU,MaxCPU;
+         } BaseOrder;
+
+typedef struct 
+         {
+          char *Name; 
+          Byte Code;
+          Boolean Reloc;
+         } MacOrder;
+
+#define FixedOrderCnt 16
+
+#define ALU3OrderCnt 5
+
+#define ALU2OrderCnt 9
+
+#define ALU1OrderCnt 6
+
+#define ShiftOrderCnt 3
+
+#define RelOrderCnt 16
+
+#define MacOrderCnt 8
+
+#define RptOrderCnt 34
+
+
+static char *ShiftOrders[ShiftOrderCnt]={"SHR","SHL","SHRA"};
+
+#define ModNone (-1)
+#define ModDir 0
+#define MModDir (1 << ModDir)
+#define ModMem 1
+#define MModMem (1 << ModMem)
+#define ModImm 2
+#define MModImm (1 << ModImm)
+
+#define SFRStart 2
+#define SFRStop 0x17
+
+static BaseOrder *FixedOrders;
+static FixedOrder *ALU3Orders;
+static FixedOrder *ALU2Orders;
+static FixedOrder *ALU1Orders;
+static FixedOrder *RelOrders;
+static MacOrder *MacOrders;
+static FixedOrder *RptOrders;
+
+static CPUVar CPU8096,CPU80196,CPU80196N,CPU80296;
+static SimpProc SaveInitProc;
+
+static Byte AdrMode;
+static ShortInt AdrType;
+static Byte AdrVals[4];
+static ShortInt OpSize;
+
+static LongInt WSRVal,WSR1Val;
+static Word WinStart,WinStop,WinEnd,WinBegin;
+static Word Win1Start,Win1Stop,Win1Begin,Win1End;
+
+IntType MemInt;
+
+/*---------------------------------------------------------------------------*/
+
+
+   	static void AddFixed(char *NName, Byte NCode, CPUVar NMin, CPUVar NMax)
+BEGIN
+   if (InstrZ>=FixedOrderCnt) exit(255);
+   FixedOrders[InstrZ].Name=NName;
+   FixedOrders[InstrZ].Code=NCode;
+   FixedOrders[InstrZ].MinCPU=NMin;
+   FixedOrders[InstrZ++].MaxCPU=NMax;
+END
+
+        static void AddALU3(char *NName, Byte NCode)
+BEGIN
+   if (InstrZ>=ALU3OrderCnt) exit(255);
+   ALU3Orders[InstrZ].Name=NName;
+   ALU3Orders[InstrZ++].Code=NCode;
+END
+
+        static void AddALU2(char *NName, Byte NCode)
+BEGIN
+   if (InstrZ>=ALU2OrderCnt) exit(255);
+   ALU2Orders[InstrZ].Name=NName;
+   ALU2Orders[InstrZ++].Code=NCode;
+END
+
+        static void AddALU1(char *NName, Byte NCode)
+BEGIN
+   if (InstrZ>=ALU1OrderCnt) exit(255);
+   ALU1Orders[InstrZ].Name=NName;
+   ALU1Orders[InstrZ++].Code=NCode;
+END
+
+        static void AddRel(char *NName, Byte NCode)
+BEGIN
+   if (InstrZ>=RelOrderCnt) exit(255);
+   RelOrders[InstrZ].Name=NName;
+   RelOrders[InstrZ++].Code=NCode;
+END
+
+        static void AddMac(char *NName, Byte NCode, Boolean NRel)
+BEGIN
+   if (InstrZ>=MacOrderCnt) exit(255);
+   MacOrders[InstrZ].Name=NName;
+   MacOrders[InstrZ].Code=NCode;
+   MacOrders[InstrZ++].Reloc=NRel;
+END
+
+        static void AddRpt(char *NName, Byte NCode)
+BEGIN
+   if (InstrZ>=RptOrderCnt) exit(255);
+   RptOrders[InstrZ].Name=NName;
+   RptOrders[InstrZ++].Code=NCode;
+END
+
+   	static void InitFields(void)
+BEGIN
+   FixedOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*FixedOrderCnt); InstrZ=0;
+   AddFixed("CLRC" ,0xf8,CPU8096  ,CPU80296 );
+   AddFixed("CLRVT",0xfc,CPU8096  ,CPU80296 );
+   AddFixed("DI"   ,0xfa,CPU8096  ,CPU80296 );
+   AddFixed("DPTS" ,0xea,CPU80196 ,CPU80196N);
+   AddFixed("EI"   ,0xfb,CPU8096  ,CPU80296 );
+   AddFixed("EPTS" ,0xeb,CPU80196 ,CPU80196N);
+   AddFixed("NOP"  ,0xfd,CPU8096  ,CPU80296 );
+   AddFixed("POPA" ,0xf5,CPU80196 ,CPU80296 );
+   AddFixed("POPF" ,0xf3,CPU8096  ,CPU80296 );
+   AddFixed("PUSHA",0xf4,CPU80196 ,CPU80296 );
+   AddFixed("PUSHF",0xf2,CPU8096  ,CPU80296 );
+   AddFixed("RET"  ,0xf0,CPU8096  ,CPU80296 );
+   AddFixed("RSC"  ,0xff,CPU8096  ,CPU80296 );
+   AddFixed("SETC" ,0xf9,CPU8096  ,CPU80296 );
+   AddFixed("TRAP" ,0xf7,CPU8096  ,CPU80296 );
+   AddFixed("RETI" ,0xe5,CPU80196N,CPU80296 );
+
+   ALU3Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*ALU3OrderCnt); InstrZ=0;
+   AddALU3("ADD" , 0x01);
+   AddALU3("AND" , 0x00);
+   AddALU3("MUL" , 0x83);   /* ** */
+   AddALU3("MULU", 0x03);
+   AddALU3("SUB" , 0x02);
+
+   ALU2Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*ALU2OrderCnt); InstrZ=0;
+   AddALU2("ADDC", 0xa4);
+   AddALU2("CMP" , 0x88);
+   AddALU2("DIV" , 0x8c);   /* ** */
+   AddALU2("DIVU", 0x8c);
+   AddALU2("LD"  , 0xa0);
+   AddALU2("OR"  , 0x80);
+   AddALU2("ST"  , 0xc0);
+   AddALU2("SUBC", 0xa8);
+   AddALU2("XOR" , 0x84);
+
+   ALU1Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*ALU1OrderCnt); InstrZ=0;
+   AddALU1("CLR", 0x01);
+   AddALU1("DEC", 0x05);
+   AddALU1("EXT", 0x06);
+   AddALU1("INC", 0x07);
+   AddALU1("NEG", 0x03);
+   AddALU1("NOT", 0x02);
+
+   RelOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*RelOrderCnt); InstrZ=0;
+   AddRel("JC"   , 0xdb);
+   AddRel("JE"   , 0xdf);
+   AddRel("JGE"  , 0xd6);
+   AddRel("JGT"  , 0xd2);
+   AddRel("JH"   , 0xd9);
+   AddRel("JLE"  , 0xda);
+   AddRel("JLT"  , 0xde);
+   AddRel("JNC"  , 0xd3);
+   AddRel("JNE"  , 0xd7);
+   AddRel("JNH"  , 0xd1);
+   AddRel("JNST" , 0xd0);
+   AddRel("JNV"  , 0xd5);
+   AddRel("JNVT" , 0xd4);
+   AddRel("JST"  , 0xd8);
+   AddRel("JV"   , 0xdd);
+   AddRel("JVT"  , 0xdc);
+
+   MacOrders=(MacOrder *) malloc(sizeof(MacOrder)*MacOrderCnt); InstrZ=0;
+   AddMac("MAC"   ,0x00,False); AddMac("SMAC"  ,0x01,False);
+   AddMac("MACR"  ,0x04,True ); AddMac("SMACR" ,0x05,True ); 
+   AddMac("MACZ"  ,0x08,False); AddMac("SMACZ" ,0x09,False);
+   AddMac("MACRZ" ,0x0c,True ); AddMac("SMACRZ",0x0d,True );
+
+   RptOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*RptOrderCnt); InstrZ=0;
+   AddRpt("RPT"    ,0x00); AddRpt("RPTNST" ,0x10); AddRpt("RPTNH"  ,0x11);
+   AddRpt("RPTGT"  ,0x12); AddRpt("RPTNC"  ,0x13); AddRpt("RPTNVT" ,0x14);
+   AddRpt("RPTNV"  ,0x15); AddRpt("RPTGE"  ,0x16); AddRpt("RPTNE"  ,0x17);
+   AddRpt("RPTST"  ,0x18); AddRpt("RPTH"   ,0x19); AddRpt("RPTLE"  ,0x1a);
+   AddRpt("RPTC"   ,0x1b); AddRpt("RPTVT"  ,0x1c); AddRpt("RPTV"   ,0x1d);
+   AddRpt("RPTLT"  ,0x1e); AddRpt("RPTE"   ,0x1f); AddRpt("RPTI"   ,0x20);
+   AddRpt("RPTINST",0x30); AddRpt("RPTINH" ,0x31); AddRpt("RPTIGT" ,0x32);
+   AddRpt("RPTINC" ,0x33); AddRpt("RPTINVT",0x34); AddRpt("RPTINV" ,0x35);
+   AddRpt("RPTIGE" ,0x36); AddRpt("RPTINE" ,0x37); AddRpt("RPTIST" ,0x38);
+   AddRpt("RPTIH"  ,0x39); AddRpt("RPTILE" ,0x3a); AddRpt("RPTIC"  ,0x3b);
+   AddRpt("RPTIVT" ,0x3c); AddRpt("RPTIV"  ,0x3d); AddRpt("RPTILT" ,0x3e);
+   AddRpt("RPTIE"  ,0x3f);
+END
+
+	static void DeinitFields(void)
+BEGIN
+   free(FixedOrders);
+   free(ALU3Orders);
+   free(ALU2Orders);
+   free(ALU1Orders);
+   free(RelOrders);
+   free(MacOrders);
+   free(RptOrders);
+END
+
+/*-------------------------------------------------------------------------*/
+
+	static void ChkSFR(Word Adr)
+BEGIN
+   if ((Adr>=SFRStart) & (Adr<=SFRStop)) WrError(190);
+END
+
+        static void Chk296(Word Adr)
+BEGIN
+   if ((MomCPU==CPU80296) AND (Adr<=1)) WrError(190);
+END
+
+	static Boolean ChkWork(Word *Adr)
+BEGIN
+   /* Registeradresse, die von Fenstern ueberdeckt wird ? */
+
+   if ((*Adr>=WinBegin) AND (*Adr<=WinEnd)) return False;
+
+   else if ((*Adr>=Win1Begin) AND (*Adr<=Win1End)) return False;
+
+   /* Speicheradresse in Fenster ? */
+
+   else if ((*Adr>=WinStart) AND (*Adr<=WinStop))
+    BEGIN
+     *Adr=(*Adr)-WinStart+WinBegin; return True;
+    END
+
+   else if ((*Adr>=Win1Start) AND (*Adr<=Win1Stop))
+    BEGIN
+     *Adr=(*Adr)-Win1Start+Win1Begin; return True;
+    END
+
+   /* Default */
+
+   else return (*Adr<=0xff);
+END
+
+	static void ChkAlign(Byte Adr)
+BEGIN
+   if (((OpSize==0) AND ((Adr & 1)!=0))
+   OR  ((OpSize==1) AND ((Adr & 3)!=0))) WrError(180);
+END
+
+	static void ChkAdr(Byte Mask)
+BEGIN
+   if ((AdrType==ModDir) AND ((Mask & MModDir)==0))
+    BEGIN
+     AdrType=ModMem; AdrMode=0;
+    END
+
+   if ((AdrType!=ModNone) AND ((Mask & (1 << AdrType))==0))
+    BEGIN
+     WrError(1350); AdrType=ModNone; AdrCnt=0;
+    END
+END
+
+	static void DecodeAdr(char *Asc, Byte Mask, Boolean AddrWide)
+BEGIN
+   LongInt AdrInt;
+   LongWord AdrWord;
+   Word BReg;
+   Boolean OK;
+   char *p,*p2;
+   int l;
+   Byte Reg;
+   LongWord OMask;
+
+   AdrType=ModNone; AdrCnt=0;
+   OMask=(1 << OpSize)-1;
+
+   if (*Asc=='#')
+    BEGIN
+     switch (OpSize)
+      BEGIN
+       case -1:
+        WrError(1132); break;
+       case 0:
+	AdrVals[0]=EvalIntExpression(Asc+1,Int8,&OK);
+	if (OK)
+	 BEGIN
+	  AdrType=ModImm; AdrCnt=1; AdrMode=1;
+	 END
+        break;
+       case 1:
+	AdrWord=EvalIntExpression(Asc+1,Int16,&OK);
+	if (OK)
+	 BEGIN
+	  AdrType=ModImm; AdrCnt=2; AdrMode=1;
+	  AdrVals[0]=Lo(AdrWord); AdrVals[1]=Hi(AdrWord);
+	 END
+        break;
+      END
+     ChkAdr(Mask); return;
+    END
+
+   p=QuotPos(Asc,'[');
+   if (p!=Nil)
+    BEGIN
+     p2=RQuotPos(Asc,']'); l=strlen(Asc);
+     if ((p2>Asc+l-1) OR (p2<Asc+l-2)) WrError(1350);
+     else
+      BEGIN
+       FirstPassUnknown=False; *p2='\0';
+       BReg=EvalIntExpression(p+1,Int16,&OK);
+       if (FirstPassUnknown) BReg=0;
+       if (OK)
+        if (NOT ChkWork(&BReg)) WrError(1320);
+        else
+	 BEGIN
+	  Reg=Lo(BReg); ChkSFR(Reg);
+	  if ((Reg&1)==1) WrError(1351);
+	  else if ((p==Asc) AND (p2==Asc+l-2) AND (Asc[l-1]=='+'))
+	   BEGIN
+	    AdrType=ModMem; AdrMode=2; AdrCnt=1; AdrVals[0]=Reg+1;
+	   END
+	  else if (p2!=Asc+l-1) WrError(1350);
+	  else if (p==Asc)
+	   BEGIN
+	    AdrType=ModMem; AdrMode=2; AdrCnt=1; AdrVals[0]=Reg;
+	   END
+	  else
+	   BEGIN
+            *p='\0';
+	    if (NOT AddrWide) AdrInt=EvalIntExpression(Asc,Int16,&OK); 
+            else AdrInt=EvalIntExpression(Asc,Int24,&OK);
+	    if (OK)
+	     if (AdrInt==0)
+	      BEGIN
+	       AdrType=ModMem; AdrMode=2; AdrCnt=1; AdrVals[0]=Reg;
+	      END
+             else if (AddrWide)
+              BEGIN
+               AdrType=ModMem; AdrMode=3; AdrCnt=4;
+               AdrVals[0]=Reg; AdrVals[1]=AdrInt & 0xff;
+               AdrVals[2]=(AdrInt >> 8) & 0xff;
+               AdrVals[3]=(AdrInt >> 16) & 0xff;
+              END
+	     else if ((AdrInt>=-128) AND (AdrInt<127))
+	      BEGIN
+	       AdrType=ModMem; AdrMode=3; AdrCnt=2;
+	       AdrVals[0]=Reg; AdrVals[1]=Lo(AdrInt);
+	      END
+	     else
+	      BEGIN
+	       AdrType=ModMem; AdrMode=3; AdrCnt=3;
+	       AdrVals[0]=Reg+1; AdrVals[1]=Lo(AdrInt); AdrVals[2]=Hi(AdrInt);
+	      END
+	   END
+	 END
+      END
+    END
+   else
+    BEGIN
+     FirstPassUnknown=False;
+     AdrWord=EvalIntExpression(Asc,MemInt,&OK);
+     if (FirstPassUnknown) AdrWord&=(0xffffffff-OMask);
+     if (OK)
+      if ((AdrWord & OMask)!=0) WrError(1325);
+      else
+       BEGIN
+        BReg=AdrWord & 0xffff;
+        if (((BReg & 0xffff0000)==0) AND (ChkWork(&BReg)))
+ 	 BEGIN
+ 	  AdrType=ModDir; AdrCnt=1; AdrVals[0]=Lo(BReg);
+ 	 END
+        else if (AddrWide)
+         BEGIN
+          AdrType=ModMem; AdrMode=3; AdrCnt=4; AdrVals[0]=0;
+          AdrVals[1]=AdrWord & 0xff; 
+          AdrVals[2]=(AdrWord >> 8) & 0xff;
+          AdrVals[3]=(AdrWord >> 16) & 0xff;
+         END
+        else if (AdrWord>=0xff80)
+ 	 BEGIN
+ 	  AdrType=ModMem; AdrMode=3; AdrCnt=2; AdrVals[0]=0;
+ 	  AdrVals[1]=Lo(AdrWord);
+ 	 END
+        else
+ 	 BEGIN
+ 	  AdrType=ModMem; AdrMode=3; AdrCnt=3; AdrVals[0]=1;
+ 	  AdrVals[1]=Lo(AdrWord); AdrVals[2]=Hi(AdrWord);
+ 	 END
+       END
+    END
+
+   ChkAdr(Mask);
+END
+
+	static void CalcWSRWindow(void)
+BEGIN
+   if (WSRVal<=0x0f)
+    BEGIN
+     WinStart=0xffff; WinStop=0; WinBegin=0xff; WinEnd=0;
+    END
+   else if (WSRVal<=0x1f)
+    BEGIN
+     WinBegin=0x80; WinEnd=0xff;
+     if (WSRVal<0x18) WinStart=(WSRVal-0x10) << 7;
+     else WinStart=(WSRVal+0x20) << 7;
+     WinStop=WinStart+0x7f;
+    END
+   else if (WSRVal<=0x3f)
+    BEGIN
+     WinBegin=0xc0; WinEnd=0xff;
+     if (WSRVal<0x30) WinStart=(WSRVal-0x20) << 6;
+     else WinStart=(WSRVal+0x40) << 6;
+     WinStop=WinStart+0x3f;
+    END
+   else if (WSRVal<=0x7f)
+    BEGIN
+     WinBegin=0xe0; WinEnd=0xff;
+     if (WSRVal<0x60) WinStart=(WSRVal-0x40) << 5;
+     else WinStart=(WSRVal+0x80) << 5;
+     WinStop=WinStart+0x1f;
+    END
+   if ((WinStop>0x1fdf) AND (MomCPU<CPU80296)) WinStop=0x1fdf;
+END
+
+        static void CalcWSR1Window(void)
+BEGIN
+   if (WSR1Val<=0x1f)
+    BEGIN
+     Win1Start=0xffff; Win1Stop=0; Win1Begin=0xff; Win1End=0;
+    END
+   else if (WSR1Val<=0x3f)
+    BEGIN
+     Win1Begin=0x40; Win1End=0x7f;
+     if (WSR1Val<0x30) Win1Start=(WSR1Val-0x20) << 6;
+     else Win1Start=(WSR1Val+0x40) << 6;
+     Win1Stop=Win1Start+0x3f;
+    END
+   else if (WSR1Val<=0x7f)
+    BEGIN
+     Win1Begin=0x60; Win1End=0x7f;
+     if (WSR1Val<0x60) Win1Start=(WSR1Val-0x40) << 5;
+     else Win1Start=(WSR1Val+0x80) << 5;
+     Win1Stop=Win1Start+0x1f;
+    END
+   else
+    BEGIN
+     Win1Begin=0x40; Win1End=0x7f;
+     Win1Start=(WSR1Val+0x340) << 6;
+     Win1Stop=Win1Start+0x3f;
+    END
+END
+
+	static Boolean DecodePseudo(void)
+BEGIN
+#define ASSUME96Count 2
+   static ASSUMERec ASSUME96s[ASSUME96Count]=
+	     {{"WSR", &WSRVal, 0, 0xff, 0x00},
+              {"WSR1", &WSR1Val, 0, 0xbf, 0x00}};
+
+   if (Memo("ASSUME"))
+    BEGIN
+     if (MomCPU<CPU80196) WrError(1500);
+     else CodeASSUME(ASSUME96s,(MomCPU>=CPU80296)?ASSUME96Count:1);
+     WSRVal&=0x7f;
+     CalcWSRWindow(); CalcWSR1Window();
+     return True;
+    END
+
+   return False;
+END
+
+	static Boolean BMemo(char *Name)
+BEGIN
+   int l;
+
+   if (strncmp(OpPart,Name,l=strlen(Name))!=0) return False;
+   switch (OpPart[l])
+    BEGIN
+     case '\0':
+      OpSize=1; return True;
+     case 'B':
+      if (OpPart[l+1]=='\0')
+       BEGIN
+        OpSize=0; return True;
+       END
+      else return False;
+     default:
+      return False;
+    END
+END
+
+	static Boolean LMemo(char *Name)
+BEGIN
+   int l;
+
+   if (strncmp(OpPart,Name,l=strlen(Name))!=0) return False;
+   switch (OpPart[l])
+    BEGIN
+     case '\0':
+      OpSize=1; return True;
+     case 'B':
+      if (OpPart[l+1]=='\0')
+       BEGIN
+        OpSize=0; return True;
+       END
+      else return False;
+     case 'L':
+      if (OpPart[l+1]=='\0')
+       BEGIN
+        OpSize=2; return True;
+       END
+      else return False;
+     default:
+      return False;
+    END
+END
+
+	static void MakeCode_96(void)
+BEGIN
+   Boolean OK,Special,IsShort;
+   Word AdrWord;
+   int z;
+   LongInt AdrInt;
+   Byte Start,HReg,Mask;
+
+   CodeLen=0; DontPrint=False; OpSize=(-1);
+
+   /* zu ignorierendes */
+
+   if (Memo("")) return;
+
+   /* Pseudoanweisungen */
+
+   if (DecodePseudo()) return;
+
+   if (DecodeIntelPseudo(False)) return;
+
+   /* ohne Argument */
+
+   for (z=0; z<FixedOrderCnt; z++)
+    if (Memo(FixedOrders[z].Name))
+     BEGIN
+      if (ArgCnt!=0) WrError(1110);
+      else if (MomCPU<FixedOrders[z].MinCPU) WrError(1500);
+      else BAsmCode[(CodeLen=1)-1]=FixedOrders[z].Code;
+      return;
+     END
+
+   /* Arithmetik */
+
+   for (z=0; z<ALU3OrderCnt; z++)
+    if (BMemo(ALU3Orders[z].Name))
+     BEGIN
+      if ((ArgCnt!=2) AND (ArgCnt!=3)) WrError(1110);
+      else
+       BEGIN
+        Start=0; Special=(strncmp(ALU3Orders[z].Name,"MUL",3)==0);
+        if ((ALU3Orders[z].Code & 0x80)!=0) BAsmCode[Start++]=0xfe;
+        BAsmCode[Start++]=0x40+(Ord(ArgCnt==2) << 5)
+       		          +((1-OpSize) << 4)
+       		          +((ALU3Orders[z].Code & 0x7f) << 2);
+        DecodeAdr(ArgStr[ArgCnt],MModImm+MModMem,False);
+        if (AdrType!=ModNone)
+         BEGIN
+          BAsmCode[Start-1]+=AdrMode;
+          memcpy(BAsmCode+Start,AdrVals,AdrCnt); Start+=AdrCnt;
+          if ((Special) AND (AdrMode==0)) ChkSFR(AdrVals[0]);
+          if (ArgCnt==3)
+           BEGIN
+            DecodeAdr(ArgStr[2],MModDir,False);
+            OK=(AdrType!=ModNone);
+            if (OK)
+             BEGIN
+              BAsmCode[Start++]=AdrVals[0];
+              if (Special) ChkSFR(AdrVals[0]);
+             END
+           END
+          else OK=True;
+          if (OK)
+           BEGIN
+            DecodeAdr(ArgStr[1],MModDir,False);
+            if (AdrType!=ModNone)
+             BEGIN
+              BAsmCode[Start]=AdrVals[0]; CodeLen=Start+1;
+              if (Special)
+       	       BEGIN
+       	        ChkSFR(AdrVals[0]);
+                Chk296(AdrVals[0]);
+                ChkAlign(AdrVals[0]);
+       	       END
+             END
+           END
+         END
+       END
+      return;
+     END
+
+   for (z=0; z<ALU2OrderCnt; z++)
+    if (BMemo(ALU2Orders[z].Name))
+     BEGIN
+      if (ArgCnt!=2) WrError(1110);
+      else
+       BEGIN
+        Start=0; Special=(strncmp(OpPart,"DIV",3)==0);
+        if (strcmp(ALU2Orders[z].Name,"DIV")==0) BAsmCode[Start++]=0xfe;
+        HReg=(1+Ord(strcmp(ALU2Orders[z].Name,"ST")!=0)) << 1;
+        BAsmCode[Start++]=ALU2Orders[z].Code+((1-OpSize) << HReg);
+        Mask=MModMem; if (NOT BMemo("ST")) Mask+=MModImm;
+        DecodeAdr(ArgStr[2],Mask,False);
+        if (AdrType!=ModNone)
+         BEGIN
+          BAsmCode[Start-1]+=AdrMode;
+          memcpy(BAsmCode+Start,AdrVals,AdrCnt); Start+=AdrCnt;
+          if ((Special) AND (AdrMode==0)) ChkSFR(AdrVals[0]);
+          DecodeAdr(ArgStr[1],MModDir,False);
+          if (AdrType!=ModNone)
+           BEGIN
+            BAsmCode[Start]=AdrVals[0]; CodeLen=1+Start;
+            if (Special)
+             BEGIN
+              ChkSFR(AdrVals[0]); ChkAlign(AdrVals[0]);
+             END
+           END
+         END
+       END
+      return;
+     END
+
+   if (Memo("CMPL"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (MomCPU<CPU80196) WrError(1500);
+     else
+      BEGIN
+       OpSize=2;
+       DecodeAdr(ArgStr[1],MModDir,False);
+       if (AdrType!=ModNone)
+        BEGIN
+         BAsmCode[2]=AdrVals[0];
+         DecodeAdr(ArgStr[2],MModDir,False);
+         if (AdrType!=ModNone)
+          BEGIN
+           BAsmCode[1]=AdrVals[0]; BAsmCode[0]=0xc5; CodeLen=3;
+          END
+        END
+      END
+     return;
+    END
+
+   if ((Memo("PUSH")) OR (Memo("POP")))
+    BEGIN
+     OpSize=1;
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       Mask=MModMem; if (Memo("PUSH")) Mask+=MModImm;
+       DecodeAdr(ArgStr[1],Mask,False);
+       if (AdrType!=ModNone)
+	BEGIN
+	 CodeLen=1+AdrCnt;
+	 BAsmCode[0]=0xc8+AdrMode+(Ord(Memo("POP")) << 2);
+	 memcpy(BAsmCode+1,AdrVals,AdrCnt);
+	END
+      END
+     return;
+    END
+
+   if ((Memo("BMOV")) OR (Memo("BMOVI")) OR (Memo("EBMOVI")))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (MomCPU<CPU80196) WrError(1500);
+     else if ((MomCPU<CPU80196N) AND (Memo("EBMOVI"))) WrError(1500);
+     else
+      BEGIN
+       OpSize=2; DecodeAdr(ArgStr[1],MModDir,False);
+       if (AdrType!=ModNone)
+        BEGIN
+         BAsmCode[2]=AdrVals[0];
+         OpSize=1; DecodeAdr(ArgStr[2],MModDir,False);
+         if (AdrType!=ModNone)
+          BEGIN
+           BAsmCode[1]=AdrVals[0];
+           if (Memo("BMOVI")) BAsmCode[0]=0xad;
+           else if (Memo("BMOV")) BAsmCode[0]=0xc1;
+           else BAsmCode[0]=0xe4;          
+           CodeLen=3;
+          END
+        END
+      END
+     return;
+    END
+
+   for (z=0; z<ALU1OrderCnt; z++)
+    if (BMemo(ALU1Orders[z].Name))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else
+       BEGIN
+        DecodeAdr(ArgStr[1],MModDir,False);
+        if (AdrType!=ModNone)
+         BEGIN
+          CodeLen=1+AdrCnt;
+          BAsmCode[0]=ALU1Orders[z].Code+((1-OpSize) << 4);
+          memcpy(BAsmCode+1,AdrVals,AdrCnt);
+          if (BMemo("EXT")) ChkAlign(AdrVals[0]);
+         END
+       END
+      return;
+     END
+
+   if (BMemo("XCH"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (MomCPU<CPU80196) WrError(1500);
+     else
+      BEGIN
+       DecodeAdr(ArgStr[1],MModMem+MModDir,False);
+       switch (AdrType)
+        BEGIN
+         case ModMem:
+          if (AdrMode==1) WrError(1350);
+          else
+           BEGIN
+            memcpy(BAsmCode+1,AdrVals,AdrCnt); HReg=AdrCnt;
+            BAsmCode[0]=0x04+((1-OpSize) << 4)+AdrMode;
+            DecodeAdr(ArgStr[2],MModDir,False);
+            if (AdrType!=ModNone)
+             BEGIN
+              BAsmCode[1+HReg]=AdrVals[0]; CodeLen=2+HReg;
+             END
+           END
+          break;
+         case ModDir:
+          HReg=AdrVals[0];
+          DecodeAdr(ArgStr[2],MModMem,False);
+          if (AdrType!=ModNone)
+           if (AdrMode==1) WrError(1350);
+           else
+            BEGIN
+             BAsmCode[0]=0x04+((1-OpSize) << 4)+AdrMode;
+             memcpy(BAsmCode+1,AdrVals,AdrCnt);
+             BAsmCode[1+AdrCnt]=HReg; CodeLen=2+AdrCnt;
+            END
+          break;
+        END
+      END
+     return;
+    END
+
+   if ((Memo("LDBZE")) OR (Memo("LDBSE")))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else
+      BEGIN
+       OpSize=0;
+       DecodeAdr(ArgStr[2],MModMem+MModImm,False);
+       if (AdrType!=ModNone)
+	BEGIN
+	 BAsmCode[0]=0xac+(Ord(Memo("LDBSE")) << 4)+AdrMode;
+	 memcpy(BAsmCode+1,AdrVals,AdrCnt); Start=1+AdrCnt;
+	 OpSize=1; DecodeAdr(ArgStr[1],MModDir,False);
+	 if (AdrType!=ModNone)
+	  BEGIN
+	   BAsmCode[Start]=AdrVals[0]; CodeLen=1+Start;
+	  END
+	END
+      END
+     return;
+    END
+
+   if (Memo("NORML"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else
+      BEGIN
+       OpSize=0; DecodeAdr(ArgStr[2],MModDir,False);
+       if (AdrType!=ModNone)
+	BEGIN
+	 BAsmCode[1]=AdrVals[0];
+	 OpSize=1; DecodeAdr(ArgStr[1],MModDir,False);
+	 if (AdrType!=ModNone)
+	  BEGIN
+	   CodeLen=3; BAsmCode[0]=0x0f; BAsmCode[2]=AdrVals[0];
+	   ChkAlign(AdrVals[0]);
+	  END
+	END
+      END
+     return;
+    END
+
+   if (Memo("IDLPD"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU80196) WrError(1500);
+     else
+      BEGIN
+       OpSize=0; DecodeAdr(ArgStr[1],MModImm,False);
+       if (AdrType!=ModNone)
+        BEGIN
+         CodeLen=2; BAsmCode[0]=0xf6; BAsmCode[1]=AdrVals[0];
+        END
+      END
+     return;
+    END
+
+   for (z=0; z<ShiftOrderCnt; z++)
+    if (LMemo(ShiftOrders[z]))
+     BEGIN
+      if (ArgCnt!=2) WrError(1110);
+      else
+       BEGIN
+	DecodeAdr(ArgStr[1],MModDir,False);
+	if (AdrType!=ModNone)
+	 BEGIN
+	  BAsmCode[0]=0x08+z+(Ord(OpSize==0) << 4)+(Ord(OpSize==2) << 2);
+	  BAsmCode[2]=AdrVals[0];
+	  OpSize=0; DecodeAdr(ArgStr[2],MModDir+MModImm,False);
+	  if (AdrType!=ModNone)
+	   if ((AdrType==ModImm) AND (AdrVals[0]>15)) WrError(1320);
+	   else if ((AdrType==ModDir) AND (AdrVals[0]<16)) WrError(1315);
+	   else
+	    BEGIN
+	     BAsmCode[1]=AdrVals[0]; CodeLen=3;
+	    END
+	 END
+       END
+      return;
+     END
+
+   if (Memo("SKIP"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       OpSize=0; DecodeAdr(ArgStr[1],MModDir,False);
+       if (AdrType!=ModNone)
+	BEGIN
+	 CodeLen=2; BAsmCode[0]=0; BAsmCode[1]=AdrVals[0];
+	END
+      END
+     return;
+    END
+
+   if ((BMemo("ELD")) OR (BMemo("EST")))
+    BEGIN 
+     if (ArgCnt!=2) WrError(1110);
+     else if (MomCPU<CPU80196N) WrError(1500);
+     else
+      BEGIN
+       DecodeAdr(ArgStr[2],MModMem,True);
+       if (AdrType==ModMem)
+        if ((AdrMode==2) AND (Odd(AdrVals[0]))) WrError(1350); /* kein Autoincrement */
+        else
+         BEGIN
+          BAsmCode[0]=(AdrMode & 1)+((1-OpSize) << 1);
+          if (OpPart[1]=='L') BAsmCode[0]+=0xe8;
+                         else BAsmCode[0]+=0x1c;
+          memcpy(BAsmCode+1,AdrVals,AdrCnt); HReg=1+AdrCnt;
+          DecodeAdr(ArgStr[1],MModDir,False);
+          if (AdrType==ModDir)  
+           BEGIN
+            BAsmCode[HReg]=AdrVals[0]; CodeLen=HReg+1;
+           END; 
+         END;
+      END;
+     return;
+    END
+
+   for (z=0; z<MacOrderCnt; z++)
+    if (Memo(MacOrders[z].Name))
+     BEGIN
+      if ((ArgCnt!=1) AND (ArgCnt!=2)) WrError(1110);
+      else if (MomCPU<CPU80296) WrError(1500);
+      else
+       BEGIN
+        OpSize=1; BAsmCode[0]=0x4c+(Ord(ArgCnt==1) << 5);
+        if (MacOrders[z].Reloc) DecodeAdr(ArgStr[ArgCnt],MModMem,False);
+        else DecodeAdr(ArgStr[ArgCnt],MModMem+MModImm,False);
+        if (AdrType!=ModNone)
+         BEGIN
+          BAsmCode[0]+=AdrMode;
+          memcpy(BAsmCode+1,AdrVals,AdrCnt); HReg=1+AdrCnt;
+          if (ArgCnt==2)
+           BEGIN
+            DecodeAdr(ArgStr[1],MModDir,False);
+            if (AdrType==ModDir)
+             BEGIN
+              BAsmCode[HReg]=AdrVals[0]; HReg++;
+             END
+           END
+          if (AdrType!=ModNone)
+           BEGIN
+            BAsmCode[HReg]=MacOrders[z].Code; CodeLen=1+HReg;
+           END
+         END  
+       END
+      return;
+     END
+
+   if ((Memo("MVAC")) OR (Memo("MSAC")))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (MomCPU<CPU80296) WrError(1500);
+     else
+      BEGIN
+       OpSize=2; DecodeAdr(ArgStr[1],MModDir,False);
+       if (AdrType==ModDir)
+        BEGIN
+         BAsmCode[0]=0x0d; BAsmCode[2]=AdrVals[0]+1+(Ord(Memo("MSAC")) << 1);
+         OpSize=0; DecodeAdr(ArgStr[2],MModImm+MModDir,False);
+         BAsmCode[1]=AdrVals[0];
+         switch (AdrType)
+          BEGIN
+           case ModImm:
+            if (AdrVals[0]>31) WrError(1320); else CodeLen=3;
+            break;
+           case ModDir:
+            if (AdrVals[0]<32) WrError(1315); else CodeLen=3;
+          END
+        END 
+      END      
+     return;  
+    END        
+
+   for (z=0; z<RptOrderCnt; z++)
+    if (Memo(RptOrders[z].Name))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (MomCPU<CPU80296) WrError(1500);
+      else
+       BEGIN
+        OpSize=1; DecodeAdr(ArgStr[1],MModImm+MModMem,False);
+        if (AdrType!=ModNone)
+         if (AdrMode==3) WrError(1350);
+         else   
+          BEGIN
+           BAsmCode[0]=0x40+AdrMode;
+           memcpy(BAsmCode+1,AdrVals,AdrCnt);
+           BAsmCode[1+AdrCnt]=RptOrders[z].Code;
+           BAsmCode[2+AdrCnt]=4;
+           CodeLen=3+AdrCnt;
+          END
+       END
+      return;
+     END
+
+   /* Spruenge */
+
+   for (z=0; z<RelOrderCnt; z++)
+    if (Memo(RelOrders[z].Name))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else
+       BEGIN
+        AdrInt=EvalIntExpression(ArgStr[1],MemInt,&OK)-(EProgCounter()+2);
+        if (OK)
+         if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+         else
+          BEGIN
+           CodeLen=2; BAsmCode[0]=RelOrders[z].Code; BAsmCode[1]=AdrInt & 0xff;
+          END
+       END
+      return;
+     END
+
+   if ((Memo("SCALL")) OR (Memo("LCALL")) OR (Memo("CALL")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       AdrWord=EvalIntExpression(ArgStr[1],MemInt,&OK);
+       if (OK)
+	BEGIN
+	 AdrInt=AdrWord-(EProgCounter()+2);
+	 if (Memo("SCALL")) IsShort=True;
+	 else if (Memo("LCALL")) IsShort=False;
+	 else IsShort=((AdrInt>=-1024) AND (AdrInt<1023));
+	 if (IsShort)
+	  BEGIN
+	   if ((NOT SymbolQuestionable) AND ((AdrInt<-1024) OR (AdrInt>1023))) WrError(1370);
+	   else
+	    BEGIN
+	     CodeLen=2; BAsmCode[1]=AdrInt & 0xff;
+	     BAsmCode[0]=0x28+((AdrInt & 0x700) >> 8);
+	    END
+	  END
+	 else
+	  BEGIN
+           CodeLen=3; BAsmCode[0]=0xef; AdrInt--;
+           BAsmCode[1]=Lo(AdrInt); BAsmCode[2]=Hi(AdrInt);
+	   if ((NOT SymbolQuestionable) AND (AdrInt>=-1024) AND (AdrInt<=1023)) WrError(20);
+	  END
+	END
+      END
+     return;
+    END
+
+   if ((Memo("BR")) OR (Memo("LJMP")) OR (Memo("SJMP")))
+    BEGIN
+     OpSize=1;
+     if (ArgCnt!=1) WrError(1110);
+     else if ((Memo("BR")) AND (QuotPos(ArgStr[1],'[')!=Nil))
+      BEGIN
+       DecodeAdr(ArgStr[1],MModMem,False);
+       if (AdrType!=ModNone)
+	if ((AdrMode!=2) OR ((AdrVals[0]&1)==1)) WrError(1350);
+	else
+	 BEGIN
+	  CodeLen=2; BAsmCode[0]=0xe3; BAsmCode[1]=AdrVals[0];
+	 END
+      END
+     else
+      BEGIN
+       AdrWord=EvalIntExpression(ArgStr[1],MemInt,&OK);
+       if (OK)
+	BEGIN
+	 AdrInt=AdrWord-(EProgCounter()+2);
+	 if (Memo("SJMP")) IsShort=True;
+	 else if (Memo("LJMP")) IsShort=False;
+	 else IsShort=((AdrInt>=-1024) AND (AdrInt<1023));
+	 if (IsShort)
+	  BEGIN
+	   if ((NOT SymbolQuestionable) AND ((AdrInt<-1024) OR (AdrInt>1023))) WrError(1370);
+	   else
+	    BEGIN
+	     CodeLen=2; BAsmCode[1]=AdrInt & 0xff;
+	     BAsmCode[0]=0x20+((AdrInt & 0x700) >> 8);
+	    END
+	  END
+	 else
+	  BEGIN
+           CodeLen=3; BAsmCode[0]=0xe7; AdrInt--;
+           BAsmCode[1]=Lo(AdrInt); BAsmCode[2]=Hi(AdrInt);
+	   if ((NOT SymbolQuestionable) AND (AdrInt>=-1024) AND (AdrInt<=1023)) WrError(20);
+	  END
+	END
+      END
+     return;
+    END
+
+   if (Memo("TIJMP"))
+    BEGIN
+     if (ArgCnt!=3) WrError(1110);
+     else if (MomCPU<CPU80196) WrError(1500);
+     else
+      BEGIN
+       OpSize=1; DecodeAdr(ArgStr[1],MModDir,False);
+       if (AdrType!=ModNone)
+        BEGIN
+         BAsmCode[3]=AdrVals[0];
+         DecodeAdr(ArgStr[2],MModDir,False);
+         if (AdrType!=ModNone)
+          BEGIN
+           BAsmCode[1]=AdrVals[0];
+           OpSize=0; DecodeAdr(ArgStr[3],MModImm,False);
+           if (AdrType!=ModNone)
+            BEGIN
+             BAsmCode[2]=AdrVals[0]; BAsmCode[0]=0xe2; CodeLen=4;
+            END
+          END
+        END
+      END
+     return;
+    END
+
+   if ((Memo("DJNZ")) OR (Memo("DJNZW")))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if ((Memo("DJNZW")) AND (MomCPU<CPU80196)) WrError(1500);
+     else
+      BEGIN
+       OpSize=Ord(Memo("DJNZW"));
+       DecodeAdr(ArgStr[1],MModDir,False);
+       if (AdrType!=ModNone)
+	BEGIN
+	 BAsmCode[0]=0xe0+OpSize; BAsmCode[1]=AdrVals[0];
+	 AdrInt=EvalIntExpression(ArgStr[2],MemInt,&OK)-(EProgCounter()+3);
+	 if (OK)
+	  if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+	  else
+	   BEGIN
+	    CodeLen=3; BAsmCode[2]=AdrInt & 0xff;
+	   END
+	END
+      END
+     return;
+    END
+
+   if ((Memo("JBC")) OR (Memo("JBS")))
+    BEGIN
+     if (ArgCnt!=3) WrError(1110);
+     else
+      BEGIN
+       BAsmCode[0]=EvalIntExpression(ArgStr[2],UInt3,&OK);
+       if (OK)
+	BEGIN
+	 BAsmCode[0]+=0x30+(Ord(Memo("JBS")) << 3);
+	 OpSize=0; DecodeAdr(ArgStr[1],MModDir,False);
+	 if (AdrType!=ModNone)
+	  BEGIN
+	   BAsmCode[1]=AdrVals[0];
+	   AdrInt=EvalIntExpression(ArgStr[3],MemInt,&OK)-(EProgCounter()+3);
+	   if (OK)
+	    if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+	    else
+	     BEGIN
+	      CodeLen=3; BAsmCode[2]=AdrInt & 0xff;
+	     END
+	  END
+	END
+      END
+     return;
+    END
+
+   if (Memo("ECALL"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU80196N) WrError(1500);
+     else  
+      BEGIN
+       AdrInt=EvalIntExpression(ArgStr[1],MemInt,&OK)-(EProgCounter()+4);
+       if (OK)
+        BEGIN
+         BAsmCode[0]=0xf1;
+         BAsmCode[1]=AdrInt & 0xff;
+         BAsmCode[2]=(AdrInt >> 8) & 0xff; 
+         BAsmCode[3]=(AdrInt >> 16) & 0xff;
+         CodeLen=4;
+        END
+      END
+     return;
+    END
+
+   if ((Memo("EJMP")) OR (Memo("EBR")))
+    BEGIN
+     OpSize=1;
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU80196N) WrError(1500);
+     else if (*ArgStr[1]=='[')
+      BEGIN
+       DecodeAdr(ArgStr[1],MModMem,False);
+       if (AdrType==ModMem)
+        if (AdrMode!=2) WrError(1350);
+        else if (Odd(AdrVals[0])) WrError(1350);
+        else
+         BEGIN
+          BAsmCode[0]=0xe3; BAsmCode[1]=AdrVals[0]+1;
+          CodeLen=2;
+         END
+      END
+     else
+      BEGIN
+       AdrInt=EvalIntExpression(ArgStr[1],MemInt,&OK)-(EProgCounter()+4);
+       if (OK)
+        BEGIN
+         BAsmCode[0]=0xe6;
+         BAsmCode[1]=AdrInt & 0xff;
+         BAsmCode[2]=(AdrInt >> 8) & 0xff;
+         BAsmCode[3]=(AdrInt >> 16) & 0xff;
+         CodeLen=4;
+        END
+      END  
+     return;
+    END    
+
+   WrXError(1200,OpPart);
+END
+
+	static void InitCode_96(void)
+BEGIN
+   SaveInitProc();
+   WSRVal=0; CalcWSRWindow();
+   WSR1Val=0; CalcWSR1Window();
+END
+
+	static Boolean IsDef_96(void)
+BEGIN
+   return False;
+END
+
+        static void SwitchFrom_96(void)
+BEGIN
+   DeinitFields();
+END
+
+	static void SwitchTo_96(void)
+BEGIN
+   TurnWords=False; ConstMode=ConstModeIntel; SetIsOccupied=False;
+
+   PCSymbol="$"; HeaderID=0x39; NOPCode=0xfd;
+   DivideChars=","; HasAttrs=False;
+
+   ValidSegs=1<<SegCode;
+   Grans[SegCode ]=1; ListGrans[SegCode ]=1; SegInits[SegCode ]=0;
+   SegLimits[SegCode] = (MomCPU >= CPU80196N) ? 0xffffffl : 0xffff;
+
+   MakeCode=MakeCode_96; IsDef=IsDef_96;
+   SwitchFrom=SwitchFrom_96;
+
+   if (MomCPU>=CPU80196N) MemInt=UInt24;
+   else MemInt=UInt16;
+
+   InitFields();
+END
+
+	void code96_init(void)
+BEGIN
+   CPU8096  =AddCPU("8096"  ,SwitchTo_96);
+   CPU80196 =AddCPU("80196" ,SwitchTo_96);
+   CPU80196N=AddCPU("80196N",SwitchTo_96);
+   CPU80296 =AddCPU("80296" ,SwitchTo_96);
+
+   SaveInitProc=InitPassProc; InitPassProc=InitCode_96;
+END
-- 
cgit v1.2.3