/* code6816.c */
/*****************************************************************************/
/* AS-Portierung                                                             */
/*                                                                           */
/* Codegeneratormodul CPU16                                                  */
/*                                                                           */
/* Historie: 15.10.1996 Grundsteinlegung                                     */
/*            2. 1.1999 ChkPC-Anpassung                                      */
/*                                                                           */
/*****************************************************************************/

#include "stdinc.h"

#include <string.h>

#include "nls.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;
          ShortInt Size;
          Word Code,ExtCode;
          Byte AdrMask,ExtShift;
         } GenOrder;

typedef struct
         {
          char *Name;
          Word Code1,Code2;
         } EmuOrder;

#define FixedOrderCnt 140
#define RelOrderCnt 18
#define LRelOrderCnt 3
#define GenOrderCnt 66
#define AuxOrderCnt 12
#define ImmOrderCnt 4
#define ExtOrderCnt 3
#define EmuOrderCnt 6
#define RegCnt 7

#define ModNone (-1)
#define ModDisp8 0
#define MModDisp8 (1 << ModDisp8)
#define ModDisp16 1
#define MModDisp16 (1 << ModDisp16)
#define ModDispE 2
#define MModDispE (1 << ModDispE)
#define ModAbs 3
#define MModAbs (1 << ModAbs)
#define ModImm 4
#define MModImm (1 << ModImm)
#define ModImmExt 5
#define MModImmExt (1 << ModImmExt)
#define ModDisp20 ModDisp16
#define MModDisp20 MModDisp16
#define ModAbs20 ModAbs
#define MModAbs20 MModAbs

static ShortInt OpSize;
static ShortInt AdrMode;
static Byte AdrPart;
static Byte AdrVals[4];

static LongInt Reg_EK;
static SimpProc SaveInitProc;

static FixedOrder *FixedOrders;
static FixedOrder *RelOrders;
static FixedOrder *LRelOrders;
static GenOrder *GenOrders;
static FixedOrder *AuxOrders;
static FixedOrder *ImmOrders;
static FixedOrder *ExtOrders;
static EmuOrder *EmuOrders;
static char **Regs;

static CPUVar CPU6816;

/*-------------------------------------------------------------------------*/

        static void AddFixed(char *NName, Word NCode)
BEGIN
   if (InstrZ>=FixedOrderCnt) exit(255);
   FixedOrders[InstrZ].Name=NName;
   FixedOrders[InstrZ++].Code=NCode;
END

        static void AddRel(char *NName, Word NCode)
BEGIN
   if (InstrZ>=RelOrderCnt) exit(255);
   RelOrders[InstrZ].Name=NName;
   RelOrders[InstrZ++].Code=NCode;
END

        static void AddLRel(char *NName, Word NCode)
BEGIN
   if (InstrZ>=LRelOrderCnt) exit(255);
   LRelOrders[InstrZ].Name=NName;
   LRelOrders[InstrZ++].Code=NCode;
END

        static void AddGen(char *NName, ShortInt NSize, Word NCode,
                           Word NExtCode, Byte NShift, Byte NMask)
BEGIN
   if (InstrZ>=GenOrderCnt) exit(255);
   GenOrders[InstrZ].Name=NName;
   GenOrders[InstrZ].Code=NCode;
   GenOrders[InstrZ].ExtCode=NExtCode;
   GenOrders[InstrZ].Size=NSize;
   GenOrders[InstrZ].AdrMask=NMask;
   GenOrders[InstrZ++].ExtShift=NShift;
END

        static void AddAux(char *NName, Word NCode)
BEGIN
   if (InstrZ>=AuxOrderCnt) exit(255);
   AuxOrders[InstrZ].Name=NName;
   AuxOrders[InstrZ++].Code=NCode;
END

        static void AddImm(char *NName, Word NCode)
BEGIN
   if (InstrZ>=ImmOrderCnt) exit(255);
   ImmOrders[InstrZ].Name=NName;
   ImmOrders[InstrZ++].Code=NCode;
END

        static void AddExt(char *NName, Word NCode)
BEGIN
   if (InstrZ>=ExtOrderCnt) exit(255);
   ExtOrders[InstrZ].Name=NName; 
   ExtOrders[InstrZ++].Code=NCode;
END

        static void AddEmu(char *NName, Word NCode1, Word NCode2)
BEGIN
   if (InstrZ>=EmuOrderCnt) exit(255);
   EmuOrders[InstrZ].Name=NName;
   EmuOrders[InstrZ].Code1=NCode1;
   EmuOrders[InstrZ++].Code2=NCode2;
END

	static void InitFields(void)
