aboutsummaryrefslogtreecommitdiffstats
path: root/code6805.c
diff options
context:
space:
mode:
Diffstat (limited to 'code6805.c')
-rw-r--r--code6805.c786
1 files changed, 786 insertions, 0 deletions
diff --git a/code6805.c b/code6805.c
new file mode 100644
index 0000000..1da6c30
--- /dev/null
+++ b/code6805.c
@@ -0,0 +1,786 @@
+/* code6805.c */
+/*****************************************************************************/
+/* AS-Portierung */
+/* */
+/* Codegenerator 68(HC)05/08 */
+/* */
+/* Historie: 9.10.1996 Grundsteinlegung */
+/* 2. 1.1999 ChkPC-Anpassung */
+/* */
+/*****************************************************************************/
+
+#include "stdinc.h"
+
+#include <string.h>
+
+#include "bpemu.h"
+#include "strutil.h"
+
+#include "asmdef.h"
+#include "asmpars.h"
+#include "asmsub.h"
+#include "codepseudo.h"
+#include "codevars.h"
+
+
+typedef struct
+ {
+ char *Name;
+ CPUVar MinCPU;
+ Byte Code;
+ } BaseOrder;
+
+typedef struct
+ {
+ char *Name;
+ CPUVar MinCPU;
+ Byte Code;
+ Word Mask;
+ ShortInt Size;
+ } ALUOrder;
+
+typedef struct
+ {
+ char *Name;
+ CPUVar MinCPU;
+ Byte Code;
+ Word Mask;
+ } RMWOrder;
+
+#define FixedOrderCnt 52
+#define RelOrderCnt 23
+#define ALUOrderCnt 19
+#define RMWOrderCnt 12
+
+#define ModNone (-1)
+#define ModImm 0
+#define MModImm (1 << ModImm)
+#define ModDir 1
+#define MModDir (1 << ModDir)
+#define ModExt 2
+#define MModExt (1 << ModExt)
+#define ModIx2 3
+#define MModIx2 (1 << ModIx2)
+#define ModIx1 4
+#define MModIx1 (1 << ModIx1)
+#define ModIx 5
+#define MModIx (1 << ModIx)
+#define ModSP2 6
+#define MModSP2 (1 << ModSP2)
+#define ModSP1 7
+#define MModSP1 (1 << ModSP1)
+#define ModIxP 8
+#define MModIxP (1 << ModIxP)
+#define MMod05 (MModImm+MModDir+MModExt+MModIx2+MModIx1+MModIx)
+#define MMod08 (MModSP2+MModSP1+MModIxP)
+
+static ShortInt AdrMode,OpSize;
+static Byte AdrVals[2];
+
+static CPUVar CPU6805,CPU6808;
+
+static BaseOrder *FixedOrders;
+static BaseOrder *RelOrders;
+static RMWOrder *RMWOrders;
+static ALUOrder *ALUOrders;
+
+/*--------------------------------------------------------------------------*/
+
+ static void AddFixed(char *NName, CPUVar NMin, Byte NCode)
+BEGIN
+ if (InstrZ>=FixedOrderCnt) exit(255);
+ FixedOrders[InstrZ].Name=NName;
+ FixedOrders[InstrZ].MinCPU=NMin;
+ FixedOrders[InstrZ++].Code=NCode;
+END
+
+ static void AddRel(char *NName, CPUVar NMin, Byte NCode)
+BEGIN
+ if (InstrZ>=RelOrderCnt) exit(255);
+ RelOrders[InstrZ].Name=NName;
+ RelOrders[InstrZ].MinCPU=NMin;
+ RelOrders[InstrZ++].Code=NCode;
+END
+
+ static void AddALU(char *NName, CPUVar NMin, Byte NCode, Word NMask, ShortInt NSize)
+BEGIN
+ if (InstrZ>=ALUOrderCnt) exit(255);
+ ALUOrders[InstrZ].Name=NName;
+ ALUOrders[InstrZ].MinCPU=NMin;
+ ALUOrders[InstrZ].Code=NCode;
+ ALUOrders[InstrZ].Mask=NMask;
+ ALUOrders[InstrZ++].Size=NSize;
+END
+
+ static void AddRMW(char *NName, CPUVar NMin, Byte NCode ,Word NMask)
+BEGIN
+ if (InstrZ>=RMWOrderCnt) exit(255);
+ RMWOrders[InstrZ].Name=NName;
+ RMWOrders[InstrZ].MinCPU=NMin;
+ RMWOrders[InstrZ].Code=NCode;
+ RMWOrders[InstrZ++].Mask=NMask;
+END
+
+ static void InitFields(void)
+BEGIN
+ FixedOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*FixedOrderCnt); InstrZ=0;
+ AddFixed("RTI" ,CPU6805,0x80); AddFixed("RTS" ,CPU6805,0x81);
+ AddFixed("SWI" ,CPU6805,0x83); AddFixed("TAX" ,CPU6805,0x97);
+ AddFixed("CLC" ,CPU6805,0x98); AddFixed("SEC" ,CPU6805,0x99);
+ AddFixed("CLI" ,CPU6805,0x9a); AddFixed("SEI" ,CPU6805,0x9b);
+ AddFixed("RSP" ,CPU6805,0x9c); AddFixed("NOP" ,CPU6805,0x9d);
+ AddFixed("TXA" ,CPU6805,0x9f); AddFixed("NEGA",CPU6805,0x40);
+ AddFixed("NEGX",CPU6805,0x50); AddFixed("COMA",CPU6805,0x43);
+ AddFixed("COMX",CPU6805,0x53); AddFixed("LSRA",CPU6805,0x44);
+ AddFixed("LSRX",CPU6805,0x54); AddFixed("RORA",CPU6805,0x46);
+ AddFixed("RORX",CPU6805,0x56); AddFixed("ASRA",CPU6805,0x47);
+ AddFixed("ASRX",CPU6805,0x57); AddFixed("ASLA",CPU6805,0x48);
+ AddFixed("ASLX",CPU6805,0x58); AddFixed("LSLA",CPU6805,0x48);
+ AddFixed("LSLX",CPU6805,0x58); AddFixed("ROLA",CPU6805,0x49);
+ AddFixed("ROLX",CPU6805,0x59); AddFixed("DECA",CPU6805,0x4a);
+ AddFixed("DECX",CPU6805,0x5a); AddFixed("INCA",CPU6805,0x4c);
+ AddFixed("INCX",CPU6805,0x5c); AddFixed("TSTA",CPU6805,0x4d);
+ AddFixed("TSTX",CPU6805,0x5d); AddFixed("CLRA",CPU6805,0x4f);
+ AddFixed("CLRX",CPU6805,0x5f); AddFixed("CLRH",CPU6808,0x8c);
+ AddFixed("DAA" ,CPU6808,0x72); AddFixed("DIV" ,CPU6808,0x52);
+ AddFixed("MUL" ,CPU6805,0x42); AddFixed("NSA" ,CPU6808,0x62);
+ AddFixed("PSHA",CPU6808,0x87); AddFixed("PSHH",CPU6808,0x8b);
+ AddFixed("PSHX",CPU6808,0x89); AddFixed("PULA",CPU6808,0x86);
+ AddFixed("PULH",CPU6808,0x8a); AddFixed("PULX",CPU6808,0x88);
+ AddFixed("STOP",CPU6805,0x8e); AddFixed("TAP" ,CPU6808,0x84);
+ AddFixed("TPA" ,CPU6808,0x85); AddFixed("TSX" ,CPU6808,0x95);
+ AddFixed("TXS" ,CPU6808,0x94); AddFixed("WAIT",CPU6805,0x8f);
+
+ RelOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*RelOrderCnt); InstrZ=0;
+ AddRel("BRA" ,CPU6805,0x20); AddRel("BRN" ,CPU6805,0x21);
+ AddRel("BHI" ,CPU6805,0x22); AddRel("BLS" ,CPU6805,0x23);
+ AddRel("BCC" ,CPU6805,0x24); AddRel("BCS" ,CPU6805,0x25);
+ AddRel("BNE" ,CPU6805,0x26); AddRel("BEQ" ,CPU6805,0x27);
+ AddRel("BHCC",CPU6805,0x28); AddRel("BHCS",CPU6805,0x29);
+ AddRel("BPL" ,CPU6805,0x2a); AddRel("BMI" ,CPU6805,0x2b);
+ AddRel("BMC" ,CPU6805,0x2c); AddRel("BMS" ,CPU6805,0x2d);
+ AddRel("BIL" ,CPU6805,0x2e); AddRel("BIH" ,CPU6805,0x2f);
+ AddRel("BSR" ,CPU6805,0xad); AddRel("BGE" ,CPU6808,0x90);
+ AddRel("BGT" ,CPU6808,0x92); AddRel("BHS" ,CPU6805,0x24);
+ AddRel("BLE" ,CPU6808,0x93); AddRel("BLO" ,CPU6805,0x25);
+ AddRel("BLT" ,CPU6808,0x91);
+
+ ALUOrders=(ALUOrder *) malloc(sizeof(ALUOrder)*ALUOrderCnt); InstrZ=0;
+ AddALU("SUB" ,CPU6805,0x00,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("CMP" ,CPU6805,0x01,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("SBC" ,CPU6805,0x02,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("CPX" ,CPU6805,0x03,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("AND" ,CPU6805,0x04,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("BIT" ,CPU6805,0x05,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("LDA" ,CPU6805,0x06,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("STA" ,CPU6805,0x07, MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("EOR" ,CPU6805,0x08,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("ADC" ,CPU6805,0x09,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("ORA" ,CPU6805,0x0a,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("ADD" ,CPU6805,0x0b,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("JMP" ,CPU6805,0x0c, MModDir+MModExt+MModIx+MModIx1+MModIx2 ,-1);
+ AddALU("JSR" ,CPU6805,0x0d, MModDir+MModExt+MModIx+MModIx1+MModIx2 ,-1);
+ AddALU("LDX" ,CPU6805,0x0e,MModImm+MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("STX" ,CPU6805,0x0f, MModDir+MModExt+MModIx+MModIx1+MModIx2+MModSP1+MModSP2,0);
+ AddALU("CPHX",CPU6808,0xc5,MModImm+MModDir ,1);
+ AddALU("LDHX",CPU6808,0xa5,MModImm+MModDir ,1);
+ AddALU("STHX",CPU6808,0x85, MModDir ,1);
+
+ RMWOrders=(RMWOrder *) malloc(sizeof(RMWOrder)*RMWOrderCnt); InstrZ=0;
+ AddRMW("NEG",CPU6805,0x00,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("COM",CPU6805,0x03,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("LSR",CPU6805,0x04,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("ROR",CPU6805,0x06,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("ASR",CPU6805,0x07,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("ASL",CPU6805,0x08,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("LSL",CPU6805,0x08,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("ROL",CPU6805,0x09,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("DEC",CPU6805,0x0a,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("INC",CPU6805,0x0c,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("TST",CPU6805,0x0d,MModDir+ MModIx+MModIx1+ MModSP1 );
+ AddRMW("CLR",CPU6805,0x0f,MModDir+ MModIx+MModIx1+ MModSP1 );
+END
+
+ static void DeinitFields(void)
+BEGIN
+ free(FixedOrders);
+ free(RelOrders);
+ free(ALUOrders);
+ free(RMWOrders);
+END
+
+/*--------------------------------------------------------------------------*/
+
+
+ static void ChkZero(char *s, char *serg, Byte *Erg)
+BEGIN
+ if (*s=='<')
+ BEGIN
+ strcpy(serg,s+1); *Erg=2;
+ END
+ else if (*s=='>')
+ BEGIN
+ strcpy(serg,s+1); *Erg=1;
+ END
+ else
+ BEGIN
+ strcpy(serg,s); *Erg=0;
+ END
+END
+
+ static void ChkAdr(Word Mask, Word Mask08)
+BEGIN
+ if ((AdrMode!=ModNone) AND ((Mask & (1 << AdrMode))==0))
+ BEGIN
+ WrError( (((1 << AdrMode) AND Mask08)==0) ? 1350 : 1505);
+ AdrMode=ModNone; AdrCnt=0;
+ END
+END
+
+ static void DecodeAdr(Byte Start, Byte Stop, Word Mask)
+BEGIN
+ Boolean OK;
+ Word AdrWord,Mask08;
+ Byte ZeroMode;
+ String s;
+ ShortInt tmode1,tmode2;
+
+ AdrMode=ModNone; AdrCnt=0;
+
+ Mask08=Mask & MMod08;
+ if (MomCPU==CPU6805) Mask&=MMod05;
+
+ if (Stop-Start==1)
+ BEGIN
+ if (strcasecmp(ArgStr[Stop],"X")==0)
+ BEGIN
+ tmode1=ModIx1; tmode2=ModIx2;
+ END
+ else if (strcasecmp(ArgStr[Stop],"SP")==0)
+ BEGIN
+ tmode1=ModSP1; tmode2=ModSP2;
+ if (MomCPU<CPU6808)
+ BEGIN
+ WrXError(1445,ArgStr[Stop]); ChkAdr(Mask,Mask08); return;
+ END
+ END
+ else
+ BEGIN
+ WrXError(1445,ArgStr[Stop]); ChkAdr(Mask,Mask08); return;
+ END
+
+ ChkZero(ArgStr[Start],s,&ZeroMode);
+ FirstPassUnknown=False;
+ AdrWord=EvalIntExpression(s,(ZeroMode==2)?Int8:Int16,&OK);
+
+ if (OK)
+ BEGIN
+ if ((ZeroMode==0) AND (AdrWord==0) AND (Mask AND MModIx!=0) AND (tmode1==ModIx1)) AdrMode=ModIx;
+
+ else if (((Mask AND (1 << tmode2))==0) OR (ZeroMode==2) OR ((ZeroMode==0) AND (Hi(AdrWord)==0)))
+ BEGIN
+ if (FirstPassUnknown) AdrWord&=0xff;
+ if (Hi(AdrWord)!=0) WrError(1340);
+ else
+ BEGIN
+ AdrCnt=1; AdrVals[0]=Lo(AdrWord); AdrMode=tmode1;
+ END
+ END
+
+ else
+ BEGIN
+ AdrVals[0]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord);
+ AdrCnt=2; AdrMode=tmode2;
+ END
+ END
+ END
+
+ else if (Stop==Start)
+ BEGIN
+ /* Postinkrement */
+
+ if (strcasecmp(ArgStr[Start],"X+")==0)
+ BEGIN
+ AdrMode=ModIxP; ChkAdr(Mask,Mask08); return;
+ END
+
+ /* X-indirekt */
+
+ if (strcasecmp(ArgStr[Start],"X")==0)
+ BEGIN
+ AdrMode=ModIx; ChkAdr(Mask,Mask08); return;
+ END
+
+ /* immediate */
+
+ if (*ArgStr[Start]=='#')
+ BEGIN
+ switch (OpSize)
+ BEGIN
+ case -1:
+ WrError(1132); break;
+ case 0:
+ AdrVals[0]=EvalIntExpression(ArgStr[Start]+1,Int8,&OK);
+ if (OK)
+ BEGIN
+ AdrCnt=1; AdrMode=ModImm;
+ END
+ break;
+ case 1:
+ AdrWord=EvalIntExpression(ArgStr[Start]+1,Int16,&OK);
+ if (OK)
+ BEGIN
+ AdrVals[0]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord);
+ AdrCnt=2; AdrMode=ModImm;
+ END
+ break;
+ END
+ ChkAdr(Mask,Mask08); return;
+ END
+
+ /* absolut */
+
+ ChkZero(ArgStr[Start],s,&ZeroMode);
+ FirstPassUnknown=False;
+ AdrWord=EvalIntExpression(s,(ZeroMode==2)?UInt8:UInt16,&OK);
+
+ if (OK)
+ BEGIN
+ if (((Mask & MModExt)==0) OR (ZeroMode==2) OR ((ZeroMode==0) AND (Hi(AdrWord)==0)))
+ BEGIN
+ if (FirstPassUnknown) AdrWord&=0xff;
+ if (Hi(AdrWord)!=0) WrError(1340);
+ else
+ BEGIN
+ AdrCnt=1; AdrVals[0]=Lo(AdrWord); AdrMode=ModDir;
+ END
+ END
+ else
+ BEGIN
+ AdrVals[0]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord);
+ AdrCnt=2; AdrMode=ModExt;
+ END
+ ChkAdr(Mask,Mask08); return;
+ END
+ END
+
+ else WrError(1110);
+
+
+ ChkAdr(Mask,Mask08);
+END
+
+ static Boolean DecodePseudo(void)
+BEGIN
+ return False;
+END
+
+ static void MakeCode_6805(void)
+BEGIN
+ int z;
+ Integer AdrInt;
+ Boolean OK;
+ char ch;
+
+ CodeLen=0; DontPrint=False; OpSize=(-1);
+
+ /* zu ignorierendes */
+
+ if (Memo("")) return;
+
+ /* Pseudoanweisungen */
+
+ if (DecodePseudo()) return;
+
+ if (DecodeMotoPseudo(True)) return;
+
+ /* Anweisungen ohne Argument */
+
+ for (z=0; z<FixedOrderCnt; z++)
+ if (Memo(FixedOrders[z].Name))
+ BEGIN
+ if (ArgCnt!=0) WrError(1110);
+ else if (MomCPU<FixedOrders[z].MinCPU) WrXError(1500,OpPart);
+ else
+ BEGIN
+ CodeLen=1; BAsmCode[0]=FixedOrders[z].Code;
+ END
+ return;
+ END
+
+ /* Datentransfer */
+
+ if (Memo("MOV"))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (MomCPU<CPU6808) WrXError(1500,OpPart);
+ else
+ BEGIN
+ OpSize=0; DecodeAdr(1,1,MModImm+MModDir+MModIxP);
+ switch (AdrMode)
+ BEGIN
+ case ModImm:
+ BAsmCode[1]=AdrVals[0]; DecodeAdr(2,2,MModDir);
+ if (AdrMode==ModDir)
+ BEGIN
+ BAsmCode[0]=0x6e; BAsmCode[2]=AdrVals[0]; CodeLen=3;
+ END
+ break;
+ case ModDir:
+ BAsmCode[1]=AdrVals[0]; DecodeAdr(2,2,MModDir+MModIxP);
+ switch (AdrMode)
+ BEGIN
+ case ModDir:
+ BAsmCode[0]=0x4e; BAsmCode[2]=AdrVals[0]; CodeLen=3;
+ break;
+ case ModIxP:
+ BAsmCode[0]=0x5e; CodeLen=2;
+ break;
+ END
+ break;
+ case ModIxP:
+ DecodeAdr(2,2,MModDir);
+ if (AdrMode==ModDir)
+ BEGIN
+ BAsmCode[0]=0x7e; BAsmCode[1]=AdrVals[0]; CodeLen=2;
+ END
+ break;
+ END
+ END
+ return;
+ END
+
+ /* relative Spruenge */
+
+ for (z=0; z<RelOrderCnt; z++)
+ if Memo(RelOrders[z].Name)
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (MomCPU<RelOrders[z].MinCPU) WrXError(1500,OpPart);
+ else
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[1],UInt16,&OK)-(EProgCounter()+2);
+ if (OK)
+ if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+ else
+ BEGIN
+ CodeLen=2; BAsmCode[0]=RelOrders[z].Code; BAsmCode[1]=Lo(AdrInt);
+ END
+ END
+ return;
+ END
+
+ if ((Memo("CBEQA")) OR (Memo("CBEQX")))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (MomCPU<CPU6808) WrXError(1500,OpPart);
+ else
+ BEGIN
+ OpSize=0; DecodeAdr(1,1,MModImm);
+ if (AdrMode==ModImm)
+ BEGIN
+ BAsmCode[1]=AdrVals[0];
+ AdrInt=EvalIntExpression(ArgStr[2],UInt16,&OK)-(EProgCounter()+3);
+ if (OK)
+ if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+ else
+ BEGIN
+ BAsmCode[0]=0x41+(Ord(Memo("CBEQX")) << 4);
+ BAsmCode[2]=AdrInt & 0xff;
+ CodeLen=3;
+ END
+ END
+ END
+ return;
+ END
+
+ if (Memo("CBEQ"))
+ BEGIN
+ if (MomCPU<CPU6808) WrXError(1500,OpPart);
+ else if (ArgCnt==2)
+ BEGIN
+ DecodeAdr(1,1,MModDir+MModIxP);
+ switch (AdrMode)
+ BEGIN
+ case ModDir:
+ BAsmCode[0]=0x31; BAsmCode[1]=AdrVals[0]; z=3;
+ break;
+ case ModIxP:
+ BAsmCode[0]=0x71; z=2;
+ break;
+ END;
+ if (AdrMode!=ModNone)
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[2],UInt16,&OK)-(EProgCounter()+z);
+ if (OK)
+ if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+ else
+ BEGIN
+ BAsmCode[z-1]=AdrInt & 0xff; CodeLen=z;
+ END
+ END
+ END
+ else if (ArgCnt==3)
+ BEGIN
+ OK=True;
+ if (strcasecmp(ArgStr[2],"X+")==0) z=3;
+ else if (strcasecmp(ArgStr[2],"SP")==0)
+ BEGIN
+ BAsmCode[0]=0x9e; z=4;
+ END
+ else
+ BEGIN
+ WrXError(1445,ArgStr[2]); OK=False;
+ END
+ if (OK)
+ BEGIN
+ BAsmCode[z-3]=0x61;
+ BAsmCode[z-2]=EvalIntExpression(ArgStr[1],UInt8,&OK);
+ if (OK)
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[3],UInt16,&OK)-(EProgCounter()+z);
+ if (OK)
+ if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+ else
+ BEGIN
+ BAsmCode[z-1]=AdrInt & 0xff; CodeLen=z;
+ END
+ END
+ END
+ END
+ else WrError(1110);
+ return;
+ END
+
+ if ((Memo("DBNZA")) OR (Memo("DBNZX")))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (MomCPU<CPU6808) WrXError(1500,OpPart);
+ else
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[1],UInt16,&OK)-(EProgCounter()+2);
+ if (OK)
+ if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+ else
+ BEGIN
+ BAsmCode[0]=0x4b+(Ord(Memo("DBNZX")) << 4);
+ BAsmCode[1]=AdrInt & 0xff;
+ CodeLen=2;
+ END
+ END
+ return;
+ END
+
+ if (Memo("DBNZ"))
+ BEGIN
+ if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
+ else if (MomCPU<CPU6808) WrXError(1500,OpPart);
+ else
+ BEGIN
+ DecodeAdr(1,ArgCnt-1,MModDir+MModIx+MModIx1+MModSP1);
+ switch (AdrMode)
+ BEGIN
+ case ModDir:
+ BAsmCode[0]=0x3b; BAsmCode[1]=AdrVals[0]; z=3;
+ break;
+ case ModIx:
+ BAsmCode[0]=0x7b; z=2;
+ break;
+ case ModIx1:
+ BAsmCode[0]=0x6b; BAsmCode[1]=AdrVals[0]; z=3;
+ break;
+ case ModSP1:
+ BAsmCode[0]=0x9e; BAsmCode[1]=0x6b; BAsmCode[2]=AdrVals[0]; z=4;
+ break;
+ END
+ if (AdrMode!=ModNone)
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[ArgCnt],UInt16,&OK)-(EProgCounter()+z);
+ if (OK)
+ if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+ else
+ BEGIN
+ BAsmCode[z-1]=AdrInt & 0xff; CodeLen=z;
+ END
+ END
+ END
+ return;
+ END
+
+ /* ALU-Operationen */
+
+ for (z=0; z<ALUOrderCnt; z++)
+ if Memo(ALUOrders[z].Name)
+ BEGIN
+ if (MomCPU<ALUOrders[z].MinCPU) WrXError(1500,OpPart);
+ else
+ BEGIN
+ OpSize=ALUOrders[z].Size;
+ DecodeAdr(1,ArgCnt,ALUOrders[z].Mask);
+ if (AdrMode!=ModNone)
+ BEGIN
+ switch (AdrMode)
+ BEGIN
+ case ModImm :
+ BAsmCode[0]=0xa0+ALUOrders[z].Code; CodeLen=1;
+ break;
+ case ModDir :
+ BAsmCode[0]=0xb0+ALUOrders[z].Code; CodeLen=1;
+ break;
+ case ModExt :
+ BAsmCode[0]=0xc0+ALUOrders[z].Code; CodeLen=1;
+ break;
+ case ModIx :
+ BAsmCode[0]=0xf0+ALUOrders[z].Code; CodeLen=1;
+ break;
+ case ModIx1 :
+ BAsmCode[0]=0xe0+ALUOrders[z].Code; CodeLen=1;
+ break;
+ case ModIx2 :
+ BAsmCode[0]=0xd0+ALUOrders[z].Code; CodeLen=1;
+ break;
+ case ModSP1 :
+ BAsmCode[0]=0x9e; BAsmCode[1]=0xe0+ALUOrders[z].Code; CodeLen=2;
+ break;
+ case ModSP2 :
+ BAsmCode[0]=0x9e; BAsmCode[1]=0xd0+ALUOrders[z].Code; CodeLen=2;
+ break;
+ END
+ memcpy(BAsmCode+CodeLen,AdrVals,AdrCnt); CodeLen+=AdrCnt;
+ END
+ END
+ return;
+ END
+
+ if ((Memo("AIX")) OR (Memo("AIS")))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (MomCPU<CPU6808) WrXError(1500,OpPart);
+ else if (*ArgStr[1]!='#') WrError(1350);
+ else
+ BEGIN
+ BAsmCode[1]=EvalIntExpression(ArgStr[1]+1,SInt8,&OK);
+ if (OK)
+ BEGIN
+ BAsmCode[0]=0xa7+(Ord(Memo("AIX")) << 3); CodeLen=2;
+ END
+ END
+ return;
+ END
+
+ /* Read/Modify/Write-Operationen */
+
+ for (z=0; z<RMWOrderCnt; z++)
+ if Memo(RMWOrders[z].Name)
+ BEGIN
+ if (MomCPU<RMWOrders[z].MinCPU) WrXError(1500,OpPart);
+ else
+ BEGIN
+ DecodeAdr(1,ArgCnt,RMWOrders[z].Mask);
+ if (AdrMode!=ModNone)
+ BEGIN
+ switch (AdrMode)
+ BEGIN
+ case ModDir :
+ BAsmCode[0]=0x30+RMWOrders[z].Code; CodeLen=1;
+ break;
+ case ModIx :
+ BAsmCode[0]=0x70+RMWOrders[z].Code; CodeLen=1;
+ break;
+ case ModIx1 :
+ BAsmCode[0]=0x60+RMWOrders[z].Code; CodeLen=1;
+ break;
+ case ModSP1 :
+ BAsmCode[0]=0x9e; BAsmCode[1]=0x60+RMWOrders[z].Code; CodeLen=2;
+ break;
+ END
+ memcpy(BAsmCode+CodeLen,AdrVals,AdrCnt); CodeLen+=AdrCnt;
+ END
+ END
+ return;
+ END
+
+ ch=OpPart[strlen(OpPart)-1];
+ if ((ch>='0') AND (ch<='7'))
+ BEGIN
+ for (z=ArgCnt; z>=1; z--) strcpy(ArgStr[z+1],ArgStr[z]);
+ *ArgStr[1]=ch; ArgStr[1][1]='\0'; ArgCnt++;
+ OpPart[strlen(OpPart)-1]='\0';
+ END
+
+ if ((Memo("BSET")) OR (Memo("BCLR")))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else
+ BEGIN
+ BAsmCode[1]=EvalIntExpression(ArgStr[2],Int8,&OK);
+ if (OK)
+ BEGIN
+ BAsmCode[0]=EvalIntExpression(ArgStr[1],UInt3,&OK);
+ if (OK)
+ BEGIN
+ CodeLen=2; BAsmCode[0]=0x10+(BAsmCode[0] << 1)+Ord(Memo("BCLR"));
+ END
+ END
+ END
+ return;
+ END
+
+ if ((Memo("BRSET")) OR (Memo("BRCLR")))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else
+ BEGIN
+ BAsmCode[1]=EvalIntExpression(ArgStr[2],Int8,&OK);
+ if (OK)
+ BEGIN
+ BAsmCode[0]=EvalIntExpression(ArgStr[1],UInt3,&OK);
+ if (OK)
+ BEGIN
+ AdrInt=EvalIntExpression(ArgStr[3],UInt16,&OK)-(EProgCounter()+3);
+ if (OK)
+ if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370);
+ else
+ BEGIN
+ CodeLen=3; BAsmCode[0]=(BAsmCode[0] << 1)+Ord(Memo("BRCLR"));
+ BAsmCode[2]=Lo(AdrInt);
+ END
+ END
+ END
+ END
+ return;
+ END
+
+ WrXError(1200,OpPart);
+END
+
+ static Boolean IsDef_6805(void)
+BEGIN
+ return False;
+END
+
+ static void SwitchFrom_6805(void)
+BEGIN
+ DeinitFields();
+END
+
+ static void SwitchTo_6805(void)
+BEGIN
+ TurnWords=False; ConstMode=ConstModeMoto; SetIsOccupied=False;
+
+ PCSymbol="*"; HeaderID=0x62; NOPCode=0x9d;
+ DivideChars=","; HasAttrs=False;
+
+ ValidSegs=(1<<SegCode);
+ Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0;
+ SegLimits[SegCode] = 0x1fff;
+
+ MakeCode=MakeCode_6805; IsDef=IsDef_6805;
+ SwitchFrom=SwitchFrom_6805; InitFields();
+END
+
+ void code6805_init(void)
+BEGIN
+ CPU6805=AddCPU("6805",SwitchTo_6805);
+ CPU6808=AddCPU("68HC08",SwitchTo_6805);
+END
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-24 16:12:51 +0000