aboutsummaryrefslogtreecommitdiffstats
path: root/code78c10.c
diff options
context:
space:
mode:
Diffstat (limited to 'code78c10.c')
-rw-r--r--code78c10.c978
1 files changed, 978 insertions, 0 deletions
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
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-29 02:11:31 +0000