dect
/
asl
Archived
13
0
Fork 0
Code Issues Releases Activity
This repository has been archived on 2022-02-17. You can view files and clone it, but cannot push or open issues or pull requests.
asl/code78c10.c

979 lines
25 KiB
C
Raw Permalink Blame History

/* 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
Reference in New Issue View Git Blame Copy Permalink