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

---
 code78c10.c | 978 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 978 insertions(+)
 create mode 100644 code78c10.c

(limited to 'code78c10.c')

diff --git a/code78c10.c b/code78c10.c
new file mode 100644
index 0000000..67afa96
--- /dev/null
+++ b/code78c10.c
@@ -0,0 +1,978 @@
+/* code78c10.c */
+/*****************************************************************************/
+/* AS-Portierung                                                             */
+/*                                                                           */
+/* Codegenerator NEC uPD78(C)1x                                              */
+/*                                                                           */
+/* Historie: 29.12.1996 Grundsteinlegung                                     */
+/*            2. 1.1999 ChkPC-Anpassung                                      */
+/*                                                                           */
+/*****************************************************************************/
+
+#include "stdinc.h"
+#include <ctype.h>
+#include <string.h>
+
+#include "bpemu.h"
+#include "strutil.h"
+#include "asmdef.h"
+#include "asmsub.h"
+#include "asmpars.h"
+#include "codepseudo.h"
+#include "codevars.h"
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct
+         {
+          char *Name;
+          Word Code;
+         } FixedOrder;
+
+typedef struct
+         {
+          char *Name;
+          Byte Code;
+         } SReg;
+
+#define FixedOrderCnt 23
+#define ALUOrderCnt 15
+#define AbsOrderCnt 10
+#define Reg2OrderCnt 10
+#define WorkOrderCnt 4
+#define EAOrderCnt 4
+#define SRegCnt 28
+
+
+static LongInt WorkArea;
+
+static SimpProc SaveInitProc;
+
+static CPUVar CPU7810,CPU78C10;
+
+static FixedOrder *FixedOrders;
+static Byte *ALUOrderCodes;
+static char **ALUOrderImmOps,**ALUOrderRegOps,**ALUOrderEAOps;
+static FixedOrder *AbsOrders;
+static FixedOrder *Reg2Orders;
+static FixedOrder *WorkOrders;
+static FixedOrder *EAOrders;
+static SReg *SRegs;
+
+/*--------------------------------------------------------------------------------*/
+
+	static void AddFixed(char *NName, Word NCode)
+BEGIN
+   if (InstrZ>=FixedOrderCnt) exit(255);
+   FixedOrders[InstrZ].Name=NName;
+   FixedOrders[InstrZ++].Code=NCode;
+END
+
+	static void AddSReg(char *NName, Word NCode)
+BEGIN
+   if (InstrZ>=SRegCnt) exit(255);
+   SRegs[InstrZ].Name=NName;
+   SRegs[InstrZ++].Code=NCode;
+END
+
+	static void AddALU(Byte NCode, char *NName1, char *NName2, char *NName3)
+BEGIN
+   if (InstrZ>=ALUOrderCnt) exit(255);
+   ALUOrderCodes[InstrZ]=NCode;
+   ALUOrderImmOps[InstrZ]=NName1;
+   ALUOrderRegOps[InstrZ]=NName2;
+   ALUOrderEAOps[InstrZ++]=NName3;
+END
+
+        static void AddAbs(char *NName, Word NCode)
+BEGIN
+   if (InstrZ>=AbsOrderCnt) exit(255);
+   AbsOrders[InstrZ].Name=NName;
+   AbsOrders[InstrZ++].Code=NCode;
+END
+
+        static void AddReg2(char *NName, Word NCode)
+BEGIN
+   if (InstrZ>=Reg2OrderCnt) exit(255);
+   Reg2Orders[InstrZ].Name=NName;
+   Reg2Orders[InstrZ++].Code=NCode;
+END
+
+        static void AddWork(char *NName, Word NCode)
+BEGIN
+   if (InstrZ>=WorkOrderCnt) exit(255);
+   WorkOrders[InstrZ].Name=NName;
+   WorkOrders[InstrZ++].Code=NCode;
+END
+
+        static void AddEA(char *NName, Word NCode)
+BEGIN
+   if (InstrZ>=EAOrderCnt) exit(255);
+   EAOrders[InstrZ].Name=NName;
+   EAOrders[InstrZ++].Code=NCode;
+END
+
+	static void InitFields(void)
+BEGIN
+   FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0;
+   AddFixed("EXX"  , 0x0011); AddFixed("EXA"  , 0x0010);
+   AddFixed("EXH"  , 0x0050); AddFixed("BLOCK", 0x0031);
+   AddFixed("TABLE", 0x48a8); AddFixed("DAA"  , 0x0061);
+   AddFixed("STC"  , 0x482b); AddFixed("CLC"  , 0x482a);
+   AddFixed("NEGA" , 0x483a); AddFixed("RLD"  , 0x4838);
+   AddFixed("RRD"  , 0x4839); AddFixed("JB"   , 0x0021);
+   AddFixed("JEA"  , 0x4828); AddFixed("CALB" , 0x4829);
+   AddFixed("SOFTI", 0x0072); AddFixed("RET"  , 0x00b8);
+   AddFixed("RETS" , 0x00b9); AddFixed("RETI" , 0x0062);
+   AddFixed("NOP"  , 0x0000); AddFixed("EI"   , 0x00aa);
+   AddFixed("DI"   , 0x00ba); AddFixed("HLT"  , 0x483b);
+   AddFixed("STOP" , 0x48bb);
+
+   SRegs=(SReg *) malloc(sizeof(SReg)*SRegCnt); InstrZ=0;
+   AddSReg("PA"  , 0x00); AddSReg("PB"  , 0x01);
+   AddSReg("PC"  , 0x02); AddSReg("PD"  , 0x03);
+   AddSReg("PF"  , 0x05); AddSReg("MKH" , 0x06);
+   AddSReg("MKL" , 0x07); AddSReg("ANM" , 0x08);
+   AddSReg("SMH" , 0x09); AddSReg("SML" , 0x0a);
+   AddSReg("EOM" , 0x0b); AddSReg("ETNM", 0x0c);
+   AddSReg("TMM" , 0x0d); AddSReg("MM"  , 0x10);
+   AddSReg("MCC" , 0x11); AddSReg("MA"  , 0x12);
+   AddSReg("MB"  , 0x13); AddSReg("MC"  , 0x14);
+   AddSReg("MF"  , 0x17); AddSReg("TXB" , 0x18);
+   AddSReg("RXB" , 0x19); AddSReg("TM0" , 0x1a);
+   AddSReg("TM1" , 0x1b); AddSReg("CR0" , 0x20);
+   AddSReg("CR1" , 0x21); AddSReg("CR2" , 0x22);
+   AddSReg("CR3" , 0x23); AddSReg("ZCM" , 0x28);
+
+   ALUOrderCodes=(Byte *) malloc(sizeof(Byte)*ALUOrderCnt);
+   ALUOrderImmOps=(char **) malloc(sizeof(char *)*ALUOrderCnt);
+   ALUOrderRegOps=(char **) malloc(sizeof(char *)*ALUOrderCnt);
+   ALUOrderEAOps=(char **) malloc(sizeof(char *)*ALUOrderCnt); InstrZ=0;
+   AddALU(10,"ACI"  ,"ADC"  ,"DADC"  );
+   AddALU( 4,"ADINC","ADDNC","DADDNC");
+   AddALU( 8,"ADI"  ,"ADD"  ,"DADD"  );
+   AddALU( 1,"ANI"  ,"ANA"  ,"DAN"   );
+   AddALU(15,"EQI"  ,"EQA"  ,"DEQ"   );
+   AddALU( 5,"GTI"  ,"GTA"  ,"DGT"   );
+   AddALU( 7,"LTI"  ,"LTA"  ,"DLT"   );
+   AddALU(13,"NEI"  ,"NEA"  ,"DNE"   );
+   AddALU(11,"OFFI" ,"OFFA" ,"DOFF"  );
+   AddALU( 9,"ONI"  ,"ONA"  ,"DON"   );
+   AddALU( 3,"ORI"  ,"ORA"  ,"DOR"   );
+   AddALU(14,"SBI"  ,"SBB"  ,"DSBB"  );
+   AddALU( 6,"SUINB","SUBNB","DSUBNB");
+   AddALU(12,"SUI"  ,"SUB"  ,"DSUB"  );
+   AddALU( 2,"XRI"  ,"XRA"  ,"DXR"   );
+
+   AbsOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*AbsOrderCnt); InstrZ=0;
+   AddAbs("CALL", 0x0040); AddAbs("JMP" , 0x0054);
+   AddAbs("LBCD", 0x701f); AddAbs("LDED", 0x702f);
+   AddAbs("LHLD", 0x703f); AddAbs("LSPD", 0x700f);
+   AddAbs("SBCD", 0x701e); AddAbs("SDED", 0x702e);
+   AddAbs("SHLD", 0x703e); AddAbs("SSPD", 0x700e);
+
+   Reg2Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*Reg2OrderCnt); InstrZ=0;
+   AddReg2("DCR" , 0x0050); AddReg2("DIV" , 0x483c);
+   AddReg2("INR" , 0x0040); AddReg2("MUL" , 0x482c);
+   AddReg2("RLL" , 0x4834); AddReg2("RLR" , 0x4830);
+   AddReg2("SLL" , 0x4824); AddReg2("SLR" , 0x4820);
+   AddReg2("SLLC", 0x4804); AddReg2("SLRC", 0x4800);
+
+   WorkOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*WorkOrderCnt); InstrZ=0;
+   AddWork("DCRW", 0x33); AddWork("INRW", 0x20);
+   AddWork("LDAW", 0x01); AddWork("STAW", 0x63);
+
+   EAOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*EAOrderCnt); InstrZ=0;
+   AddEA("DRLL", 0x48b4); AddEA("DRLR", 0x48b0);
+   AddEA("DSLL", 0x48a4); AddEA("DSLR", 0x48a0);
+END
+
+	static void DeinitFields(void)
+BEGIN
+   free(FixedOrders);
+   free(ALUOrderCodes); free(ALUOrderImmOps); free(ALUOrderRegOps); free(ALUOrderEAOps);
+   free(AbsOrders);
+   free(Reg2Orders);
+   free(WorkOrders);
+   free(EAOrders);
+   free(SRegs);
+END
+
+/*--------------------------------------------------------------------------------*/
+
+	static Boolean Decode_r(char *Asc, ShortInt *Erg)
+BEGIN
+   static char *Names="VABCDEHL";
+   char *p;
+
+   if (strlen(Asc)!=1) return False;
+   p=strchr(Names,toupper(*Asc));
+   if (p==Nil) return False;
+   *Erg=p-Names; return True;;
+END
+
+	static Boolean Decode_r1(char *Asc, ShortInt *Erg)
+BEGIN
+   if (strcasecmp(Asc,"EAL")==0) *Erg=1;
+   else if (strcasecmp(Asc,"EAH")==0) *Erg=0;
+   else
+    BEGIN
+     if (NOT Decode_r(Asc,Erg)) return False;
+     return (*Erg>1);
+    END
+   return True;
+END
+
+	static Boolean Decode_r2(char *Asc, ShortInt *Erg)
+BEGIN
+   if (NOT Decode_r(Asc,Erg)) return False;
+   return ((*Erg>0) AND (*Erg<4));
+END
+
+	static Boolean Decode_rp2(char *Asc, ShortInt *Erg)
+BEGIN
+#define RegCnt 5
+   static char *Regs[RegCnt]={"SP","B","D","H","EA"};
+
+   for (*Erg=0; *Erg<RegCnt; (*Erg)++)
+    if (strcasecmp(Asc,Regs[*Erg])==0) break;
+   return (*Erg<RegCnt);
+END
+
+	static Boolean Decode_rp(char *Asc, ShortInt *Erg)
+BEGIN
+   if (NOT Decode_rp2(Asc,Erg)) return False;
+   return (*Erg<4);
+END
+
+	static Boolean Decode_rp1(char *Asc, ShortInt *Erg)
+BEGIN
+   if (strcasecmp(Asc,"VA")==0) *Erg=0;
+   else
+    BEGIN
+     if (NOT Decode_rp2(Asc,Erg)) return False;
+     return (*Erg!=0);
+    END
+   return True;
+END
+
+	static Boolean Decode_rp3(char *Asc, ShortInt *Erg)
+BEGIN
+   if (NOT Decode_rp2(Asc,Erg)) return False;
+   return ((*Erg<4) AND (*Erg>0));
+END
+
+	static Boolean Decode_rpa2(char *Asc, ShortInt *Erg, ShortInt *Disp)
+BEGIN
+#define OpCnt 13
+   static char *OpNames[OpCnt]={"B","D","H","D+","H+","D-","H-",
+				   "H+A","A+H","H+B","B+H","H+EA","EA+H"};
+   static Byte OpCodes[OpCnt]={1,2,3,4,5,6,7,12,12,13,13,14,14};
+
+   int z;
+   char *p,*pm;
+   Boolean OK;
+
+   for (z=0; z<OpCnt; z++)
+    if (strcasecmp(Asc,OpNames[z])==0)
+     BEGIN
+      *Erg=OpCodes[z]; return True;
+     END
+
+   p=QuotPos(Asc,'+'); pm=QuotPos(Asc,'-');
+   if ((p==Nil) OR ((pm!=Nil) AND (pm<p))) p=pm;
+   if (p==Nil) return False;
+
+   if (p==Asc+1)
+    switch (toupper(*Asc))
+     BEGIN
+      case 'H': *Erg=15; break;
+      case 'D': *Erg=11; break;
+      default: return False;
+     END
+   else return False;
+   *Disp=EvalIntExpression(p,SInt8,&OK);
+   return OK;
+END
+
+	static Boolean Decode_rpa(char *Asc, ShortInt *Erg)
+BEGIN
+   ShortInt Dummy;
+
+   if (NOT Decode_rpa2(Asc,Erg,&Dummy)) return False;
+   return (*Erg<=7);
+END
+
+	static Boolean Decode_rpa1(char *Asc, ShortInt *Erg)
+BEGIN
+   ShortInt Dummy;
+
+   if (NOT Decode_rpa2(Asc,Erg,&Dummy)) return False;
+   return (*Erg<=3);
+END
+
+	static Boolean Decode_rpa3(char *Asc, ShortInt *Erg, ShortInt *Disp)
+BEGIN
+   if (strcasecmp(Asc,"D++")==0) *Erg=4;
+   else if (strcasecmp(Asc,"H++")==0) *Erg=5;
+   else
+    BEGIN
+     if (NOT Decode_rpa2(Asc,Erg,Disp)) return False;
+     return ((*Erg==2) OR (*Erg==3) OR (*Erg>=8));
+    END
+   return True;
+END
+
+	static Boolean Decode_f(char *Asc, ShortInt *Erg)
+BEGIN
+#define FlagCnt 3
+   static char *Flags[FlagCnt]={"CY","HC","Z"};
+
+   for (*Erg=0; *Erg<FlagCnt; (*Erg)++)
+    if (strcasecmp(Flags[*Erg],Asc)==0) break;
+   *Erg+=2; return (*Erg<=4);
+END
+
+	static Boolean Decode_sr0(char *Asc, ShortInt *Erg)
+BEGIN
+   int z;
+
+   for (z=0; z<SRegCnt; z++)
+    if (strcasecmp(Asc,SRegs[z].Name)==0) break;
+   if ((z==SRegCnt-1) AND (MomCPU==CPU7810))
+    BEGIN
+     WrError(1440); return False;
+    END
+   if (z<SRegCnt)
+    BEGIN
+     *Erg=SRegs[z].Code; return True;
+    END
+   else return False;
+END
+
+	static Boolean Decode_sr1(char *Asc, ShortInt *Erg)
+BEGIN
+   if (NOT Decode_sr0(Asc,Erg)) return False;
+   return (((*Erg>=0) AND (*Erg<=9)) OR (*Erg==11) OR (*Erg==13) OR (*Erg==25) OR ((*Erg>=32) AND (*Erg<=35)));
+END
+
+	static Boolean Decode_sr(char *Asc, ShortInt *Erg)
+BEGIN
+   if (NOT Decode_sr0(Asc,Erg)) return False;
+   return (((*Erg>=0) AND (*Erg<=24)) OR (*Erg==26) OR (*Erg==27) OR (*Erg==40));
+END
+
+	static Boolean Decode_sr2(char *Asc, ShortInt *Erg)
+BEGIN
+   if (NOT Decode_sr0(Asc,Erg)) return False;
+   return (((*Erg>=0) AND (*Erg<=9)) OR (*Erg==11) OR (*Erg==13));
+END
+
+        static Boolean Decode_sr3(char *Asc, ShortInt *Erg)
+BEGIN
+   if (strcasecmp(Asc,"ETM0")==0) *Erg=0;
+   else if (strcasecmp(Asc,"ETM1")==0) *Erg=1;
+   else return False;
+   return True;
+END
+
+        static Boolean Decode_sr4(char *Asc, ShortInt *Erg)
+BEGIN
+   if (strcasecmp(Asc,"ECNT")==0) *Erg=0;
+   else if (strcasecmp(Asc,"ECPT")==0) *Erg=1;
+   else return False;
+   return True;
+END
+
+	static Boolean Decode_irf(char *Asc, ShortInt *Erg)
+BEGIN
+#undef FlagCnt
+#define FlagCnt 18
+   static char *FlagNames[FlagCnt]=
+	     {"NMI" ,"FT0" ,"FT1" ,"F1"  ,"F2"  ,"FE0" ,
+	      "FE1" ,"FEIN","FAD" ,"FSR" ,"FST" ,"ER"  ,
+	      "OV"  ,"AN4" ,"AN5" ,"AN6" ,"AN7" ,"SB"   };
+   static ShortInt FlagCodes[FlagCnt]=
+	     {0,1,2,3,4,5,6,7,8,9,10,11,12,16,17,18,19,20};
+
+   for (*Erg=0; *Erg<FlagCnt; (*Erg)++)
+    if (strcasecmp(FlagNames[*Erg],Asc)==0) break;
+   if (*Erg>=FlagCnt) return False;
+   *Erg=FlagCodes[*Erg];
+   return True;
+END
+
+	static Boolean Decode_wa(char *Asc, Byte *Erg)
+BEGIN
+   Word Adr;
+   Boolean OK;
+
+   FirstPassUnknown=False;
+   Adr=EvalIntExpression(Asc,Int16,&OK); if (NOT OK) return False;
+   if ((FirstPassUnknown) AND (Hi(Adr)!=WorkArea)) WrError(110);
+   *Erg=Lo(Adr);
+   return True;
+END
+
+	static Boolean HasDisp(ShortInt Mode)
+BEGIN
+   return ((Mode & 11)==11);
+END
+
+/*--------------------------------------------------------------------------*/
+
+	static Boolean DecodePseudo(void)
+BEGIN
+#define ASSUME78C10Count 1
+static ASSUMERec ASSUME78C10s[ASSUME78C10Count]=
+		 {{"V" , &WorkArea, 0, 0xff, 0x100}};
+
+   if (Memo("ASSUME"))
+    BEGIN
+     CodeASSUME(ASSUME78C10s,ASSUME78C10Count);
+     return True;
+    END
+
+   return False;
+END
+
+	static void MakeCode_78C10(void)
+BEGIN
+   int z;
+   Integer AdrInt;
+   ShortInt HVal8,HReg;
+   Boolean OK;
+
+   CodeLen=0; DontPrint=False;
+
+   /* 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 ((Memo("STOP")) AND (MomCPU==CPU7810)) WrError(1500);
+      else
+       BEGIN
+        CodeLen=0;
+        if (Hi(FixedOrders[z].Code)!=0) BAsmCode[CodeLen++]=Hi(FixedOrders[z].Code);
+        BAsmCode[CodeLen++]=Lo(FixedOrders[z].Code);
+       END
+      return;
+     END
+
+   if (Memo("MOV"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (strcasecmp(ArgStr[1],"A")==0)
+      if (Decode_sr1(ArgStr[2],&HReg))
+       BEGIN
+	CodeLen=2; BAsmCode[0]=0x4c;
+	BAsmCode[1]=0xc0+HReg;
+       END
+      else if (Decode_r1(ArgStr[2],&HReg))
+       BEGIN
+	CodeLen=1; BAsmCode[0]=0x08+HReg;
+       END
+      else WrError(1350);
+     else if (strcasecmp(ArgStr[2],"A")==0)
+      if (Decode_sr(ArgStr[1],&HReg))
+       BEGIN
+	CodeLen=2; BAsmCode[0]=0x4d;
+	BAsmCode[1]=0xc0+HReg;
+       END
+      else if (Decode_r1(ArgStr[1],&HReg))
+       BEGIN
+	CodeLen=1; BAsmCode[0]=0x18+HReg;
+       END
+      else WrError(1350);
+     else if (Decode_r(ArgStr[1],&HReg))
+      BEGIN
+       AdrInt=EvalIntExpression(ArgStr[2],Int16,&OK);
+       if (OK)
+	BEGIN
+	 CodeLen=4; BAsmCode[0]=0x70; BAsmCode[1]=0x68+HReg;
+	 BAsmCode[2]=Lo(AdrInt); BAsmCode[3]=Hi(AdrInt);
+	END
+      END
+     else if (Decode_r(ArgStr[2],&HReg))
+      BEGIN
+       AdrInt=EvalIntExpression(ArgStr[1],Int16,&OK);
+       if (OK)
+	BEGIN
+	 CodeLen=4; BAsmCode[0]=0x70; BAsmCode[1]=0x78+HReg;
+	 BAsmCode[2]=Lo(AdrInt); BAsmCode[3]=Hi(AdrInt);
+	END
+      END
+     else WrError(1350);
+     return;
+    END
+
+   if (Memo("MVI"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else
+      BEGIN
+       BAsmCode[1]=EvalIntExpression(ArgStr[2],Int8,&OK);
+       if (OK)
+	if (Decode_r(ArgStr[1],&HReg))
+	 BEGIN
+	  CodeLen=2; BAsmCode[0]=0x68+HReg;
+	 END
+	else if (Decode_sr2(ArgStr[1],&HReg))
+	 BEGIN
+	  CodeLen=3; BAsmCode[2]=BAsmCode[1]; BAsmCode[0]=0x64;
+	  BAsmCode[1]=(HReg & 7)+((HReg & 8) << 4);
+	 END
+	else WrError(1350);
+      END
+     return;
+    END
+
+   if (Memo("MVIW"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (Decode_wa(ArgStr[1],BAsmCode+1))
+      BEGIN
+       BAsmCode[2]=EvalIntExpression(ArgStr[2],Int8,&OK);
+       if (OK)
+	BEGIN
+	 CodeLen=3; BAsmCode[0]=0x71;
+	END
+      END
+     return;
+    END
+
+   if (Memo("MVIX"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (NOT Decode_rpa1(ArgStr[1],&HReg)) WrError(1350);
+     else
+      BEGIN
+       BAsmCode[1]=EvalIntExpression(ArgStr[2],Int8,&OK);
+       if (OK)
+	BEGIN
+	 BAsmCode[0]=0x48+HReg; CodeLen=2;
+	END
+      END
+     return;
+    END
+
+   if ((Memo("LDAX")) OR (Memo("STAX")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (NOT Decode_rpa2(ArgStr[1],&HReg,(ShortInt *) BAsmCode+1)) WrError(1350);
+     else
+      BEGIN
+       CodeLen=1+Ord(HasDisp(HReg));
+       BAsmCode[0]=0x28+(Ord(Memo("STAX")) << 4)+((HReg & 8) << 4)+(HReg & 7);
+      END
+     return;
+    END
+
+   if ((Memo("LDEAX")) OR (Memo("STEAX")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (NOT Decode_rpa3(ArgStr[1],&HReg,(ShortInt *) BAsmCode+2)) WrError(1350);
+     else
+      BEGIN
+       CodeLen=2+Ord(HasDisp(HReg)); BAsmCode[0]=0x48;
+       BAsmCode[1]=0x80+(Ord(Memo("STEAX")) << 4)+HReg;
+      END
+     return;
+    END
+
+   if (Memo("LXI"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (NOT Decode_rp2(ArgStr[1],&HReg)) WrError(1350);
+     else
+      BEGIN
+       AdrInt=EvalIntExpression(ArgStr[2],Int16,&OK);
+       if (OK)
+	BEGIN
+	 CodeLen=3; BAsmCode[0]=0x04+(HReg << 4);
+	 BAsmCode[1]=Lo(AdrInt); BAsmCode[2]=Hi(AdrInt);
+	END
+      END
+     return;
+    END
+
+   if ((Memo("PUSH")) OR (Memo("POP")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (NOT Decode_rp1(ArgStr[1],&HReg)) WrError(1350);
+     else
+      BEGIN
+       CodeLen=1;
+       BAsmCode[0]=0xa0+(Ord(Memo("PUSH")) << 4)+HReg;
+      END
+     return;
+    END
+
+   if (Memo("DMOV"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else
+      BEGIN
+       if (strcasecmp(ArgStr[1],"EA")!=0)
+        BEGIN
+         strcpy(ArgStr[3],ArgStr[1]);
+         strcpy(ArgStr[1],ArgStr[2]);
+         strcpy(ArgStr[2],ArgStr[3]);
+         OK=True;
+	END
+       else OK=False;
+       if (strcasecmp(ArgStr[1],"EA")!=0) WrError(1350);
+       else if (Decode_rp3(ArgStr[2],&HReg))
+        BEGIN
+         CodeLen=1; BAsmCode[0]=0xa4+HReg;
+         if (OK) BAsmCode[0]+=0x10;
+        END
+       else if (((OK) AND (Decode_sr3(ArgStr[2],&HReg)))
+             OR ((NOT OK) AND (Decode_sr4(ArgStr[2],&HReg))))
+        BEGIN
+         CodeLen=2; BAsmCode[0]=0x48; BAsmCode[1]=0xc0+HReg;
+         if (OK) BAsmCode[1]+=0x12;
+        END
+       else WrError(1350);
+      END
+     return;
+    END
+
+   for (z=0; z<ALUOrderCnt; z++)
+    if (Memo(ALUOrderImmOps[z]))
+     BEGIN
+      if (ArgCnt!=2) WrError(1110);
+      else
+       BEGIN
+	HVal8=EvalIntExpression(ArgStr[2],Int8,&OK);
+	if (OK)
+	 if (strcasecmp(ArgStr[1],"A")==0)
+	  BEGIN
+	   CodeLen=2;
+	   BAsmCode[0]=0x06+((ALUOrderCodes[z] & 14) << 3)+(ALUOrderCodes[z] & 1);
+	   BAsmCode[1]=HVal8;
+	  END
+	 else if (Decode_r(ArgStr[1],&HReg))
+	  BEGIN
+	   CodeLen=3; BAsmCode[0]=0x74; BAsmCode[2]=HVal8;
+	   BAsmCode[1]=HReg+(ALUOrderCodes[z] << 3);
+	  END
+	 else if (Decode_sr2(ArgStr[1],&HReg))
+	  BEGIN
+	   CodeLen=3; BAsmCode[0]=0x64; BAsmCode[2]=HVal8;
+	   BAsmCode[1]=(HReg & 7)+(ALUOrderCodes[z] << 3)+((HReg & 8) << 4);
+	  END
+	 else WrError(1350);
+       END
+      return;
+     END
+    else if (Memo(ALUOrderRegOps[z]))
+     BEGIN
+      if (ArgCnt!=2) WrError(1110);
+      else
+       BEGIN
+	if (strcasecmp(ArgStr[1],"A")!=0)
+	 BEGIN
+	  strcpy(ArgStr[3],ArgStr[1]);
+          strcpy(ArgStr[1],ArgStr[2]);
+          strcpy(ArgStr[2],ArgStr[3]);
+	  OK=False;
+	 END
+	else OK=True;
+	if (strcasecmp(ArgStr[1],"A")!=0) WrError(1350);
+	else if (NOT Decode_r(ArgStr[2],&HReg)) WrError(1350);
+	else
+	 BEGIN
+	  CodeLen=2; BAsmCode[0]=0x60;
+	  BAsmCode[1]=(ALUOrderCodes[z] << 3)+HReg;
+	  if ((OK) OR (Memo("ONA")) OR (Memo("OFFA")))
+	   BAsmCode[1]+=0x80;
+	 END
+       END
+      return;
+     END
+    else if ((OpPart[strlen(OpPart)-1]=='W') AND (strncmp(ALUOrderRegOps[z],OpPart,strlen(ALUOrderRegOps[z]))==0))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (Decode_wa(ArgStr[1],BAsmCode+2))
+       BEGIN
+	CodeLen=3; BAsmCode[0]=0x74;
+	BAsmCode[1]=0x80+(ALUOrderCodes[z] << 3);
+       END
+      return;
+     END
+    else if ((OpPart[strlen(OpPart)-1]=='X') AND (strncmp(ALUOrderRegOps[z],OpPart,strlen(ALUOrderRegOps[z]))==0))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (NOT Decode_rpa(ArgStr[1],&HReg)) WrError(1350);
+      else
+       BEGIN
+	CodeLen=2; BAsmCode[0]=0x70;
+	BAsmCode[1]=0x80+(ALUOrderCodes[z] << 3)+HReg;
+       END
+      return;
+     END
+    else if (Memo(ALUOrderEAOps[z]))
+     BEGIN
+      if (ArgCnt!=2) WrError(1110);
+      else if (strcasecmp(ArgStr[1],"EA")!=0) WrError(1350);
+      else if (NOT Decode_rp3(ArgStr[2],&HReg)) WrError(1350);
+      else
+       BEGIN
+	CodeLen=2; BAsmCode[0]=0x74;
+	BAsmCode[1]=0x84+(ALUOrderCodes[z] << 3)+HReg;
+       END
+      return;
+     END
+    else if (((OpPart[strlen(OpPart)-1]=='W') AND (strncmp(ALUOrderImmOps[z],OpPart,strlen(ALUOrderImmOps[z]))==0)) AND (Odd(ALUOrderCodes[z])))
+     BEGIN
+      if (ArgCnt!=2) WrError(1110);
+      else if (Decode_wa(ArgStr[1],BAsmCode+1))
+       BEGIN
+	BAsmCode[2]=EvalIntExpression(ArgStr[2],Int8,&OK);
+	if (OK)
+	 BEGIN
+	  CodeLen=3;
+	  BAsmCode[0]=0x05+((ALUOrderCodes[z] >> 1) << 4);
+	 END
+       END
+      return;
+     END
+
+   for (z=0; z<AbsOrderCnt; z++)
+    if (Memo(AbsOrders[z].Name))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else
+       BEGIN
+        AdrInt=EvalIntExpression(ArgStr[1],Int16,&OK);
+        if (OK)
+         BEGIN
+          CodeLen=0;
+          if (Hi(AbsOrders[z].Code)!=0) BAsmCode[CodeLen++]=Hi(AbsOrders[z].Code);
+          BAsmCode[CodeLen++]=Lo(AbsOrders[z].Code);
+          BAsmCode[CodeLen++]=Lo(AdrInt);
+          BAsmCode[CodeLen++]=Hi(AdrInt);
+         END
+       END
+      return;
+     END
+
+   for (z=0; z<Reg2OrderCnt; z++)
+    if (Memo(Reg2Orders[z].Name))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (NOT Decode_r2(ArgStr[1],&HReg)) WrError(1350);
+      else
+       BEGIN
+        CodeLen=0;
+        if (Hi(Reg2Orders[z].Code)!=0) BAsmCode[CodeLen++]=Hi(Reg2Orders[z].Code);
+        BAsmCode[CodeLen++]=Lo(Reg2Orders[z].Code)+HReg;
+       END
+      return;
+     END
+
+   for (z=0; z<WorkOrderCnt; z++)
+    if (Memo(WorkOrders[z].Name))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (Decode_wa(ArgStr[1],BAsmCode+1))
+       BEGIN
+        CodeLen=2; BAsmCode[0]=WorkOrders[z].Code;
+       END
+      return;
+     END
+
+   if ((Memo("DCX")) OR (Memo("INX")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (strcasecmp(ArgStr[1],"EA")==0)
+      BEGIN
+       CodeLen=1; BAsmCode[0]=0xa8+Ord(Memo("DCX"));
+      END
+     else if (Decode_rp(ArgStr[1],&HReg))
+      BEGIN
+       CodeLen=1; BAsmCode[0]=0x02+Ord(Memo("DCX"))+(HReg << 4);
+      END
+     else WrError(1350);
+     return;
+    END
+
+   if ((Memo("EADD")) OR (Memo("ESUB")))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else if (strcasecmp(ArgStr[1],"EA")!=0) WrError(1350);
+     else if (NOT Decode_r2(ArgStr[2],&HReg)) WrError(1350);
+     else
+      BEGIN
+       CodeLen=2; BAsmCode[0]=0x70;
+       BAsmCode[1]=0x40+(Ord(Memo("ESUB")) << 5)+HReg;
+      END
+     return;
+    END
+
+   if ((Memo("JR")) OR (Memo("JRE")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       AdrInt=EvalIntExpression(ArgStr[1],Int16,&OK)-(EProgCounter()+1+Ord(Memo("JRE")));
+       if (OK)
+	if (Memo("JR"))
+	 if ((NOT SymbolQuestionable) AND ((AdrInt<-32) OR (AdrInt>31))) WrError(1370);
+	 else
+	  BEGIN
+	   CodeLen=1; BAsmCode[0]=0xc0+(AdrInt & 0x3f);
+	  END
+	else
+	 if ((NOT SymbolQuestionable) AND ((AdrInt<-256) OR (AdrInt>255))) WrError(1370);
+	 else
+	  BEGIN
+	   if ((AdrInt>=-32) AND (AdrInt<=31)) WrError(20);
+	   CodeLen=2; BAsmCode[0]=0x4e + (Hi(AdrInt) & 1); /* ANSI :-O */
+ 	   BAsmCode[1]=Lo(AdrInt);
+	  END
+      END
+     return;
+    END
+
+   if (Memo("CALF"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       FirstPassUnknown=False;
+       AdrInt=EvalIntExpression(ArgStr[1],Int16,&OK);
+       if (OK)
+	if ((NOT FirstPassUnknown) AND ((AdrInt >> 11)!=1)) WrError(1905);
+	else
+	 BEGIN
+	  CodeLen=2;
+	  BAsmCode[0]=Hi(AdrInt)+0x70; BAsmCode[1]=Lo(AdrInt);
+	 END
+      END
+     return;
+    END
+
+   if (Memo("CALT"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       FirstPassUnknown=False;
+       AdrInt=EvalIntExpression(ArgStr[1],Int16,&OK);
+       if (OK)
+	if ((NOT FirstPassUnknown) AND ((AdrInt & 0xffc1)!=0x80)) WrError(1905);
+	else
+	 BEGIN
+	  CodeLen=1;
+	  BAsmCode[0]=0x80+((AdrInt & 0x3f) >> 1);
+	 END
+      END
+     return;
+    END
+
+   if (Memo("BIT"))
+    BEGIN
+     if (ArgCnt!=2) WrError(1110);
+     else
+      BEGIN
+       HReg=EvalIntExpression(ArgStr[1],UInt3,&OK);
+       if (OK)
+	if (Decode_wa(ArgStr[2],BAsmCode+1))
+	 BEGIN
+	  CodeLen=2; BAsmCode[0]=0x58+HReg;
+	 END
+      END
+     return;
+    END
+
+   for (z=0; z<EAOrderCnt; z++)
+    if (Memo(EAOrders[z].Name))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (strcasecmp(ArgStr[1],"EA")!=0) WrError(1350);
+      else
+       BEGIN
+        CodeLen=2; BAsmCode[0]=Hi(EAOrders[z].Code); BAsmCode[1]=Lo(EAOrders[z].Code);
+       END
+      return;
+     END
+
+   if ((Memo("SK")) OR (Memo("SKN")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (NOT Decode_f(ArgStr[1],&HReg)) WrError(1350);
+     else
+      BEGIN
+       CodeLen=2; BAsmCode[0]=0x48;
+       BAsmCode[1]=0x08+(Ord(Memo("SKN")) << 4)+HReg;
+      END
+     return;
+    END
+
+   if ((Memo("SKIT")) OR (Memo("SKINT")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (NOT Decode_irf(ArgStr[1],&HReg)) WrError(1350);
+     else
+      BEGIN
+       CodeLen=2; BAsmCode[0]=0x48;
+       BAsmCode[1]=0x40+(Ord(Memo("SKINT")) << 5)+HReg;
+      END
+     return;
+    END
+
+   WrXError(1200,OpPart);
+END
+
+	static void InitCode_78C10(void)
+BEGIN
+   SaveInitProc();
+   WorkArea=0x100;
+END
+
+	static Boolean IsDef_78C10(void)
+BEGIN
+   return False;
+END
+
+        static void SwitchFrom_78C10(void)
+BEGIN
+   DeinitFields();
+END
+
+	static void SwitchTo_78C10(void)
+BEGIN
+   TurnWords=False; ConstMode=ConstModeIntel; SetIsOccupied=False;
+
+   PCSymbol="$"; HeaderID=0x7a; NOPCode=0x00;
+   DivideChars=","; HasAttrs=False;
+
+   ValidSegs=1<<SegCode;
+   Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0;
+   SegLimits[SegCode] = 0xffff;
+
+   MakeCode=MakeCode_78C10; IsDef=IsDef_78C10;
+   SwitchFrom=SwitchFrom_78C10; InitFields();
+END
+
+	void code78c10_init(void)
+BEGIN
+   CPU7810 =AddCPU("7810" ,SwitchTo_78C10);
+   CPU78C10=AddCPU("78C10",SwitchTo_78C10);
+
+   SaveInitProc=InitPassProc; InitPassProc=InitCode_78C10;
+END
-- 
cgit v1.2.3