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

---
 code6805.c | 786 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 786 insertions(+)
 create mode 100644 code6805.c

(limited to 'code6805.c')

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
-- 
cgit v1.2.3