aboutsummaryrefslogtreecommitdiffstats
path: root/code68.c
diff options
context:
space:
mode:
Diffstat (limited to 'code68.c')
-rw-r--r--code68.c847
1 files changed, 847 insertions, 0 deletions
diff --git a/code68.c b/code68.c
new file mode 100644
index 0000000..6f679d6
--- /dev/null
+++ b/code68.c
@@ -0,0 +1,847 @@
+/* code68.c */
+/*****************************************************************************/
+/* AS-Portierung */
+/* */
+/* Codegenerator fuer 68xx Prozessoren */
+/* */
+/* Historie: 13. 8.1996 Grundsteinlegung */
+/* 2. 1.1998 ChkPC ersetzt */
+/* */
+/*****************************************************************************/
+
+#include "stdinc.h"
+#include <string.h>
+#include <ctype.h>
+
+#include "bpemu.h"
+#include "strutil.h"
+#include "asmdef.h"
+#include "asmpars.h"
+#include "asmsub.h"
+#include "codepseudo.h"
+#include "codevars.h"
+#include "asmitree.h"
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct
+ {
+ char *Name;
+ CPUVar MinCPU,MaxCPU;
+ Word Code;
+ } FixedOrder;
+
+typedef struct
+ {
+ char *Name;
+ Byte Code;
+ } BaseOrder;
+
+typedef struct
+ {
+ char *Name;
+ Boolean MayImm;
+ Byte Code;
+ } ALU8Order;
+
+typedef struct
+ {
+ Boolean MayImm;
+ CPUVar MinCPU; /* Shift andere ,Y */
+ Byte PageShift; /* 0 : nix Pg 2 */
+ Byte Code; /* 1 : Pg 3 Pg 4 */
+ } ALU16Order; /* 2 : nix Pg 4 */
+ /* 3 : Pg 2 Pg 3 */
+
+
+#define ModNone (-1)
+#define ModAcc 0
+#define MModAcc (1<<ModAcc)
+#define ModDir 1
+#define MModDir (1<<ModDir)
+#define ModExt 2
+#define MModExt (1<<ModExt)
+#define ModInd 3
+#define MModInd (1<<ModInd)
+#define ModImm 4
+#define MModImm (1<<ModImm)
+
+#define Page2Prefix 0x18
+#define Page3Prefix 0x1a
+#define Page4Prefix 0xcd
+
+#define FixedOrderCnt 45
+#define RelOrderCnt 19
+#define ALU8OrderCnt 11
+#define ALU16OrderCnt 13
+#define Sing8OrderCnt 12
+#define Bit63OrderCnt 4
+
+
+static ShortInt OpSize;
+static Byte PrefCnt; /* Anzahl Befehlspraefixe */
+static ShortInt AdrMode; /* Ergebnisadressmodus */
+static Byte AdrPart; /* Adressierungsmodusbits im Opcode */
+static Byte AdrVals[4]; /* Adressargument */
+
+static FixedOrder *FixedOrders;
+static BaseOrder *RelOrders;
+static ALU8Order *ALU8Orders;
+static ALU16Order *ALU16Orders;
+static BaseOrder *Bit63Orders;
+static BaseOrder *Sing8Orders;
+static PInstTable InstTable;
+
+static CPUVar CPU6800,CPU6301,CPU6811;
+
+/*---------------------------------------------------------------------------*/
+
+ static void DecodeAdr(int StartInd, int StopInd, Byte Erl)
+BEGIN
+ String Asc;
+ Boolean OK,ErrOcc;
+ Word AdrWord;
+ Byte Bit8;
+
+ AdrMode=ModNone; AdrPart=0; strmaxcpy(Asc,ArgStr[StartInd],255); ErrOcc=False;
+
+ /* eine Komponente ? */
+
+ if (StartInd==StopInd)
+ BEGIN
+
+ /* Akkumulatoren ? */
+
+ if (strcasecmp(Asc,"A")==0)
+ BEGIN
+ if ((MModAcc & Erl)!=0) AdrMode=ModAcc;
+ END
+ else if (strcasecmp(Asc,"B")==0)
+ BEGIN
+ if ((MModAcc & Erl)!=0)
+ BEGIN
+ AdrMode=ModAcc; AdrPart=1;
+ END
+ END
+
+ /* immediate ? */
+
+ else if ((strlen(Asc)>1) AND (*Asc=='#'))
+ BEGIN
+ if ((MModImm & Erl)!=0)
+ BEGIN
+ if (OpSize==1)
+ BEGIN
+ AdrWord=EvalIntExpression(Asc+1,Int16,&OK);
+ if (OK)
+ BEGIN
+ AdrMode=ModImm;
+ AdrVals[AdrCnt++]=Hi(AdrWord); AdrVals[AdrCnt++]=Lo(AdrWord);
+ END
+ else ErrOcc=True;
+ END
+ else
+ BEGIN
+ AdrVals[AdrCnt]=EvalIntExpression(Asc+1,Int8,&OK);
+ if (OK)
+ BEGIN
+ AdrMode=ModImm; AdrCnt++;
+ END
+ else ErrOcc=True;
+ END
+ END
+ END
+
+ /* absolut ? */
+
+ else
+ BEGIN
+ Bit8=0;
+ if (*Asc=='<')
+ BEGIN
+ Bit8=2; strcpy(Asc,Asc+1);
+ END
+ else if (*Asc=='>')
+ BEGIN
+ Bit8=1; strcpy(Asc,Asc+1);
+ END
+ if ((Bit8==2) OR ((MModExt & Erl)==0))
+ AdrWord=EvalIntExpression(Asc,Int8,&OK);
+ else
+ AdrWord=EvalIntExpression(Asc,Int16,&OK);
+ if (OK)
+ BEGIN
+ if (((MModDir & Erl)!=0) AND (Bit8!=1) AND ((Bit8==2) OR ((MModExt & Erl)==0) OR (Hi(AdrWord)==0)))
+ BEGIN
+ if (Hi(AdrWord)!=0)
+ BEGIN
+ WrError(1340); ErrOcc=True;
+ END
+ else
+ BEGIN
+ AdrMode=ModDir; AdrPart=1;
+ AdrVals[AdrCnt++]=Lo(AdrWord);
+ END
+ END
+ else if ((MModExt & Erl)!=0)
+ BEGIN
+ AdrMode=ModExt; AdrPart=3;
+ AdrVals[AdrCnt++]=Hi(AdrWord); AdrVals[AdrCnt++]=Lo(AdrWord);
+ END
+ END
+ else ErrOcc=True;
+ END
+ END
+
+ /* zwei Komponenten ? */
+
+ else if (StartInd+1==StopInd)
+ BEGIN
+
+ /* indiziert ? */
+
+ if (((strcasecmp(ArgStr[StopInd],"X")==0) OR (strcasecmp(ArgStr[StopInd],"Y")==0)))
+ BEGIN
+ if ((MModInd & Erl)!=0)
+ BEGIN
+ AdrWord=EvalIntExpression(Asc,Int8,&OK);
+ if (OK)
+ if ((MomCPU<CPU6811) AND (strcasecmp(ArgStr[StartInd+1],"Y")==0))
+ BEGIN
+ WrError(1505); ErrOcc=True;
+ END
+ else
+ BEGIN
+ AdrVals[AdrCnt++]=Lo(AdrWord);
+ AdrMode=ModInd; AdrPart=2;
+ if (strcasecmp(ArgStr[StartInd+1],"Y")==0)
+ BEGIN
+ BAsmCode[PrefCnt++]=0x18;
+ END
+ END
+ else ErrOcc=True;
+ END
+ END
+ else
+ BEGIN
+ WrXError(1445,ArgStr[StopInd]); ErrOcc=True;
+ END
+
+ END
+ else
+ BEGIN
+ WrError(1110); ErrOcc=True;
+ END
+
+ if ((NOT ErrOcc) AND (AdrMode==ModNone)) WrError(1350);
+END
+
+ static void AddPrefix(Byte Prefix)
+BEGIN
+ BAsmCode[PrefCnt++]=Prefix;
+END
+
+ static void Try2Split(int Src)
+BEGIN
+ Integer z;
+ char *p;
+
+ KillPrefBlanks(ArgStr[Src]); KillPostBlanks(ArgStr[Src]);
+ p=ArgStr[Src]+strlen(ArgStr[Src])-1;
+ while ((p>ArgStr[Src]) AND (NOT isspace((unsigned int) *p))) p--;
+ if (p>ArgStr[Src])
+ BEGIN
+ for (z=ArgCnt; z>=Src; z--) strcpy(ArgStr[z+1],ArgStr[z]); ArgCnt++;
+ strcpy(ArgStr[Src+1],p+1); *p='\0';
+ KillPostBlanks(ArgStr[Src]); KillPrefBlanks(ArgStr[Src+1]);
+ END
+END
+
+/*---------------------------------------------------------------------------*/
+
+ static void DecodeFixed(Word Index)
+BEGIN
+ FixedOrder *forder=FixedOrders+Index;
+
+ if (ArgCnt!=0) WrError(1110);
+ else if ((MomCPU<forder->MinCPU) OR (MomCPU>forder->MaxCPU)) WrError(1500);
+ else if (Hi(forder->Code)!=0)
+ BEGIN
+ CodeLen=2;
+ BAsmCode[0]=Hi(forder->Code);
+ BAsmCode[1]=Lo(forder->Code);
+ END
+ else
+ BEGIN
+ CodeLen=1;
+ BAsmCode[0]=Lo(forder->Code);
+ END
+END
+
+ static void DecodeRel(Word Index)
+BEGIN
+ BaseOrder *forder=RelOrders+Index;
+ Integer AdrInt;
+ Boolean OK;
+
+ if (ArgCnt!=1) WrError(1110);
+ else
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[1],Int16,&OK);
+ if (OK)
+ BEGIN
+ AdrInt-=EProgCounter()+2;
+ if (((AdrInt<-128) OR (AdrInt>127)) AND (NOT SymbolQuestionable)) WrError(1370);
+ else
+ BEGIN
+ CodeLen=2; BAsmCode[0]=forder->Code; BAsmCode[1]=Lo(AdrInt);
+ END
+ END
+ END
+END
+
+ static void DecodeALU16(Word Index)
+BEGIN
+ ALU16Order *forder=ALU16Orders+Index;
+
+ OpSize=1;
+ if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
+ else if (MomCPU<forder->MinCPU) WrError(1500);
+ else
+ BEGIN
+ DecodeAdr(1,ArgCnt,(forder->MayImm?MModImm:0)+MModInd+MModExt+MModDir);
+ if (AdrMode!=ModNone)
+ BEGIN
+ switch (forder->PageShift)
+ BEGIN
+ case 1:
+ if (PrefCnt==1) BAsmCode[PrefCnt-1]=Page4Prefix;
+ else AddPrefix(Page3Prefix);
+ break;
+ case 2:
+ if (PrefCnt==1) BAsmCode[PrefCnt-1]=Page4Prefix;
+ break;
+ case 3:
+ if (PrefCnt==0) AddPrefix((AdrMode==ModInd)?Page3Prefix:Page2Prefix);
+ break;
+ END
+ BAsmCode[PrefCnt]=forder->Code+(AdrPart << 4);
+ CodeLen=PrefCnt+1+AdrCnt;
+ memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
+ END
+ END
+END
+
+ static void DecodeBit63(Word Index)
+BEGIN
+ BaseOrder *forder=Bit63Orders+Index;
+
+ if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
+ else if (MomCPU!=CPU6301) WrError(1500);
+ else
+ BEGIN
+ DecodeAdr(1,1,MModImm);
+ if (AdrMode!=ModNone)
+ BEGIN
+ DecodeAdr(2,ArgCnt,MModDir+MModInd);
+ if (AdrMode!=ModNone)
+ BEGIN
+ BAsmCode[PrefCnt]=forder->Code;
+ if (AdrMode==ModDir) BAsmCode[PrefCnt]+=0x10;
+ CodeLen=PrefCnt+1+AdrCnt;
+ memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
+ END
+ END
+ END
+END
+
+ static void DecodeJMP(Word Index)
+BEGIN
+ if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
+ else
+ BEGIN
+ DecodeAdr(1,ArgCnt,MModExt+MModInd);
+ if (AdrMode!=ModImm)
+ BEGIN
+ CodeLen=PrefCnt+1+AdrCnt;
+ BAsmCode[PrefCnt]=0x4e + (AdrPart << 4);
+ memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
+ END
+ END
+END
+
+ static void DecodeJSR(Word Index)
+BEGIN
+ if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
+ else
+ BEGIN
+ DecodeAdr(1,ArgCnt,MModDir+MModExt+MModInd);
+ if (AdrMode!=ModImm)
+ BEGIN
+ CodeLen=PrefCnt+1+AdrCnt;
+ BAsmCode[PrefCnt]=0x8d+(AdrPart << 4);
+ memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
+ END
+ END
+END
+
+ static void DecodeBRxx(Word Index)
+BEGIN
+ Boolean OK;
+ Byte Mask;
+ Integer AdrInt;
+
+ if (ArgCnt==1)
+ BEGIN
+ Try2Split(1); Try2Split(1);
+ END
+ else if (ArgCnt==2)
+ BEGIN
+ Try2Split(ArgCnt); Try2Split(2);
+ END
+ if ((ArgCnt<3) OR (ArgCnt>4)) WrError(1110);
+ else if (MomCPU<CPU6811) WrError(1500);
+ else
+ BEGIN
+ if (*ArgStr[ArgCnt-1]=='#') strcpy(ArgStr[ArgCnt-1],ArgStr[ArgCnt-1]+1);
+ Mask=EvalIntExpression(ArgStr[ArgCnt-1],Int8,&OK);
+ if (OK)
+ BEGIN
+ DecodeAdr(1,ArgCnt-2,MModDir+MModInd);
+ if (AdrMode!=ModNone)
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[ArgCnt],Int16,&OK);
+ if (OK)
+ BEGIN
+ AdrInt-=EProgCounter()+3+PrefCnt+AdrCnt;
+ if ((AdrInt<-128) OR (AdrInt>127)) WrError(1370);
+ else
+ BEGIN
+ CodeLen=PrefCnt+3+AdrCnt;
+ BAsmCode[PrefCnt]=0x12+Index;
+ if (AdrMode==ModInd) BAsmCode[PrefCnt]+=12;
+ memcpy(BAsmCode+PrefCnt+1,AdrVals,AdrCnt);
+ BAsmCode[PrefCnt+1+AdrCnt]=Mask;
+ BAsmCode[PrefCnt+2+AdrCnt]=Lo(AdrInt);
+ END
+ END
+ END
+ END
+ END
+END
+
+ static void DecodeBxx(Word Index)
+BEGIN
+ Byte Mask;
+ Boolean OK;
+ int z;
+
+ if (MomCPU==CPU6301)
+ BEGIN
+ strcpy(ArgStr[ArgCnt+1],ArgStr[1]);
+ for (z=1; z<=ArgCnt-1; z++) strcpy(ArgStr[z],ArgStr[z+1]);
+ strcpy(ArgStr[ArgCnt],ArgStr[ArgCnt+1]);
+ END
+ if ((ArgCnt>=1) AND (ArgCnt<=2)) Try2Split(ArgCnt);
+ if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
+ else if (MomCPU<CPU6301) WrError(1500);
+ else
+ BEGIN
+ if (*ArgStr[ArgCnt]=='#') strcpy(ArgStr[ArgCnt],ArgStr[ArgCnt]+1);
+ Mask=EvalIntExpression(ArgStr[ArgCnt],Int8,&OK);
+ if ((OK) AND (MomCPU==CPU6301))
+ if (Mask>7)
+ BEGIN
+ WrError(1320); OK=False;
+ END
+ else
+ BEGIN
+ Mask=1 << Mask;
+ if (Index==1) Mask=0xff-Mask;
+ END
+ if (OK)
+ BEGIN
+ DecodeAdr(1,ArgCnt-1,MModDir+MModInd);
+ if (AdrMode!=ModNone)
+ BEGIN
+ CodeLen=PrefCnt+2+AdrCnt;
+ if (MomCPU==CPU6301)
+ BEGIN
+ BAsmCode[PrefCnt]=0x62-Index;
+ if (AdrMode==ModDir) BAsmCode[PrefCnt]+=0x10;
+ BAsmCode[1+PrefCnt]=Mask;
+ memcpy(BAsmCode+2+PrefCnt,AdrVals,AdrCnt);
+ END
+ else
+ BEGIN
+ BAsmCode[PrefCnt]=0x14+Index;
+ if (AdrMode==ModInd) BAsmCode[PrefCnt]+=8;
+ memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
+ BAsmCode[1+PrefCnt+AdrCnt]=Mask;
+ END
+ END
+ END
+ END
+END
+
+ static void DecodeBTxx(Word Index)
+BEGIN
+ Boolean OK;
+ Byte AdrByte;
+
+ if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
+ else if (MomCPU!=CPU6301) WrError(1500);
+ else
+ BEGIN
+ AdrByte=EvalIntExpression(ArgStr[1],Int8,&OK);
+ if (OK)
+ if (AdrByte>7) WrError(1320);
+ else
+ BEGIN
+ DecodeAdr(2,ArgCnt,MModDir+MModInd);
+ if (AdrMode!=ModNone)
+ BEGIN
+ CodeLen=PrefCnt+2+AdrCnt;
+ BAsmCode[1+PrefCnt]=1 << AdrByte;
+ memcpy(BAsmCode+2+PrefCnt,AdrVals,AdrCnt);
+ BAsmCode[PrefCnt]=0x65;
+ BAsmCode[PrefCnt]+=Index;
+ if (AdrMode==ModDir) BAsmCode[PrefCnt]+=0x10;
+ END
+ END
+ END
+END
+
+/*---------------------------------------------------------------------------*/
+
+ static void AddFixed(char *NName, CPUVar NMin, CPUVar NMax, Word NCode)
+BEGIN
+ if (InstrZ>=FixedOrderCnt) exit(255);
+
+ FixedOrders[InstrZ].Name=NName;
+ FixedOrders[InstrZ].MinCPU=NMin;
+ FixedOrders[InstrZ].MaxCPU=NMax;
+ FixedOrders[InstrZ].Code=NCode;
+ AddInstTable(InstTable,NName,InstrZ++,DecodeFixed);
+END
+
+ static void AddRel(char *NName, Byte NCode)
+BEGIN
+ if (InstrZ>=RelOrderCnt) exit(255);
+
+ RelOrders[InstrZ].Name=NName;
+ RelOrders[InstrZ].Code=NCode;
+ AddInstTable(InstTable,NName,InstrZ++,DecodeRel);
+END
+
+ static void AddALU8(char *NName, Boolean NMay, Byte NCode)
+BEGIN
+ if (InstrZ>=ALU8OrderCnt) exit(255);
+
+ ALU8Orders[InstrZ].Name=NName;
+ ALU8Orders[InstrZ].MayImm=NMay;
+ ALU8Orders[InstrZ++].Code=NCode;
+END
+
+ static void AddALU16(char *NName, Boolean NMay, CPUVar NMin, Byte NShift, Byte NCode)
+BEGIN
+ if (InstrZ>=ALU16OrderCnt) exit(255);
+
+ ALU16Orders[InstrZ].MayImm=NMay;
+ ALU16Orders[InstrZ].MinCPU=NMin;
+ ALU16Orders[InstrZ].PageShift=NShift;
+ ALU16Orders[InstrZ].Code=NCode;
+ AddInstTable(InstTable,NName,InstrZ++,DecodeALU16);
+END
+
+ static void AddSing8(char *NName, Byte NCode)
+BEGIN
+ if (InstrZ>=Sing8OrderCnt) exit(255);
+
+ Sing8Orders[InstrZ].Name=NName;
+ Sing8Orders[InstrZ++].Code=NCode;
+END
+
+ static void AddBit63(char *NName, Byte NCode)
+BEGIN
+ if (InstrZ>=Bit63OrderCnt) exit(255);
+
+ Bit63Orders[InstrZ].Name=NName;
+ Bit63Orders[InstrZ].Code=NCode;
+ AddInstTable(InstTable,NName,InstrZ++,DecodeBit63);
+END
+
+ static void InitFields(void)
+BEGIN
+ InstTable=CreateInstTable(201);
+ AddInstTable(InstTable,"JMP",0,DecodeJMP);
+ AddInstTable(InstTable,"JSR",0,DecodeJSR);
+ AddInstTable(InstTable,"BRCLR",1,DecodeBRxx);
+ AddInstTable(InstTable,"BRSET",0,DecodeBRxx);
+ AddInstTable(InstTable,"BCLR",1,DecodeBxx);
+ AddInstTable(InstTable,"BSET",0,DecodeBxx);
+ AddInstTable(InstTable,"BTST",6,DecodeBTxx);
+ AddInstTable(InstTable,"BTGL",0,DecodeBTxx);
+
+ FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0;
+ AddFixed("ABA" ,CPU6800, CPU6811, 0x001b); AddFixed("ABX" ,CPU6301, CPU6811, 0x003a);
+ AddFixed("ABY" ,CPU6811, CPU6811, 0x183a); AddFixed("ASLD" ,CPU6301, CPU6811, 0x0005);
+ AddFixed("CBA" ,CPU6800, CPU6811, 0x0011); AddFixed("CLC" ,CPU6800, CPU6811, 0x000c);
+ AddFixed("CLI" ,CPU6800, CPU6811, 0x000e); AddFixed("CLV" ,CPU6800, CPU6811, 0x000a);
+ AddFixed("DAA" ,CPU6800, CPU6811, 0x0019); AddFixed("DES" ,CPU6800, CPU6811, 0x0034);
+ AddFixed("DEX" ,CPU6800, CPU6811, 0x0009); AddFixed("DEY" ,CPU6811, CPU6811, 0x1809);
+ AddFixed("FDIV" ,CPU6811, CPU6811, 0x0003); AddFixed("IDIV" ,CPU6811, CPU6811, 0x0002);
+ AddFixed("INS" ,CPU6800, CPU6811, 0x0031); AddFixed("INX" ,CPU6800, CPU6811, 0x0008);
+ AddFixed("INY" ,CPU6811, CPU6811, 0x1808); AddFixed("LSLD" ,CPU6301, CPU6811, 0x0005);
+ AddFixed("LSRD" ,CPU6301, CPU6811, 0x0004); AddFixed("MUL" ,CPU6301, CPU6811, 0x003d);
+ AddFixed("NOP" ,CPU6800, CPU6811, 0x0001); AddFixed("PSHX" ,CPU6301, CPU6811, 0x003c);
+ AddFixed("PSHY" ,CPU6811, CPU6811, 0x183c); AddFixed("PULX" ,CPU6301, CPU6811, 0x0038);
+ AddFixed("PULY" ,CPU6811, CPU6811, 0x1838); AddFixed("RTI" ,CPU6800, CPU6811, 0x003b);
+ AddFixed("RTS" ,CPU6800, CPU6811, 0x0039); AddFixed("SBA" ,CPU6800, CPU6811, 0x0010);
+ AddFixed("SEC" ,CPU6800, CPU6811, 0x000d); AddFixed("SEI" ,CPU6800, CPU6811, 0x000f);
+ AddFixed("SEV" ,CPU6800, CPU6811, 0x000b); AddFixed("SLP" ,CPU6301, CPU6301, 0x001a);
+ AddFixed("STOP" ,CPU6811, CPU6811, 0x00cf); AddFixed("SWI" ,CPU6800, CPU6811, 0x003f);
+ AddFixed("TAB" ,CPU6800, CPU6811, 0x0016); AddFixed("TAP" ,CPU6800, CPU6811, 0x0006);
+ AddFixed("TBA" ,CPU6800, CPU6811, 0x0017); AddFixed("TPA" ,CPU6800, CPU6811, 0x0007);
+ AddFixed("TSX" ,CPU6800, CPU6811, 0x0030); AddFixed("TSY" ,CPU6811, CPU6811, 0x1830);
+ AddFixed("TXS" ,CPU6800, CPU6811, 0x0035); AddFixed("TYS" ,CPU6811, CPU6811, 0x1835);
+ AddFixed("WAI" ,CPU6800, CPU6811, 0x003e); AddFixed("XGDX" ,CPU6811, CPU6811, 0x008f);
+ AddFixed("XGDY" ,CPU6811, CPU6811, 0x188f);
+
+ RelOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*RelOrderCnt); InstrZ=0;
+ AddRel("BCC", 0x24); AddRel("BCS", 0x25);
+ AddRel("BEQ", 0x27); AddRel("BGE", 0x2c);
+ AddRel("BGT", 0x2e); AddRel("BHI", 0x22);
+ AddRel("BHS", 0x24); AddRel("BLE", 0x2f);
+ AddRel("BLO", 0x25); AddRel("BLS", 0x23);
+ AddRel("BLT", 0x2d); AddRel("BMI", 0x2b);
+ AddRel("BNE", 0x26); AddRel("BPL", 0x2a);
+ AddRel("BRA", 0x20); AddRel("BRN", 0x21);
+ AddRel("BSR", 0x8d); AddRel("BVC", 0x28);
+ AddRel("BVS", 0x29);
+
+ ALU8Orders=(ALU8Order *) malloc(sizeof(ALU8Order)*ALU8OrderCnt); InstrZ=0;
+ AddALU8("ADC",True , 0x89);
+ AddALU8("ADD",True , 0x8b);
+ AddALU8("AND",True , 0x84);
+ AddALU8("BIT",True , 0x85);
+ AddALU8("CMP",True , 0x81);
+ AddALU8("EOR",True , 0x88);
+ AddALU8("LDA",True , 0x86);
+ AddALU8("ORA",True , 0x8a);
+ AddALU8("SBC",True , 0x82);
+ AddALU8("STA",False, 0x87);
+ AddALU8("SUB",True , 0x80);
+
+ ALU16Orders=(ALU16Order *) malloc(sizeof(ALU16Order)*ALU16OrderCnt); InstrZ=0;
+ AddALU16("ADDD", True , CPU6301, 0, 0xc3);
+ AddALU16("CPD" , True , CPU6811, 1, 0x83);
+ AddALU16("CPX" , True , CPU6800, 2, 0x8c);
+ AddALU16("CPY" , True , CPU6811, 3, 0x8c);
+ AddALU16("LDD" , True , CPU6301, 0, 0xcc);
+ AddALU16("LDS" , True , CPU6800, 0, 0x8e);
+ AddALU16("LDX" , True , CPU6800, 2, 0xce);
+ AddALU16("LDY" , True , CPU6811, 3, 0xce);
+ AddALU16("STD" , False, CPU6301, 0, 0xcd);
+ AddALU16("STS" , False, CPU6800, 0, 0x8f);
+ AddALU16("STX" , False, CPU6800, 2, 0xcf);
+ AddALU16("STY" , False, CPU6811, 3, 0xcf);
+ AddALU16("SUBD", True , CPU6301, 0, 0x83);
+
+ Sing8Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Sing8OrderCnt); InstrZ=0;
+ AddSing8("ASL", 0x48);
+ AddSing8("ASR", 0x47);
+ AddSing8("CLR", 0x4f);
+ AddSing8("COM", 0x43);
+ AddSing8("DEC", 0x4a);
+ AddSing8("INC", 0x4c);
+ AddSing8("LSL", 0x48);
+ AddSing8("LSR", 0x44);
+ AddSing8("NEG", 0x40);
+ AddSing8("ROL", 0x49);
+ AddSing8("ROR", 0x46);
+ AddSing8("TST", 0x4d);
+
+ Bit63Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Bit63OrderCnt); InstrZ=0;
+ AddBit63("AIM", 0x61); AddBit63("EIM", 0x65);
+ AddBit63("OIM", 0x62); AddBit63("TIM", 0x6b);
+END
+
+ static void DeinitFields(void)
+BEGIN
+ DestroyInstTable(InstTable);
+ free(FixedOrders);
+ free(RelOrders);
+ free(ALU8Orders);
+ free(ALU16Orders);
+ free(Sing8Orders);
+ free(Bit63Orders);
+END
+
+ static Boolean SplitAcc(char *Op)
+BEGIN
+ char Ch;
+ Integer z;
+ int OpLen=strlen(Op),OpPartLen=strlen(OpPart);
+
+ Ch=OpPart[OpPartLen-1];
+ if ((OpLen+1==OpPartLen) AND
+ (strncmp(OpPart,Op,OpLen)==0) AND
+ ((Ch=='A') OR (Ch=='B')))
+ BEGIN
+ for (z=ArgCnt; z>=1; z--) strcpy(ArgStr[z+1],ArgStr[z]);
+ ArgStr[1][0]=Ch; ArgStr[1][1]='\0';
+ OpPart[OpPartLen-1]='\0'; ArgCnt++;
+ END
+ return (Memo(Op));
+END
+
+ static Boolean DecodePseudo(void)
+BEGIN
+ return False;
+END
+
+ static void MakeCode_68(void)
+BEGIN
+ int z;
+
+ CodeLen=0; DontPrint=False; PrefCnt=0; AdrCnt=0; OpSize=0;
+
+ /* Operandengroesse festlegen */
+
+ if (*AttrPart!='\0')
+ switch (toupper(*AttrPart))
+ BEGIN
+ case 'B':OpSize=0; break;
+ case 'W':OpSize=1; break;
+ case 'L':OpSize=2; break;
+ case 'Q':OpSize=3; break;
+ case 'S':OpSize=4; break;
+ case 'D':OpSize=5; break;
+ case 'X':OpSize=6; break;
+ case 'P':OpSize=7; break;
+ default:
+ WrError(1107); return;
+ END
+
+ /* zu ignorierendes */
+
+ if (*OpPart=='\0') return;
+
+ /* Pseudoanweisungen */
+
+ if (DecodePseudo()) return;
+
+ if (DecodeMotoPseudo(True)) return;
+ if (DecodeMoto16Pseudo(OpSize,True)) return;
+
+ /* gehashtes */
+
+ if (LookupInstTable(InstTable,OpPart)) return;
+
+ /* Anweisungen ohne Argument */
+
+ /* Sonderfall : XGDX hat anderen Code bei 6301 !!!! */
+
+ if ((MomCPU==CPU6301) AND (Memo("XGDX")))
+ BEGIN
+ if (ArgCnt!=0) WrError(1110);
+ else
+ BEGIN
+ CodeLen=1; BAsmCode[0]=0x18;
+ END
+ return;
+ END
+
+ for (z=0; z<ALU8OrderCnt; z++)
+ if (SplitAcc(ALU8Orders[z].Name))
+ BEGIN
+ if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
+ else
+ BEGIN
+ DecodeAdr(2,ArgCnt,((ALU8Orders[z].MayImm)?MModImm:0)+MModInd+MModExt+MModDir);
+ if (AdrMode!=ModNone)
+ BEGIN
+ BAsmCode[PrefCnt]=
+ ALU8Orders[z].Code+(AdrPart << 4);
+ DecodeAdr(1,1,1);
+ if (AdrMode!=ModNone)
+ BEGIN
+ BAsmCode[PrefCnt]+=AdrPart << 6;
+ CodeLen=PrefCnt+1+AdrCnt;
+ memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
+ END
+ END
+ END
+ return;
+ END
+
+ for (z=0; z<Sing8OrderCnt; z++)
+ if (SplitAcc(Sing8Orders[z].Name))
+ BEGIN
+ if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
+ else
+ BEGIN
+ DecodeAdr(1,ArgCnt,MModAcc+MModExt+MModInd);
+ if (AdrMode!=ModNone)
+ BEGIN
+ CodeLen=PrefCnt+1+AdrCnt;
+ BAsmCode[PrefCnt]=Sing8Orders[z].Code+(AdrPart << 4);
+ memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
+ END
+ END
+ return;
+ END
+
+ if ((SplitAcc("PSH")) OR (SplitAcc("PUL")))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else
+ BEGIN
+ DecodeAdr(1,1,MModAcc);
+ if (AdrMode!=ModNone)
+ BEGIN
+ CodeLen=1; BAsmCode[0]=0x32+AdrPart;
+ if (Memo("PSH")) BAsmCode[0]+=4;
+ END
+ END
+ return;
+ END
+
+ WrXError(1200,OpPart);
+END
+
+ static Boolean IsDef_68(void)
+BEGIN
+ return False;
+END
+
+ static void SwitchFrom_68()
+BEGIN
+ DeinitFields();
+END
+
+ static void SwitchTo_68(void)
+BEGIN
+ TurnWords=False; ConstMode=ConstModeMoto; SetIsOccupied=False;
+
+ PCSymbol="*"; HeaderID=0x61; NOPCode=0x01;
+ DivideChars=","; HasAttrs=True; AttrChars=".";
+
+ ValidSegs=1<<SegCode;
+ Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0;
+ SegLimits[SegCode] = 0xffff;
+
+ MakeCode=MakeCode_68; IsDef=IsDef_68;
+ SwitchFrom=SwitchFrom_68; InitFields();
+ AddMoto16PseudoONOFF();
+
+ SetFlag(&DoPadding,DoPaddingName,False);
+END
+
+ void code68_init(void)
+BEGIN
+ CPU6800=AddCPU("6800",SwitchTo_68);
+ CPU6301=AddCPU("6301",SwitchTo_68);
+ CPU6811=AddCPU("6811",SwitchTo_68);
+END
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-20 11:38:31 +0000