/* 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