BEGIN
   FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0;
   AddFixed("ABA"   ,0x370b); AddFixed("ABX"   ,0x374f);
   AddFixed("ABY"   ,0x375f); AddFixed("ABZ"   ,0x376f);
   AddFixed("ACE"   ,0x3722); AddFixed("ACED"  ,0x3723);
   AddFixed("ADE"   ,0x2778); AddFixed("ADX"   ,0x37cd);
   AddFixed("ADY"   ,0x37dd); AddFixed("ADZ"   ,0x37ed);
   AddFixed("AEX"   ,0x374d); AddFixed("AEY"   ,0x375d);
   AddFixed("AEZ"   ,0x376d); AddFixed("ASLA"  ,0x3704);
   AddFixed("ASLB"  ,0x3714); AddFixed("ASLD"  ,0x27f4);
   AddFixed("ASLE"  ,0x2774); AddFixed("ASLM"  ,0x27b6);
   AddFixed("LSLB"  ,0x3714); AddFixed("LSLD"  ,0x27f4);
   AddFixed("LSLE"  ,0x2774); AddFixed("LSLA"  ,0x3704);
   AddFixed("ASRA"  ,0x370d); AddFixed("ASRB"  ,0x371d);
   AddFixed("ASRD"  ,0x27fd); AddFixed("ASRE"  ,0x277d);
   AddFixed("ASRM"  ,0x27ba); AddFixed("BGND"  ,0x37a6);
   AddFixed("CBA"   ,0x371b); AddFixed("CLRA"  ,0x3705);
   AddFixed("CLRB"  ,0x3715); AddFixed("CLRD"  ,0x27f5);
   AddFixed("CLRE"  ,0x2775); AddFixed("CLRM"  ,0x27b7);
   AddFixed("COMA"  ,0x3700); AddFixed("COMB"  ,0x3710);
   AddFixed("COMD"  ,0x27f0); AddFixed("COME"  ,0x2770);
   AddFixed("DAA"   ,0x3721); AddFixed("DECA"  ,0x3701);
   AddFixed("DECB"  ,0x3711); AddFixed("EDIV"  ,0x3728);
   AddFixed("EDIVS" ,0x3729); AddFixed("EMUL"  ,0x3725);
   AddFixed("EMULS" ,0x3726); AddFixed("FDIV"  ,0x372b);
   AddFixed("FMULS" ,0x3727); AddFixed("IDIV"  ,0x372a);
   AddFixed("INCA"  ,0x3703); AddFixed("INCB"  ,0x3713);
   AddFixed("LPSTOP",0x27f1); AddFixed("LSRA"  ,0x370f);
   AddFixed("LSRB"  ,0x371f); AddFixed("LSRD"  ,0x27ff);
   AddFixed("LSRE"  ,0x277f); AddFixed("MUL"   ,0x3724);
   AddFixed("NEGA"  ,0x3702); AddFixed("NEGB"  ,0x3712);
   AddFixed("NEGD"  ,0x27f2); AddFixed("NEGE"  ,0x2772);
   AddFixed("NOP"   ,0x274c); AddFixed("PSHA"  ,0x3708);
   AddFixed("PSHB"  ,0x3718); AddFixed("PSHMAC",0x27b8);
   AddFixed("PULA"  ,0x3709); AddFixed("PULB"  ,0x3719);
   AddFixed("PULMAC",0x27b9); AddFixed("ROLA"  ,0x370c);
   AddFixed("ROLB"  ,0x371c); AddFixed("ROLD"  ,0x27fc);
   AddFixed("ROLE"  ,0x277c); AddFixed("RORA"  ,0x370e);
   AddFixed("RORB"  ,0x371e); AddFixed("RORD"  ,0x27fe);
   AddFixed("RORE"  ,0x277e); AddFixed("RTI"   ,0x2777);
   AddFixed("RTS"   ,0x27f7); AddFixed("SBA"   ,0x370a);
   AddFixed("SDE"   ,0x2779); AddFixed("SWI"   ,0x3720);
   AddFixed("SXT"   ,0x27f8); AddFixed("TAB"   ,0x3717);
   AddFixed("TAP"   ,0x37fd); AddFixed("TBA"   ,0x3707);
   AddFixed("TBEK"  ,0x27fa); AddFixed("TBSK"  ,0x379f);
   AddFixed("TBXK"  ,0x379c); AddFixed("TBYK"  ,0x379d);
   AddFixed("TBZK"  ,0x379e); AddFixed("TDE"   ,0x277b);
   AddFixed("TDMSK" ,0x372f); AddFixed("TDP"   ,0x372d);
   AddFixed("TED"   ,0x27fb); AddFixed("TEDM"  ,0x27b1);
   AddFixed("TEKB"  ,0x27bb); AddFixed("TEM"   ,0x27b2);
   AddFixed("TMER"  ,0x27b4); AddFixed("TMET"  ,0x27b5);
   AddFixed("TMXED" ,0x27b3); AddFixed("TPA"   ,0x37fc);
   AddFixed("TPD"   ,0x372c); AddFixed("TSKB"  ,0x37af);
   AddFixed("TSTA"  ,0x3706); AddFixed("TSTB"  ,0x3716);
   AddFixed("TSTD"  ,0x27f6); AddFixed("TSTE"  ,0x2776);
   AddFixed("TSX"   ,0x274f); AddFixed("TSY"   ,0x275f);
   AddFixed("TSZ"   ,0x276f); AddFixed("TXKB"  ,0x37ac);
   AddFixed("TXS"   ,0x374e); AddFixed("TXY"   ,0x275c);
   AddFixed("TXZ"   ,0x276c); AddFixed("TYKB"  ,0x37ad);
   AddFixed("TYS"   ,0x375e); AddFixed("TYX"   ,0x274d);
   AddFixed("TYZ"   ,0x276d); AddFixed("TZKB"  ,0x37ae);
   AddFixed("TZS"   ,0x376e); AddFixed("TZX"   ,0x274e);
   AddFixed("TZY"   ,0x275e); AddFixed("WAI"   ,0x27f3);
   AddFixed("XGAB"  ,0x371a); AddFixed("XGDE"  ,0x277a);
   AddFixed("XGDX"  ,0x37cc); AddFixed("XGDY"  ,0x37dc);
   AddFixed("XGDZ"  ,0x37ec); AddFixed("XGEX"  ,0x374c);
   AddFixed("XGEY"  ,0x375c); AddFixed("XGEZ"  ,0x376c);
   AddFixed("DES"   ,0x3fff); AddFixed("INS"   ,0x3f01);
   AddFixed("DEX"   ,0x3cff); AddFixed("INX"   ,0x3c01);
   AddFixed("DEY"   ,0x3dff); AddFixed("INY"   ,0x3d01);
   AddFixed("PSHX"  ,0x3404); AddFixed("PULX"  ,0x3510);
   AddFixed("PSHY"  ,0x3408); AddFixed("PULY"  ,0x3508);

   RelOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*RelOrderCnt); InstrZ=0;
   AddRel("BCC", 4); AddRel("BCS", 5); AddRel("BEQ", 7);
   AddRel("BGE",12); AddRel("BGT",14); AddRel("BHI", 2);
   AddRel("BLE",15); AddRel("BLS", 3); AddRel("BLT",13);
   AddRel("BMI",11); AddRel("BNE", 6); AddRel("BPL",10);
   AddRel("BRA", 0); AddRel("BRN", 1); AddRel("BVC", 8);
   AddRel("BVS", 9); AddRel("BHS", 4); AddRel("BLO", 5);

   LRelOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*LRelOrderCnt); InstrZ=0;
   AddLRel("LBEV",0x3791); AddLRel("LBMV",0x3790); AddLRel("LBSR",0x27f9);

   GenOrders=(GenOrder *) malloc(sizeof(GenOrder)*GenOrderCnt); InstrZ=0;
   AddGen("ADCA",0,0x43,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ADCB",0,0xc3,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ADCD",1,0x83,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ADCE",1,0x03,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("ADDA",0,0x41,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ADDB",0,0xc1,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ADDD",1,0x81,  0xfc,0x20,MModDisp8+MModImm+MModImmExt+MModDisp16+MModAbs+MModDispE);
   AddGen("ADDE",1,0x01,  0x7c,0x20,          MModImm+MModImmExt+MModDisp16+MModAbs          );
   AddGen("ANDA",0,0x46,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ANDB",0,0xc6,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ANDD",1,0x86,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ANDE",1,0x06,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("ASL" ,0,0x04,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("ASLW",0,0x04,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("LSL" ,0,0x04,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("LSLW",0,0x04,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("ASR" ,0,0x0d,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("ASRW",0,0x0d,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("BITA",0,0x49,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("BITB",0,0xc9,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("CLR" ,0,0x05,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("CLRW",0,0x05,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("CMPA",0,0x48,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("CMPB",0,0xc8,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("COM" ,0,0x00,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("COMW",0,0x00,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("CPD" ,1,0x88,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("CPE" ,1,0x08,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("DEC" ,0,0x01,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("DECW",0,0x01,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("EORA",0,0x44,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("EORB",0,0xc4,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("EORD",1,0x84,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("EORE",1,0x04,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("INC" ,0,0x03,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("INCW",0,0x03,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("LDAA",0,0x45,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("LDAB",0,0xc5,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("LDD" ,1,0x85,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("LDE" ,1,0x05,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("LSR" ,0,0x0f,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("LSRW",0,0x0f,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("NEG" ,0,0x02,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("NEGW",0,0x02,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("ORAA",0,0x47,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ORAB",0,0xc7,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ORD" ,1,0x87,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("ORE" ,1,0x07,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("ROL" ,0,0x0c,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("ROLW",0,0x0c,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("ROR" ,0,0x0e,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("RORW",0,0x0e,0xffff,0x10,                             MModDisp16+MModAbs          );
   AddGen("SBCA",0,0x42,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("SBCB",0,0xc2,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("SBCD",1,0x82,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("SBCE",1,0x02,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("STAA",0,0x4a,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs+MModDispE);
   AddGen("STAB",0,0xca,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs+MModDispE);
   AddGen("STD" ,1,0x8a,0xffff,0x20,MModDisp8+                   MModDisp16+MModAbs+MModDispE);
   AddGen("STE" ,1,0x0a,0xffff,0x20,                             MModDisp16+MModAbs          );
   AddGen("SUBA",0,0x40,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("SUBB",0,0xc0,0xffff,0x00,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("SUBD",1,0x80,0xffff,0x20,MModDisp8+MModImm+           MModDisp16+MModAbs+MModDispE);
   AddGen("SUBE",1,0x00,0xffff,0x20,          MModImm+           MModDisp16+MModAbs          );
   AddGen("TST" ,0,0x06,0xffff,0x00,MModDisp8+                   MModDisp16+MModAbs          );
   AddGen("TSTW",0,0x06,0xffff,0x10,                             MModDisp16+MModAbs          );

   AuxOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*AuxOrderCnt); InstrZ=0;
   AddAux("CPS",0x4f); AddAux("CPX",0x4c); AddAux("CPY",0x4d); AddAux("CPZ",0x4e);
   AddAux("LDS",0xcf); AddAux("LDX",0xcc); AddAux("LDY",0xcd); AddAux("LDZ",0xce);
   AddAux("STS",0x8f); AddAux("STX",0x8c); AddAux("STY",0x8d); AddAux("STZ",0x8e);

   ImmOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*ImmOrderCnt); InstrZ=0;
   AddImm("AIS",0x3f); AddImm("AIX",0x3c); AddImm("AIY",0x3d); AddImm("AIZ",0x3e);

   ExtOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*ExtOrderCnt); InstrZ=0;
   AddExt("LDED",0x2771); AddExt("LDHI",0x27b0);AddExt("STED",0x2773);

   EmuOrders=(EmuOrder *) malloc(sizeof(EmuOrder)*EmuOrderCnt); InstrZ=0;
   AddEmu("CLC",0x373a,0xfeff); AddEmu("CLI",0x373a,0xff1f); AddEmu("CLV",0x373a,0xfdff);
   AddEmu("SEC",0x373b,0x0100); AddEmu("SEI",0x373b,0x00e0); AddEmu("SEV",0x373b,0x0200);

   Regs=(char **) malloc(sizeof(char *)*RegCnt);
   Regs[0]="D"; Regs[1]="E"; Regs[2]="X"; Regs[3]="Y";
   Regs[4]="Z"; Regs[5]="K"; Regs[6]="CCR";
END

	static void DeinitFields(void)
BEGIN
   free(FixedOrders);
   free(RelOrders);
   free(LRelOrders);
   free(GenOrders);
   free(AuxOrders);
   free(ImmOrders);
   free(ExtOrders);
   free(EmuOrders);
   free(Regs);
END

/*-------------------------------------------------------------------------*/

typedef enum {ShortDisp,LongDisp,NoDisp} DispType;

	static void ChkAdr(Byte Mask)
BEGIN
   if ((AdrMode!=ModNone) AND ((Mask AND (1 << AdrMode))==0))
    BEGIN
     WrError(1350);
     AdrMode=ModNone; AdrCnt=0;
    END
END

   	static void SplitSize(char *Asc, DispType *Erg)
BEGIN
   if (strlen(Asc)<1) *Erg=NoDisp;
   else if (*Asc=='>') *Erg=LongDisp;
   else if (*Asc=='<') *Erg=ShortDisp;
   else *Erg=NoDisp;
END

	static void DecodeAdr(int Start, int Stop, Boolean LongAdr, Byte Mask)
BEGIN
   Integer V16;
   LongInt V32;
   Boolean OK;
   String s;
   DispType Size;

   AdrMode=ModNone; AdrCnt=0;

   Stop-=Start-1;
   if (Stop<1)
    BEGIN
     WrError(1110); return;
    END

   /* immediate ? */

   if (*ArgStr[Start]=='#')
    BEGIN
     strmaxcpy(s,ArgStr[Start]+1,255); SplitSize(s,&Size);
     switch (OpSize)
      BEGIN
       case -1: WrError(1132); break;
       case 0:
        AdrVals[0]=EvalIntExpression(s,Int8,&OK);
        if (OK)
         BEGIN
          AdrCnt=1; AdrMode=ModImm;
         END
        break;
       case 1:
        V16=EvalIntExpression(s,(Size==ShortDisp)?SInt8:Int16,&OK);
        if ((Size==NoDisp) AND (V16>=-128) AND (V16<=127) AND ((Mask & MModImmExt)!=0))
         Size=ShortDisp;
        if (OK)
         if (Size==ShortDisp)
          BEGIN
           AdrVals[0]=Lo(V16);
           AdrCnt=1; AdrMode=ModImmExt;
          END
         else
          BEGIN
           AdrVals[0]=Hi(V16);
           AdrVals[1]=Lo(V16);
           AdrCnt=2; AdrMode=ModImm;
          END
        break;
       case 2:
        V32=EvalIntExpression(s,Int32,&OK);
        if (OK)
         BEGIN
          AdrVals[0]=(V32 >> 24) & 0xff;
          AdrVals[1]=(V32 >> 16) & 0xff;
          AdrVals[2]=(V32 >>  8) & 0xff;
          AdrVals[3]=V32 & 0xff;
          AdrCnt=4; AdrMode=ModImm;
         END
        break;
      END
     ChkAdr(Mask); return;
    END

   /* zusammengesetzt ? */

   if (Stop==2)
    BEGIN
     AdrPart=0xff;
     if (strcasecmp(ArgStr[Start+1],"X")==0) AdrPart=0x00;
     else if (strcasecmp(ArgStr[Start+1],"Y")==0) AdrPart=0x10;
     else if (strcasecmp(ArgStr[Start+1],"Z")==0) AdrPart=0x20;
     else WrXError(1445,ArgStr[Start+1]);
     if (AdrPart!=0xff)
      if (strcasecmp(ArgStr[Start],"E")==0) AdrMode=ModDispE;
      else
       BEGIN
        SplitSize(ArgStr[Start],&Size);
        if (Size==ShortDisp)
	 V32=EvalIntExpression(ArgStr[Start],UInt8,&OK);
        else if (LongAdr)
         V32=EvalIntExpression(ArgStr[Start],SInt20,&OK);
        else
         V32=EvalIntExpression(ArgStr[Start],SInt16,&OK);
        if (OK)
         BEGIN
          if (Size==NoDisp)
           if ((V32>=0) AND (V32<=255) AND ((Mask & MModDisp8)!=0)) Size=ShortDisp;
          if (Size==ShortDisp)
           BEGIN
            AdrVals[0]=V32 & 0xff;
	    AdrCnt=1; AdrMode=ModDisp8;
           END
          else if (LongAdr)
	   BEGIN
            AdrVals[0]=(V32 >> 16) & 0x0f;
            AdrVals[1]=(V32 >> 8) & 0xff;
            AdrVals[2]=V32 & 0xff;
            AdrCnt=3; AdrMode=ModDisp16;
           END
          else
           BEGIN
            AdrVals[0]=(V32 >> 8) & 0xff;
            AdrVals[1]=V32 & 0xff;
            AdrCnt=2; AdrMode=ModDisp16;
           END
         END
       END
     ChkAdr(Mask); return;
    END

   /* absolut ? */

   else
    BEGIN
     SplitSize(ArgStr[Start],&Size);
     V32=EvalIntExpression(ArgStr[Start],UInt20,&OK);
     if (OK)
      if (LongAdr)
       BEGIN
        AdrVals[0]=(V32 >> 16) & 0xff;
        AdrVals[1]=(V32 >> 8) & 0xff;
        AdrVals[2]=V32 & 0xff;
        AdrMode=ModAbs; AdrCnt=3;
       END
      else
       BEGIN
        if ((V32 >> 16)!=Reg_EK) WrError(110);
        AdrVals[0]=(V32 >> 8) & 0xff;
        AdrVals[1]=V32 & 0xff;
        AdrMode=ModAbs; AdrCnt=2;
       END
     ChkAdr(Mask); return;
    END
END

/*-------------------------------------------------------------------------*/

	static Boolean DecodePseudo(void)
BEGIN
#define ASSUME6816Count 1
   static ASSUMERec ASSUME6816s[ASSUME6816Count]=
	       {{"EK" , &Reg_EK , 0 , 0xff , 0x100}};

   if (Memo("ASSUME"))
    BEGIN
     CodeASSUME(ASSUME6816s,ASSUME6816Count);
     return True;
    END

   return False;
END

	static void MakeCode_6816(void)
BEGIN
   int z,z2;
   Boolean OK;
   Byte Mask;
   LongInt AdrLong;

   CodeLen=0; DontPrint=False; AdrCnt=0; 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
       BEGIN
        BAsmCode[0]=Hi(FixedOrders[z].Code); BAsmCode[1]=Lo(FixedOrders[z].Code);
        CodeLen=2;
       END
      return;
     END

   for (z=0; z<EmuOrderCnt; z++)
    if Memo(EmuOrders[z].Name)
     BEGIN
      if (ArgCnt!=0) WrError(1110);
      else
       BEGIN
        BAsmCode[0]=Hi(EmuOrders[z].Code1); BAsmCode[1]=Lo(EmuOrders[z].Code1);
        BAsmCode[2]=Hi(EmuOrders[z].Code2); BAsmCode[3]=Lo(EmuOrders[z].Code2);
        CodeLen=4;
       END
      return;
     END

   /* Datentransfer */

   for (z=0; z<AuxOrderCnt; z++)
    if (Memo(AuxOrders[z].Name))
     BEGIN
      if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
      else
       BEGIN
        OpSize=1;
        DecodeAdr(1,ArgCnt,False,(*OpPart=='S'?0:MModImm)+MModDisp8+MModDisp16+MModAbs);
        switch (AdrMode)
         BEGIN
          case ModDisp8:
           BAsmCode[0]=AuxOrders[z].Code+AdrPart;
           BAsmCode[1]=AdrVals[0]; CodeLen=2;
           break;
          case ModDisp16:
           BAsmCode[0]=0x17;
           BAsmCode[1]=AuxOrders[z].Code+AdrPart;
           memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           break;
          case ModAbs:
           BAsmCode[0]=0x17;
           BAsmCode[1]=AuxOrders[z].Code+0x30;
           memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           break;
          case ModImm:
           BAsmCode[0]=0x37; BAsmCode[1]=AuxOrders[z].Code+0x30;
           if (*OpPart=='L') BAsmCode[1]-=0x40;
           memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           break;
         END
       END
      return;
     END

   for (z=0; z<ExtOrderCnt; z++)
    if (Memo(ExtOrders[z].Name))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else
       BEGIN
        OpSize=1; DecodeAdr(1,1,False,MModAbs);
        switch (AdrMode)
         BEGIN
          case ModAbs:
           BAsmCode[0]=Hi(ExtOrders[z].Code); BAsmCode[1]=Lo(ExtOrders[z].Code);
           memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           break;
         END
       END
      return;
     END

   if ((Memo("PSHM")) OR (Memo("PULM")))
    BEGIN
     if (ArgCnt<1) WrError(1110);
     else
      BEGIN
       OK=True; Mask=0;
       for (z=1; z<=ArgCnt; z++)
        if (OK)
         BEGIN
          z2=0; NLS_UpString(ArgStr[z]);
	  while ((z2<RegCnt) AND (strcmp(ArgStr[z],Regs[z2])!=0)) z2++;
          if (z2>=RegCnt)
           BEGIN
            WrXError(1445,ArgStr[z]); OK=False;
           END
          else if (Memo("PSHM")) Mask+=(1 << z2);
          else Mask+=(1 << (RegCnt-1-z2));
         END
       if (OK)
        BEGIN
         BAsmCode[0]=0x34+Ord(Memo("PULM")); BAsmCode[1]=Mask;
         CodeLen=2;
        END
      END
     return;
    END

   if ((Memo("MOVB")) OR (Memo("MOVW")))
    BEGIN
     z=Ord(Memo("MOVW"));
     if (ArgCnt==2)
      BEGIN
       DecodeAdr(1,1,False,MModAbs);
       if (AdrMode==ModAbs)
        BEGIN
         memcpy(BAsmCode+2,AdrVals,2);
         DecodeAdr(2,2,False,MModAbs);
         if (AdrMode==ModAbs)
          BEGIN
           memcpy(BAsmCode+4,AdrVals,2);
           BAsmCode[0]=0x37; BAsmCode[1]=0xfe + z; /* ANSI :-0 */
           CodeLen=6;
          END
        END
      END
     else if (ArgCnt!=3) WrError(1110);
     else if (strcasecmp(ArgStr[2],"X")==0)
      BEGIN
       BAsmCode[1]=EvalIntExpression(ArgStr[1],SInt8,&OK);
       if (OK)
        BEGIN
         DecodeAdr(3,3,False,MModAbs);
         if (AdrMode==ModAbs)
          BEGIN
           memcpy(BAsmCode+2,AdrVals,2);
           BAsmCode[0]=0x30+z;
           CodeLen=4;
          END
        END
      END
     else if (strcasecmp(ArgStr[3],"X")==0)
      BEGIN
       BAsmCode[3]=EvalIntExpression(ArgStr[2],SInt8,&OK);
       if (OK)
        BEGIN
         DecodeAdr(1,1,False,MModAbs);
         if (AdrMode==ModAbs)
          BEGIN
           memcpy(BAsmCode+1,AdrVals,2);
           BAsmCode[0]=0x32+z;
           CodeLen=4;
          END
        END
      END
     else WrError(1350);
     return;
    END

   /* Arithmetik */

   for (z=0; z<GenOrderCnt; z++)
    if (Memo(GenOrders[z].Name))
     BEGIN
      if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
      else
       BEGIN
        OpSize=GenOrders[z].Size;
        DecodeAdr(1,ArgCnt,False,GenOrders[z].AdrMask);
        switch (AdrMode)
         BEGIN
          case ModDisp8:
           BAsmCode[0]=GenOrders[z].Code+AdrPart; 
           BAsmCode[1]=AdrVals[0]; CodeLen=2;
           break;
          case ModDisp16:
           BAsmCode[0]=0x17+GenOrders[z].ExtShift;
           BAsmCode[1]=GenOrders[z].Code+(OpSize << 6)+AdrPart;
           memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           break;
          case ModDispE:
           BAsmCode[0]=0x27; BAsmCode[1]=GenOrders[z].Code+AdrPart;
           CodeLen=2;
           break;
          case ModAbs:
           BAsmCode[0]=0x17+GenOrders[z].ExtShift;
           BAsmCode[1]=GenOrders[z].Code+(OpSize << 6)+0x30;
           memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           break;
          case ModImm:
           if (OpSize==0)
            BEGIN
             BAsmCode[0]=GenOrders[z].Code+0x30;
             BAsmCode[1]=AdrVals[0]; CodeLen=2;
            END
           else
            BEGIN
             BAsmCode[0]=0x37; BAsmCode[1]=GenOrders[z].Code+0x30;
             memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
            END
           break;
          case ModImmExt:
           BAsmCode[0]=GenOrders[z].ExtCode;
           BAsmCode[1]=AdrVals[0]; CodeLen=2;
           break;
         END
       END
      return;
     END

   for (z=0; z<ImmOrderCnt; z++)
    if (Memo(ImmOrders[z].Name))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else
       BEGIN
        OpSize=1; DecodeAdr(1,1,False,MModImm+MModImmExt);
        switch (AdrMode)
         BEGIN
          case ModImm:
           BAsmCode[0]=0x37; BAsmCode[1]=ImmOrders[z].Code;
           memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           break;
          case ModImmExt:
           BAsmCode[0]=ImmOrders[z].Code; BAsmCode[1]=AdrVals[0]; CodeLen=2;
           break;
         END
       END
      return;
     END

   if ((Memo("ANDP")) OR (Memo("ORP")))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       OpSize=1; DecodeAdr(1,1,False,MModImm);
       switch (AdrMode)
        BEGIN
         case ModImm:
          BAsmCode[0]=0x37; BAsmCode[1]=0x3a+Ord(Memo("ORP"));
          memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
          break;
        END
      END
     return;
    END

   if ((Memo("MAC")) OR (Memo("RMAC")))
    BEGIN
     if (ArgCnt!=2) WrError(1110);
     else
      BEGIN
       z=EvalIntExpression(ArgStr[1],UInt4,&OK);
       if (OK)
        BEGIN
         BAsmCode[1]=EvalIntExpression(ArgStr[2],UInt4,&OK);
         if (OK)
          BEGIN
           BAsmCode[1]+=(z << 4);
           BAsmCode[0]=0x7b+(Ord(Memo("RMAC")) << 7);
           CodeLen=2;
          END
        END
      END
     return;
    END

   /* Bitoperationen */

   if ((Memo("BCLR")) OR (Memo("BSET")))
    BEGIN
     if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
     else
      BEGIN
       OpSize=0; z=Ord(Memo("BSET"));
       DecodeAdr(ArgCnt,ArgCnt,False,MModImm);
       switch (AdrMode)
        BEGIN
         case ModImm:
          Mask=AdrVals[0];
          DecodeAdr(1,ArgCnt-1,False,MModDisp8+MModDisp16+MModAbs);
          switch (AdrMode)
           BEGIN
            case ModDisp8:
             BAsmCode[0]=0x17; BAsmCode[1]=0x08+z+AdrPart;
             BAsmCode[2]=Mask; BAsmCode[3]=AdrVals[0];
             CodeLen=4;
             break;
            case ModDisp16:
             BAsmCode[0]=0x08+z+AdrPart; BAsmCode[1]=Mask;
	     memcpy(BAsmCode+2,AdrVals,AdrCnt);
             CodeLen=2+AdrCnt;
             break;
            case ModAbs:
             BAsmCode[0]=0x38+z; BAsmCode[1]=Mask;
	     memcpy(BAsmCode+2,AdrVals,AdrCnt);
             CodeLen=2+AdrCnt;
             break;
           END
          break;
        END
      END
     return;
    END

   if ((Memo("BCLRW")) OR (Memo("BSETW")))
    BEGIN
     if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
     else
      BEGIN
       OpSize=1; z=Ord(Memo("BSETW"));
       DecodeAdr(ArgCnt,ArgCnt,False,MModImm);
       switch (AdrMode)
        BEGIN
         case ModImm:
          memcpy(BAsmCode+2,AdrVals,AdrCnt);
          DecodeAdr(1,ArgCnt-1,False,MModDisp16+MModAbs);
          switch (AdrMode)
           BEGIN
            case ModDisp16:
             BAsmCode[0]=0x27; BAsmCode[1]=0x08+z+AdrPart;
  	     memcpy(BAsmCode+4,AdrVals,AdrCnt);
             CodeLen=4+AdrCnt;
             break;
            case ModAbs:
             BAsmCode[0]=0x27; BAsmCode[1]=0x38+z;
  	     memcpy(BAsmCode+4,AdrVals,AdrCnt);
             CodeLen=4+AdrCnt;
             break;
           END
        END
      END
     return;
    END

   if ((Memo("BRCLR")) OR (Memo("BRSET")))
    BEGIN
     if ((ArgCnt<3) OR (ArgCnt>4)) WrError(1110);
     else
      BEGIN
       z=Ord(Memo("BRSET"));
       OpSize=0; DecodeAdr(ArgCnt-1,ArgCnt-1,False,MModImm);
       if (AdrMode==ModImm)
        BEGIN
         BAsmCode[1]=AdrVals[0];
         AdrLong=EvalIntExpression(ArgStr[ArgCnt],UInt20,&OK)-EProgCounter()-6;
         if (OK)
          BEGIN
           OK=SymbolQuestionable;
           DecodeAdr(1,ArgCnt-2,False,MModDisp8+MModDisp16+MModAbs);
           switch (AdrMode)
            BEGIN
             case ModDisp8:
              if ((AdrLong>=-128) AND (AdrLong<127))
               BEGIN
                BAsmCode[0]=0xcb-(z << 6)+AdrPart;
                BAsmCode[2]=AdrVals[0];
                BAsmCode[3]=AdrLong & 0xff;
                CodeLen=4;
               END
              else if ((NOT OK) AND ((AdrLong<-0x8000l) OR (AdrLong>0x7fffl))) WrError(1370);
              else
               BEGIN
                BAsmCode[0]=0x0a+AdrPart+z;
                BAsmCode[2]=0;
                BAsmCode[3]=AdrVals[0];
                BAsmCode[4]=(AdrLong >> 8) & 0xff;
	        BAsmCode[5]=AdrLong & 0xff;
	        CodeLen=6;
               END
              break;
             case ModDisp16:
              if ((NOT OK) AND ((AdrLong<-0x8000l) OR (AdrLong>0x7fffl))) WrError(1370);
              else
               BEGIN
                BAsmCode[0]=0x0a+AdrPart+z;
                memcpy(BAsmCode+2,AdrVals,2);
                BAsmCode[4]=(AdrLong >> 8) & 0xff;
	        BAsmCode[5]=AdrLong & 0xff;
	        CodeLen=6;
               END
              break;
             case ModAbs:
              if ((NOT OK) AND ((AdrLong<-0x8000l) OR (AdrLong>0x7fffl))) WrError(1370);
              else
               BEGIN
                BAsmCode[0]=0x3a+z;
                memcpy(BAsmCode+2,AdrVals,2);
                BAsmCode[4]=(AdrLong >> 8) & 0xff;
	        BAsmCode[5]=AdrLong & 0xff;
	        CodeLen=6;
               END
              break;
            END
          END
        END
      END
     return;
    END

   /* Spruenge */

   if ((Memo("JMP")) OR (Memo("JSR")))
    BEGIN
     if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
     else
      BEGIN
       OpSize=1;
       DecodeAdr(1,ArgCnt,True,MModAbs20+MModDisp20);
       switch (AdrMode)
        BEGIN
         case ModAbs20:
          BAsmCode[0]=0x7a+(Ord(Memo("JSR")) << 7);
          memcpy(BAsmCode+1,AdrVals,AdrCnt);
          CodeLen=1+AdrCnt;
          break;
         case ModDisp20:
          BAsmCode[0]=(Memo("JMP"))?0x4b:0x89;
	  BAsmCode[0]+=AdrPart;
          memcpy(BAsmCode+1,AdrVals,AdrCnt);
          CodeLen=1+AdrCnt;
          break;
        END
      END
     return;
    END

   for (z=0; z<RelOrderCnt; z++)
    if ((Memo(RelOrders[z].Name)) OR ((*OpPart=='L') AND (strcmp(OpPart+1,RelOrders[z].Name)==0)))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else
       BEGIN
        AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK)-EProgCounter()-6;
        if ((AdrLong&1)==1) WrError(1325);
        else if (*OpPart=='L')
         if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fffl) OR (AdrLong<-0x8000l))) WrError(1370);
         else
          BEGIN
           BAsmCode[0]=0x37; BAsmCode[1]=RelOrders[z].Code+0x80;
           BAsmCode[2]=(AdrLong >> 8) & 0xff;
           BAsmCode[3]=AdrLong & 0xff;
           CodeLen=4;
          END
        else
         if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fl) OR (AdrLong<-0x80l))) WrError(1370);
         else
          BEGIN
           BAsmCode[0]=0xb0+RelOrders[z].Code;
           BAsmCode[1]=AdrLong & 0xff;
           CodeLen=2;
          END
       END
      return;
     END

   for (z=0; z<LRelOrderCnt; z++)
    if (Memo(LRelOrders[z].Name))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else
       BEGIN
        AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK)-EProgCounter()-6;
        if ((AdrLong&1)==1) WrError(1325);
        else if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fffl) OR (AdrLong<-0x8000l))) WrError(1370);
        else
         BEGIN
          BAsmCode[0]=Hi(LRelOrders[z].Code); BAsmCode[1]=Lo(LRelOrders[z].Code);
          BAsmCode[2]=(AdrLong >> 8) & 0xff;
          BAsmCode[3]=AdrLong & 0xff;
          CodeLen=4;
         END
       END
      return;
     END

   if (Memo("BSR"))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK)-EProgCounter()-6;
       if ((AdrLong&1)==1) WrError(1325);
       else if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fl) OR (AdrLong<-0x80l))) WrError(1370);
       else
        BEGIN
         BAsmCode[0]=0x36;
         BAsmCode[1]=AdrLong & 0xff;
         CodeLen=2;
        END
      END
     return;
    END

   WrXError(1200,OpPart);
END

	static void InitCode_6816(void)
BEGIN
   SaveInitProc();
   Reg_EK=0;
END

	static Boolean IsDef_6816(void)
BEGIN
   return False;
END

        static void SwitchFrom_6816(void)
BEGIN
   DeinitFields();
END

	static void SwitchTo_6816(void)
BEGIN
   TurnWords=False; ConstMode=ConstModeMoto; SetIsOccupied=False;

   PCSymbol="*"; HeaderID=0x65; NOPCode=0x274c;
   DivideChars=","; HasAttrs=False;

   ValidSegs=(1<<SegCode);
   Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0;
   SegLimits[SegCode] = 0xfffffl;

   MakeCode=MakeCode_6816; IsDef=IsDef_6816;
   SwitchFrom=SwitchFrom_6816;

   InitFields();
END

	void code6816_init(void)
BEGIN
   CPU6816=AddCPU("68HC16",SwitchTo_6816);

   SaveInitProc=InitPassProc; InitPassProc=InitCode_6816;
END