/* code7700.c */
/*****************************************************************************/
/* AS-Portierung                                                             */
/*                                                                           */
/* AS-Codegeneratormodul MELPS-7700                                          */
/*                                                                           */
/* Historie: 5.11.1996 Grundsteinlegung                                      */
/*           2. 1.1999 ChkPC-Anpassung                                       */
/*                                                                           */
/*****************************************************************************/

#include "stdinc.h"
#include <string.h>

#include "bpemu.h"
#include "strutil.h"
#include "asmdef.h"
#include "asmsub.h"
#include "asmpars.h"
#include "codepseudo.h"
#include "codevars.h"

#include "code7700.h"

typedef struct
         {
          char *Name;
          Word Code;
          Byte Allowed;
         } FixedOrder;

typedef struct
         {
          char *Name;
          Word Code;
          ShortInt Disp8,Disp16;
         } RelOrder;

typedef struct
         {   
          char *Name;
          Byte Code;
         } AccOrder;

typedef struct
         {
          char *Name;
          Byte ACode,MCode;
         } RMWOrder;

typedef struct
         {
          char *Name;
          Byte CodeImm,CodeAbs8,CodeAbs16,CodeIdxX8,CodeIdxX16,
               CodeIdxY8,CodeIdxY16;
         } XYOrder;

typedef struct
         {
          char *Name;
          Word Code;
          Byte Allowed;
         } MulDivOrder;

#define ModNone    (-1)
#define ModImm      0
#define MModImm      (1l << ModImm)
#define ModAbs8     1
#define MModAbs8     (1l << ModAbs8)
#define ModAbs16    2
#define MModAbs16    (1l << ModAbs16)
#define ModAbs24    3
#define MModAbs24    (1l << ModAbs24)
#define ModIdxX8    4
#define MModIdxX8    (1l << ModIdxX8)
#define ModIdxX16   5
#define MModIdxX16   (1l << ModIdxX16)
#define ModIdxX24   6
#define MModIdxX24   (1l << ModIdxX24)
#define ModIdxY8    7
#define MModIdxY8    (1l << ModIdxY8)
#define ModIdxY16   8
#define MModIdxY16   (1l << ModIdxY16)
#define ModIdxY24   9
#define MModIdxY24   (1l << ModIdxY24)
#define ModInd8    10
#define MModInd8     (1l << ModInd8)
#define ModInd16   11
#define MModInd16    (1l << ModInd16)
#define ModInd24   12
#define MModInd24    (1l << ModInd24)
#define ModIndX8   13
#define MModIndX8    (1l << ModIndX8)
#define ModIndX16  14
#define MModIndX16   (1l << ModIndX16)
#define ModIndX24  15
#define MModIndX24   (1l << ModIndX24)
#define ModIndY8   16
#define MModIndY8    (1l << ModIndY8)
#define ModIndY16  17
#define MModIndY16   (1l << ModIndY16)
#define ModIndY24  18
#define MModIndY24   (1l << ModIndY24)
#define ModIdxS8   19
#define MModIdxS8    (1l << ModIdxS8)
#define ModIndS8   20
#define MModIndS8    (1l << ModIndS8)

#define FixedOrderCnt 64

#define RelOrderCnt 13

#define AccOrderCnt 9

#define RMWOrderCnt 6

#define Imm8OrderCnt 5

#define XYOrderCnt 6

#define MulDivOrderCnt 4

#define PushRegCnt 8
static char *PushRegs[PushRegCnt]={"A","B","X","Y","DPR","DT","PG","PS"};

#define PrefAccB 0x42

static LongInt Reg_PG,Reg_DT,Reg_X,Reg_M,Reg_DPR,BankReg;

static Boolean WordSize;
static Byte AdrVals[3];
static ShortInt AdrType;
static Boolean LFlag;

static FixedOrder *FixedOrders;
static RelOrder *RelOrders;
static AccOrder *AccOrders;
static RMWOrder *RMWOrders;
static FixedOrder *Imm8Orders;
static XYOrder *XYOrders;
static MulDivOrder *MulDivOrders;

static SimpProc SaveInitProc;

static CPUVar CPU65816,CPUM7700,CPUM7750,CPUM7751;

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

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

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

        static void AddAcc(char *NName, Byte NCode)
BEGIN
   if (InstrZ>=AccOrderCnt) exit(255);
   AccOrders[InstrZ].Name=NName;
   AccOrders[InstrZ++].Code=NCode;
END

        static void AddRMW(char *NName, Byte NACode, Byte NMCode)
BEGIN
   if (InstrZ>=RMWOrderCnt) exit(255);
   RMWOrders[InstrZ].Name=NName;
   RMWOrders[InstrZ].MCode=NMCode;
   RMWOrders[InstrZ++].ACode=NACode;
END

        static void AddImm8(char *NName, Word NCode, Byte NAllowed)
BEGIN
   if (InstrZ>=Imm8OrderCnt) exit(255);
   Imm8Orders[InstrZ].Name=NName;
   Imm8Orders[InstrZ].Code=NCode;
   Imm8Orders[InstrZ++].Allowed=NAllowed;
END

        static void AddXY(char *NName, Byte NCodeImm, Byte NCodeAbs8, Byte NCodeAbs16,
                          Byte NCodeIdxX8, Byte NCodeIdxX16, Byte NCodeIdxY8,
                          Byte NCodeIdxY16)
BEGIN
   if (InstrZ>=XYOrderCnt) exit(255);
   XYOrders[InstrZ].Name=NName;
   XYOrders[InstrZ].CodeImm=NCodeImm;
   XYOrders[InstrZ].CodeAbs8=NCodeAbs8;
   XYOrders[InstrZ].CodeAbs16=NCodeAbs16;
   XYOrders[InstrZ].CodeIdxX8=NCodeIdxX8;
   XYOrders[InstrZ].CodeIdxX16=NCodeIdxX16;
   XYOrders[InstrZ].CodeIdxY8=NCodeIdxY8;
   XYOrders[InstrZ++].CodeIdxY16=NCodeIdxY16;
END

        static void AddMulDiv(char *NName, Word NCode, Byte NAllowed)
BEGIN
   if (InstrZ>=MulDivOrderCnt) exit(255);
   MulDivOrders[InstrZ].Name=NName;
   MulDivOrders[InstrZ].Code=NCode;
   MulDivOrders[InstrZ++].Allowed=NAllowed;
END

        static void InitFields(void)
BEGIN
   FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0;
   AddFixed("CLC",0x0018,15); AddFixed("CLI",0x0058,15);
   AddFixed("CLM",0x00d8,14); AddFixed("CLV",0x00b8,15);
   AddFixed("DEX",0x00ca,15); AddFixed("DEY",0x0088,15);
   AddFixed("INX",0x00e8,15); AddFixed("INY",0x00c8,15);
   AddFixed("NOP",0x00ea,15); AddFixed("PHA",0x0048,15);
   AddFixed("PHD",0x000b,15); AddFixed("PHG",0x004b,14);
   AddFixed("PHP",0x0008,15); AddFixed("PHT",0x008b,14);
   AddFixed("PHX",0x00da,15); AddFixed("PHY",0x005a,15);
   AddFixed("PLA",0x0068,15); AddFixed("PLD",0x002b,15);
   AddFixed("PLP",0x0028,15); AddFixed("PLT",0x00ab,14);
   AddFixed("PLX",0x00fa,15); AddFixed("PLY",0x007a,15);
   AddFixed("RTI",0x0040,15); AddFixed("RTL",0x006b,15);
   AddFixed("RTS",0x0060,15); AddFixed("SEC",0x0038,15);
   AddFixed("SEI",0x0078,15); AddFixed("SEM",0x00f8,14);
   AddFixed("STP",0x00db,15); AddFixed("TAD",0x005b,15);
   AddFixed("TAS",0x001b,15); AddFixed("TAX",0x00aa,15);
   AddFixed("TAY",0x00a8,15); AddFixed("TBD",0x425b,14);
   AddFixed("TBS",0x421b,14); AddFixed("TBX",0x42aa,14);
   AddFixed("TBY",0x42a8,14); AddFixed("TDA",0x007b,15);
   AddFixed("TDB",0x427b,14); AddFixed("TSA",0x003b,15);
   AddFixed("TSX",0x00ba,15); AddFixed("TXA",0x008a,15);
   AddFixed("TXB",0x428a,14); AddFixed("TXS",0x009a,15);
   AddFixed("TXY",0x009b,15); AddFixed("TYA",0x0098,15);
   AddFixed("TYB",0x4298,15); AddFixed("TYX",0x00bb,15);
   AddFixed("WIT",0x00cb,14); AddFixed("XAB",0x8928,14);
   AddFixed("COP",0x0002, 1); AddFixed("CLD",0x00d8, 1);
   AddFixed("SED",0x00f8, 1); AddFixed("TCS",0x001b,15);
   AddFixed("TSC",0x003b,15); AddFixed("TCD",0x005b,15);
   AddFixed("TDC",0x007b,15); AddFixed("PHK",0x004b, 1);
   AddFixed("WAI",0x00cb, 1); AddFixed("XBA",0x00eb, 1);
   AddFixed("SWA",0x00eb, 1); AddFixed("XCE",0x00fb, 1);
   AddFixed("DEA",(MomCPU>=CPUM7700) ? 0x001a : 0x003a,15);
   AddFixed("INA",(MomCPU>=CPUM7700) ? 0x003a : 0x001a,15);

   RelOrders=(RelOrder *) malloc(sizeof(RelOrder)*RelOrderCnt); InstrZ=0;
   AddRel("BCC" ,0x0090, 2,-1);
   AddRel("BLT" ,0x0090, 2,-1);
   AddRel("BCS" ,0x00b0, 2,-1);
   AddRel("BGE" ,0x00b0, 2,-1);
   AddRel("BEQ" ,0x00f0, 2,-1);
   AddRel("BMI" ,0x0030, 2,-1);
   AddRel("BNE" ,0x00d0, 2,-1);
   AddRel("BPL" ,0x0010, 2,-1);
   AddRel("BRA" ,0x8280, 2, 3);
   AddRel("BVC" ,0x0050, 2,-1);
   AddRel("BVS" ,0x0070, 2,-1);
   AddRel("BRL" ,0x8200,-1, 3);
   AddRel("BRAL",0x8200,-1, 3);

   AccOrders=(AccOrder *) malloc(sizeof(AccOrder)*AccOrderCnt); InstrZ=0;
   AddAcc("ADC",0x60);
   AddAcc("AND",0x20);
   AddAcc("CMP",0xc0);
   AddAcc("CPA",0xc0);
   AddAcc("EOR",0x40);
   AddAcc("LDA",0xa0);
   AddAcc("ORA",0x00);
   AddAcc("SBC",0xe0);
   AddAcc("STA",0x80);

   RMWOrders=(RMWOrder *) malloc(sizeof(RMWOrder)*RMWOrderCnt); InstrZ=0;
   AddRMW("ASL",0x0a,0x06);
   AddRMW("DEC",(MomCPU>=CPUM7700)?0x1a:0x3a,0xc6);
   AddRMW("ROL",0x2a,0x26);
   AddRMW("INC",(MomCPU>=CPUM7700)?0x3a:0x1a,0xe6);
   AddRMW("LSR",0x4a,0x46);
   AddRMW("ROR",0x6a,0x66);

   Imm8Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*Imm8OrderCnt); InstrZ=0;
   AddImm8("CLP",0x00c2,15);
   AddImm8("REP",0x00c2,15);
   AddImm8("LDT",0x89c2,14);
   AddImm8("SEP",0x00e2,15);
   AddImm8("RMPA",0x89e2,8);

   XYOrders=(XYOrder *) malloc(sizeof(XYOrder)*XYOrderCnt); InstrZ=0;
   AddXY("CPX",0xe0,0xe4,0xec,0xff,0xff,0xff,0xff);
   AddXY("CPY",0xc0,0xc4,0xcc,0xff,0xff,0xff,0xff);
   AddXY("LDX",0xa2,0xa6,0xae,0xff,0xff,0xb6,0xbe);
   AddXY("LDY",0xa0,0xa4,0xac,0xb4,0xbc,0xff,0xff);
   AddXY("STX",0xff,0x86,0x8e,0xff,0xff,0x96,0xff);
   AddXY("STY",0xff,0x84,0x8c,0x94,0xff,0xff,0xff);

   MulDivOrders=(MulDivOrder *) malloc(sizeof(MulDivOrder)*MulDivOrderCnt); InstrZ=0;
   AddMulDiv("MPY",0x0000,14); AddMulDiv("MPYS",0x0080,12);
   AddMulDiv("DIV",0x0020,14); AddMulDiv("DIVS",0x00a0,12); /*???*/
END

        static void DeinitFields(void)
BEGIN
   free(FixedOrders);
   free(RelOrders);
   free(AccOrders);
   free(RMWOrders);
   free(Imm8Orders);
   free(XYOrders);
   free(MulDivOrders);
END

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

	static void ChkAdr(LongWord Mask)
BEGIN
   if (AdrType!=ModNone)
    if ((Mask & (1l << ((LongWord)AdrType)))==0)
     BEGIN
      AdrType=ModNone; AdrCnt=0; WrError(1350);
     END
END


	static void CodeDisp(char *Asc, LongInt Start, LongWord Mask)
BEGIN
   Boolean OK;
   LongInt Adr;
   ShortInt DType;
   int l=strlen(Asc);

   if ((l>1) AND (*Asc=='<'))
    BEGIN
     Asc++; DType=0;
    END
   else if ((l>1) AND (*Asc=='>'))
    if ((l>2) AND (Asc[1]=='>'))
     BEGIN
      Asc+=2; DType=2;
     END
    else
     BEGIN
      Asc++; DType=1;
     END
   else DType=(-1);

   Adr=EvalIntExpression(Asc,UInt24,&OK);

   if (NOT OK) return;

   if (DType==-1)
    BEGIN
     if ((((Mask & (1l << Start)))!=0) AND (Adr>=Reg_DPR) AND (Adr<Reg_DPR+0x100)) DType=0;
     else if ((((Mask & (2l << Start)))!=0) AND ((Adr >> 16)==BankReg)) DType=1;
     else DType=2;
    END

   if ((Mask & (1l << (Start+DType)))==0) WrError(1350);
   else switch (DType)
    BEGIN
     case 0:
      if ((FirstPassUnknown) OR (ChkRange(Adr,Reg_DPR,Reg_DPR+0xff)))
       BEGIN
        AdrCnt=1; AdrType=Start;
        AdrVals[0]=Lo(Adr-Reg_DPR);
       END;
      break;
     case 1:
      if ((NOT FirstPassUnknown) AND ((Adr >> 16)!=BankReg)) WrError(1320);
      else
       BEGIN
        AdrCnt=2; AdrType=Start+1;
        AdrVals[0]=Lo(Adr); AdrVals[1]=Hi(Adr);
       END
      break;
     case 2:
      AdrCnt=3; AdrType=Start+2;
      AdrVals[0]=Lo(Adr); AdrVals[1]=Hi(Adr); AdrVals[2]=Adr >> 16;
      break;
    END
END

	static void SplitArg(char *Src, String *HStr, Integer *HCnt)
BEGIN
   char *p;

   strcpy(Src,Src+1); Src[strlen(Src)-1]='\0';
   p=QuotPos(Src,',');
   if (p==Nil)
    BEGIN
     strmaxcpy(HStr[0],Src,255); *HCnt=1;
    END
   else
    BEGIN
     *p='\0';
     strmaxcpy(HStr[0],Src,255);
     strmaxcpy(HStr[1],p+1,255);
     *p=',';
     *HCnt=2;
    END
END

	static void DecodeAdr(Integer Start, LongWord Mask)
BEGIN
   Word AdrWord;
   Boolean OK;
   Integer HCnt;
   String HStr[2];

   AdrType=ModNone; AdrCnt=0; BankReg=Reg_DT;

   /* I. 1 Parameter */

   if (Start==ArgCnt)
    BEGIN
     /* I.1. immediate */

     if (*ArgStr[Start]=='#')
      BEGIN
       if (WordSize)
	BEGIN
	 AdrWord=EvalIntExpression(ArgStr[Start]+1,Int16,&OK);
	 AdrVals[0]=Lo(AdrWord); AdrVals[1]=Hi(AdrWord);
	END
       else AdrVals[0]=EvalIntExpression(ArgStr[Start]+1,Int8,&OK);
       if (OK)
	BEGIN
	 AdrCnt=1+Ord(WordSize); AdrType=ModImm;
	END
       ChkAdr(Mask); return;
      END

     /* I.2. indirekt */

     if (IsIndirect(ArgStr[Start]))
      BEGIN
       SplitArg(ArgStr[Start],HStr,&HCnt);

       /* I.2.i. einfach indirekt */

       if (HCnt==1)
	BEGIN
	 CodeDisp(HStr[0],ModInd8,Mask); ChkAdr(Mask); return;
	END

       /* I.2.ii indirekt mit Vorindizierung */

       else if (strcasecmp(HStr[1],"X")==0)
	BEGIN
	 CodeDisp(HStr[0],ModIndX8,Mask); ChkAdr(Mask); return;
	END

       else
	BEGIN
	 WrError(1350); ChkAdr(Mask); return;
	END
      END

     /* I.3. absolut */

     else
      BEGIN
       CodeDisp(ArgStr[Start],ModAbs8,Mask); ChkAdr(Mask); return;
      END
    END

   /* II. 2 Parameter */

   else if (Start+1==ArgCnt)
    BEGIN
     /* II.1 indirekt mit Nachindizierung */

     if (IsIndirect(ArgStr[Start]))
      BEGIN
       if (strcasecmp(ArgStr[Start+1],"Y")!=0) WrError(1350);
       else
	BEGIN
	 SplitArg(ArgStr[Start],HStr,&HCnt);

	 /* II.1.i. (d),Y */

	 if (HCnt==1)
	  BEGIN
	   CodeDisp(HStr[0],ModIndY8,Mask); ChkAdr(Mask); return;
	  END

	 /* II.1.ii. (d,S),Y */

	 else if (strcasecmp(HStr[1],"S")==0)
	  BEGIN
	   AdrVals[0]=EvalIntExpression(HStr[0],Int8,&OK);
	   if (OK)
	    BEGIN
	     AdrType=ModIndS8; AdrCnt=1;
	    END
	   ChkAdr(Mask); return;
	  END

	 else WrError(1350);
	END
       ChkAdr(Mask); return;
      END

     /* II.2. einfach indiziert */

     else
      BEGIN
       /* II.2.i. d,X */

       if (strcasecmp(ArgStr[Start+1],"X")==0)
	BEGIN
	 CodeDisp(ArgStr[Start],ModIdxX8,Mask); ChkAdr(Mask); return;
	END

       /* II.2.ii. d,Y */

       else if (strcasecmp(ArgStr[Start+1],"Y")==0)
	BEGIN
	 CodeDisp(ArgStr[Start],ModIdxY8,Mask); ChkAdr(Mask); return;
	END

       /* II.2.iii. d,S */

       else if (strcasecmp(ArgStr[Start+1],"S")==0)
	BEGIN
	 AdrVals[0]=EvalIntExpression(ArgStr[Start],Int8,&OK);
	 if (OK)
	  BEGIN
	   AdrType=ModIdxS8; AdrCnt=1;
	  END
	 ChkAdr(Mask); return;
	END

       else WrError(1350);
      END
    END

   else WrError(1110);
END

	static Boolean DecodePseudo(void)
BEGIN
#define ASSUME7700Count 5
static ASSUMERec ASSUME7700s[ASSUME7700Count]=
	       {{"PG" , &Reg_PG , 0,  0xff,  0x100},
		{"DT" , &Reg_DT , 0,  0xff,  0x100},
		{"X"  , &Reg_X  , 0,     1,     -1},
		{"M"  , &Reg_M  , 0,     1,     -1},
		{"DPR", &Reg_DPR, 0,0xffff,0x10000}};

   if (Memo("ASSUME"))
    BEGIN
     CodeASSUME(ASSUME7700s,ASSUME7700Count);
     return True;
    END

   return False;
END

	static Boolean LMemo(char *s)
BEGIN
   String tmp;

   if (Memo(s)) 
    BEGIN
     LFlag=False; return True;
    END
   else
    BEGIN
     strmaxcpy(tmp,s,255); strmaxcat(tmp,"L",255);
     if (Memo(tmp))
      BEGIN
       LFlag=True; return True;
      END
     else return False;
    END
END

	static void MakeCode_7700(void)
BEGIN
   int z;
   Integer Start;
   LongInt AdrLong,Mask;
   Boolean OK,Rel;

   CodeLen=0; DontPrint=False;

   /* zu ignorierendes */

   if (Memo("")) return;

   /* Pseudoanweisungen */

   if (DecodePseudo()) return;

   if (DecodeMotoPseudo(False)) return;
   if (DecodeIntelPseudo(False)) return;

   /* ohne Argument */

   if (Memo("BRK"))
    BEGIN
     if (ArgCnt!=0) WrError(1110);
     else
      BEGIN
       CodeLen=2; BAsmCode[0]=0x00; BAsmCode[1]=NOPCode;
      END
     return;
    END

   for (z=0; z<FixedOrderCnt; z++)
    if (Memo(FixedOrders[z].Name))
     BEGIN
      if (ArgCnt!=0) WrError(1110);
      else if (((FixedOrders[z].Allowed >> (MomCPU-CPU65816))&1)==0) WrError(1500);
      else
       BEGIN
        CodeLen=1+Ord(Hi(FixedOrders[z].Code)!=0);
        if (CodeLen==2) BAsmCode[0]=Hi(FixedOrders[z].Code);
        BAsmCode[CodeLen-1]=Lo(FixedOrders[z].Code);
       END
      return;
     END

   if ((Memo("PHB")) OR (Memo("PLB")))
    BEGIN
     if (ArgCnt!=0) WrError(1110);
     else
      BEGIN
       if (MomCPU>=CPUM7700)
	BEGIN
	 CodeLen=2; BAsmCode[0]=PrefAccB; BAsmCode[1]=0x48;
	END
       else
	BEGIN
	 CodeLen=1; BAsmCode[0]=0x8b;
	END;
       if (Memo("PLB")) BAsmCode[CodeLen-1]+=0x20;
      END
     return;
    END

   /* relative Adressierung */

   for (z=0; z<RelOrderCnt; z++)
    if (Memo(RelOrders[z].Name))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else
       BEGIN
        if (*ArgStr[1]=='#') strcpy(ArgStr[1],ArgStr[1]+1);
        AdrLong=EvalIntExpression(ArgStr[1],Int32,&OK);
        if (OK)
         BEGIN
          OK=RelOrders[z].Disp8==-1;
          if (OK) AdrLong-=EProgCounter()+RelOrders[z].Disp16;
          else
           BEGIN
            AdrLong-=EProgCounter()+RelOrders[z].Disp8;
            if (((AdrLong>127) OR (AdrLong<-128)) AND (NOT SymbolQuestionable) AND (RelOrders[z].Disp16!=-1))
             BEGIN
              OK=True; AdrLong-=RelOrders[z].Disp16-RelOrders[z].Disp8;
             END
           END
          if (OK)            /* d16 */
           if (((AdrLong<-32768) OR (AdrLong>32767)) AND (NOT SymbolQuestionable)) WrError(1330);
           else
            BEGIN
             CodeLen=3; BAsmCode[0]=Hi(RelOrders[z].Code);
             BAsmCode[1]=Lo(AdrLong); BAsmCode[2]=Hi(AdrLong);
            END
          else               /* d8 */
           if (((AdrLong<-128) OR (AdrLong>127)) AND (NOT SymbolQuestionable)) WrError(1370);
           else
            BEGIN
             CodeLen=2; BAsmCode[0]=Lo(RelOrders[z].Code);
             BAsmCode[1]=Lo(AdrLong);
            END
         END
       END
      return;
     END

   /* mit Akku */

   for (z=0; z<AccOrderCnt; z++)
    if (LMemo(AccOrders[z].Name))
     BEGIN
      if ((ArgCnt==0) OR (ArgCnt>3)) WrError(1110);
      else
       BEGIN
        WordSize=(Reg_M==0);
        if (strcasecmp(ArgStr[1],"A")==0) Start=2;
        else if (strcasecmp(ArgStr[1],"B")==0)
         BEGIN
          Start=2; BAsmCode[0]=PrefAccB; CodeLen++;
          if (MomCPU==CPU65816)
           BEGIN
            WrError(1505); return;
           END
         END
        else Start=1;
        Mask=MModAbs8+MModAbs16+MModAbs24+
             MModIdxX8+MModIdxX16+MModIdxX24+
             MModIdxY16+
             MModInd8+MModIndX8+MModIndY8+
             MModIdxS8+MModIndS8;
        if (NOT LMemo("STA")) Mask+=MModImm;
        DecodeAdr(Start,Mask);
        if (AdrType!=ModNone)
         if ((LFlag) AND (AdrType!=ModInd8) AND (AdrType!=ModIndY8)) WrError(1350);
         else
          BEGIN
           switch (AdrType)
            BEGIN
             case ModImm    : BAsmCode[CodeLen]=AccOrders[z].Code+0x09; break;
             case ModAbs8   : BAsmCode[CodeLen]=AccOrders[z].Code+0x05; break;
             case ModAbs16  : BAsmCode[CodeLen]=AccOrders[z].Code+0x0d; break;
             case ModAbs24  : BAsmCode[CodeLen]=AccOrders[z].Code+0x0f; break;
             case ModIdxX8  : BAsmCode[CodeLen]=AccOrders[z].Code+0x15; break;
             case ModIdxX16 : BAsmCode[CodeLen]=AccOrders[z].Code+0x1d; break;
             case ModIdxX24 : BAsmCode[CodeLen]=AccOrders[z].Code+0x1f; break;
             case ModIdxY16 : BAsmCode[CodeLen]=AccOrders[z].Code+0x19; break;
             case ModInd8   : if (LFlag) BAsmCode[CodeLen]=AccOrders[z].Code+0x07;
         		      else BAsmCode[CodeLen]=AccOrders[z].Code+0x12; break;
             case ModIndX8  : BAsmCode[CodeLen]=AccOrders[z].Code+0x01; break;
             case ModIndY8  : if (LFlag) BAsmCode[CodeLen]=AccOrders[z].Code+0x17;
         		      else BAsmCode[CodeLen]=AccOrders[z].Code+0x11; break;
             case ModIdxS8  : BAsmCode[CodeLen]=AccOrders[z].Code+0x03; break;
             case ModIndS8  : BAsmCode[CodeLen]=AccOrders[z].Code+0x13; break;
            END
           memcpy(BAsmCode+CodeLen+1,AdrVals,AdrCnt); CodeLen+=1+AdrCnt;
          END
       END
     return;
    END

   if ((Memo("EXTS")) OR (Memo("EXTZ")))
    BEGIN
     if (ArgCnt==0)
      BEGIN
       strmaxcpy(ArgStr[1],"A",255); ArgCnt=1;
      END
     if (ArgCnt!=1) WrError(1110);
     else if (MomCPU<CPUM7750) WrError(1500);
     else
      BEGIN
       BAsmCode[1]=0x8b+(Ord(Memo("EXTZ")) << 5);
       BAsmCode[0]=0;
       if (strcasecmp(ArgStr[1],"A")==0) BAsmCode[0]=0x89;
       else if (strcasecmp(ArgStr[1],"B")==0) BAsmCode[0]=0x42;
       else WrError(1350);
       if (BAsmCode[0]!=0) CodeLen=2;
      END
     return;
    END

   for (z=0; z<RMWOrderCnt; z++)
    if (Memo(RMWOrders[z].Name))
     BEGIN
      if ((ArgCnt==0) OR ((ArgCnt==1) AND (strcasecmp(ArgStr[1],"A")==0)))
       BEGIN
        CodeLen=1; BAsmCode[0]=RMWOrders[z].ACode;
       END
      else if ((ArgCnt==1) AND (strcasecmp(ArgStr[1],"B")==0))
       BEGIN
        CodeLen=2; BAsmCode[0]=PrefAccB; BAsmCode[1]=RMWOrders[z].ACode;
        if (MomCPU==CPU65816)
         BEGIN
          WrError(1505); return;
         END
       END
      else if (ArgCnt>2) WrError(1110);
      else
       BEGIN
        DecodeAdr(1,MModAbs8+MModAbs16+MModIdxX8+MModIdxX16);
        if (AdrType!=ModNone)
         BEGIN
          switch (AdrType)
           BEGIN
            case ModAbs8   : BAsmCode[0]=RMWOrders[z].MCode; break;
            case ModAbs16  : BAsmCode[0]=RMWOrders[z].MCode+8; break;
            case ModIdxX8  : BAsmCode[0]=RMWOrders[z].MCode+16; break;
            case ModIdxX16 : BAsmCode[0]=RMWOrders[z].MCode+24; break;
           END
          memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
         END
       END
      return;
     END

   if (Memo("ASR"))
    BEGIN
     if (MomCPU<CPUM7750) WrError(1500);
     else if ((ArgCnt==0) OR ((ArgCnt==1) AND (strcasecmp(ArgStr[1],"A")==0)))
      BEGIN
       BAsmCode[0]=0x89; BAsmCode[1]=0x08; CodeLen=2;
      END
     else if ((ArgCnt==1) AND (strcasecmp(ArgStr[1],"B")==0))
      BEGIN
       BAsmCode[0]=0x42; BAsmCode[1]=0x08; CodeLen=2;
      END
     else if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
     else
      BEGIN
       DecodeAdr(1,MModAbs8+MModIdxX8+MModAbs16+MModIdxX16);
       if (AdrType!=ModNone)
        BEGIN
         BAsmCode[0]=0x89;
         switch (AdrType)
          BEGIN
           case ModAbs8:BAsmCode[1]=0x06; break;
           case ModIdxX8:BAsmCode[1]=0x16; break;
           case ModAbs16:BAsmCode[1]=0x0e; break;
           case ModIdxX16:BAsmCode[1]=0x1e; break;
          END
         memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
        END
      END
     return;
    END

   if ((Memo("BBC")) OR (Memo("BBS")))
    BEGIN
     if (ArgCnt!=3) WrError(1110);
     else if (MomCPU<CPUM7700) WrError(1500);
     else
      BEGIN
       WordSize=(Reg_M==0);
       ArgCnt=2; DecodeAdr(2,MModAbs8+MModAbs16);
       if (AdrType!=ModNone)
	BEGIN
	 BAsmCode[0]=0x24;
	 if (Memo("BBC")) BAsmCode[0]+=0x10;
	 if (AdrType==ModAbs16) BAsmCode[0]+=8;
	 memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
	 ArgCnt=1; DecodeAdr(1,MModImm);
	 if (AdrType==ModNone) CodeLen=0;
	 else
	  BEGIN
	   memcpy(BAsmCode+CodeLen,AdrVals,AdrCnt); CodeLen+=AdrCnt;
	   AdrLong=EvalIntExpression(ArgStr[3],UInt24,&OK)-(EProgCounter()+CodeLen+1);
	   if (NOT OK) CodeLen=0;
	   else if ((NOT SymbolQuestionable) AND ((AdrLong<-128) OR (AdrLong>127)))
	    BEGIN
	     WrError(1370); CodeLen=0;
	    END
	   else
	    BEGIN
	     BAsmCode[CodeLen]=Lo(AdrLong); CodeLen++;
	    END
	  END
	END
      END
     return;
    END

   if (Memo("BIT"))
    BEGIN
     if ((ArgCnt!=1) AND (ArgCnt!=2)) WrError(1110);
     else if (MomCPU!=CPU65816) WrError(1500);
     else
      BEGIN
       WordSize=False;
       DecodeAdr(1,MModAbs8+MModAbs16+MModIdxX8+MModIdxX16+MModImm);
       if (AdrType!=ModNone)
	BEGIN
	 switch (AdrType)
          BEGIN
	   case ModAbs8:BAsmCode[0]=0x24; break;
	   case ModAbs16:BAsmCode[0]=0x2c; break;
	   case ModIdxX8:BAsmCode[0]=0x34; break;
	   case ModIdxX16:BAsmCode[0]=0x3c; break;
	   case ModImm:BAsmCode[0]=0x89; break;
	  END
	 memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
	END
      END
     return;
    END

   if ((Memo("CLB")) OR (Memo("SEB")))
    BEGIN
     if (ArgCnt!=2) WrError(1110);
     else if (MomCPU<CPUM7700) WrError(1500);
     else
      BEGIN
       WordSize=(Reg_M==0);
       DecodeAdr(2,MModAbs8+MModAbs16);
       if (AdrType!=ModNone)
	BEGIN
	 BAsmCode[0]=0x04;
	 if (Memo("CLB")) BAsmCode[0]+=0x10;
	 if (AdrType==ModAbs16) BAsmCode[0]+=8;
	 memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
	 ArgCnt=1; DecodeAdr(1,MModImm);
	 if (AdrType==ModNone) CodeLen=0;
	 else
	  BEGIN
	   memcpy(BAsmCode+CodeLen,AdrVals,AdrCnt); CodeLen+=AdrCnt;
	  END
	END
      END
     return;
    END

   if ((Memo("TSB")) OR (Memo("TRB")))
    BEGIN
     if (MomCPU==CPU65816)
      BEGIN
       if (ArgCnt!=1) WrError(1110);
       else
	BEGIN
	 DecodeAdr(1,MModAbs8+MModAbs16);
	 if (AdrType!=ModNone)
	  BEGIN
	   BAsmCode[0]=0x04;
	   if (Memo("TRB")) BAsmCode[0]+=0x10;
	   if (AdrType==ModAbs16) BAsmCode[0]+=8;
	   memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
	  END
	END
      END
     else if (Memo("TRB")) WrError(1500);
     else if (ArgCnt!=0) WrError(1110);
     else
      BEGIN
       CodeLen=2; BAsmCode[0]=0x42; BAsmCode[1]=0x3b;
      END
     return;
    END

   for (z=0; z<Imm8OrderCnt; z++)
    if (Memo(Imm8Orders[z].Name))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else if (((Imm8Orders[z].Allowed >> (MomCPU-CPU65816))&1)==0) WrError(1500);
      else
       BEGIN
        WordSize=False;
        DecodeAdr(1,MModImm);
        if (AdrType==ModImm)
         BEGIN
          CodeLen=1+Ord(Hi(Imm8Orders[z].Code)!=0);
          if (CodeLen==2) BAsmCode[0]=Hi(Imm8Orders[z].Code);
          BAsmCode[CodeLen-1]=Lo(Imm8Orders[z].Code);
          memcpy(BAsmCode+CodeLen,AdrVals,AdrCnt); CodeLen+=AdrCnt;
         END
       END
      return;
     END

   if (Memo("RLA"))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       WordSize=(Reg_M==0);
       DecodeAdr(1,MModImm);
       if (AdrType!=ModNone)
        BEGIN
         CodeLen=2+AdrCnt; BAsmCode[0]=0x89; BAsmCode[1]=0x49;
         memcpy(BAsmCode+2,AdrVals,AdrCnt);
        END
      END
     return;
    END

   for (z=0; z<XYOrderCnt; z++)
    if (Memo(XYOrders[z].Name))
     BEGIN
      if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
      else
       BEGIN
        WordSize=(Reg_X==0); Mask=0;
        if (XYOrders[z].CodeImm   !=0xff) Mask+=MModImm;
        if (XYOrders[z].CodeAbs8  !=0xff) Mask+=MModAbs8;
        if (XYOrders[z].CodeAbs16 !=0xff) Mask+=MModAbs16;
        if (XYOrders[z].CodeIdxX8 !=0xff) Mask+=MModIdxX8;
        if (XYOrders[z].CodeIdxX16!=0xff) Mask+=MModIdxX16;
        if (XYOrders[z].CodeIdxY8 !=0xff) Mask+=MModIdxY8;
        if (XYOrders[z].CodeIdxY16!=0xff) Mask+=MModIdxY16;
        DecodeAdr(1,Mask);
        if (AdrType!=ModNone)
         BEGIN
          switch (AdrType)
           BEGIN
            case ModImm   :BAsmCode[0]=XYOrders[z].CodeImm; break;
            case ModAbs8  :BAsmCode[0]=XYOrders[z].CodeAbs8; break;
            case ModAbs16 :BAsmCode[0]=XYOrders[z].CodeAbs16; break;
            case ModIdxX8 :BAsmCode[0]=XYOrders[z].CodeIdxX8; break;
            case ModIdxY8 :BAsmCode[0]=XYOrders[z].CodeIdxY8; break;
            case ModIdxX16:BAsmCode[0]=XYOrders[z].CodeIdxX16; break;
            case ModIdxY16:BAsmCode[0]=XYOrders[z].CodeIdxY16; break;
           END
          memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
         END
       END
      return;
     END

    for (z=0; z<MulDivOrderCnt; z++)
     if (LMemo(MulDivOrders[z].Name))
      BEGIN
       if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
       else if (((MulDivOrders[z].Allowed >> (MomCPU-CPU65816))&1)==0) WrError(1500);
       else
        BEGIN
         WordSize=(Reg_M==0);
         DecodeAdr(1,MModImm+MModAbs8+MModAbs16+MModAbs24+MModIdxX8+MModIdxX16+
                     MModIdxX24+MModIdxY16+MModInd8+MModIndX8+MModIndY8+
                     MModIdxS8+MModIndS8);
         if (AdrType!=ModNone)
          if ((LFlag) AND (AdrType!=ModInd8) AND (AdrType!=ModIndY8)) WrError(1350);
          else
           BEGIN
            BAsmCode[0]=0x89;
            switch (AdrType)
             BEGIN
              case ModImm    : BAsmCode[1]=0x09; break;
              case ModAbs8   : BAsmCode[1]=0x05; break;
              case ModAbs16  : BAsmCode[1]=0x0d; break;
              case ModAbs24  : BAsmCode[1]=0x0f; break;
              case ModIdxX8  : BAsmCode[1]=0x15; break;
              case ModIdxX16 : BAsmCode[1]=0x1d; break;
              case ModIdxX24 : BAsmCode[1]=0x1f; break;
              case ModIdxY16 : BAsmCode[1]=0x19; break;
              case ModInd8   : BAsmCode[1]=(LFlag) ? 0x07 : 0x12; break;
              case ModIndX8  : BAsmCode[1]=0x01; break;
              case ModIndY8  : BAsmCode[1]=(LFlag) ? 0x17 : 0x11; break;
              case ModIdxS8  : BAsmCode[1]=0x03; break;
              case ModIndS8  : BAsmCode[1]=0x13; break;
             END
            BAsmCode[1]+=MulDivOrders[z].Code;
            memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt;
           END
        END
       return;
      END

   if ((Memo("JML")) OR (Memo("JSL")))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK);
       if (OK)
	BEGIN
	 CodeLen=4;
	 BAsmCode[0]=(Memo("JSL")) ? 0x22 : 0x5c;
	 BAsmCode[1]=AdrLong >> 16;
	 BAsmCode[2]=Hi(AdrLong);
	 BAsmCode[3]=Lo(AdrLong);
	END
      END
     return;
    END

   if ((LMemo("JMP")) OR (LMemo("JSR")))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       BankReg=Reg_PG;
       Mask=MModAbs24+MModIndX16;
       if (NOT LFlag) Mask+=MModAbs16;
       DecodeAdr(1,Mask+((LMemo("JSR"))?0:MModInd16));
       if (AdrType!=ModNone)
        BEGIN
         switch (AdrType)
          BEGIN
           case ModAbs16:
            BAsmCode[0]=(LMemo("JSR")) ? 0x20 : 0x4c; break;
           case ModAbs24:
            BAsmCode[0]=(LMemo("JSR")) ? 0x22 : 0x5c; break;
           case ModIndX16:
            BAsmCode[0]=(LMemo("JSR")) ? 0xfc : 0x7c; break;
           case ModInd16:
            BAsmCode[0]=(LFlag) ? 0xdc : 0x6c; break;
          END
         memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
        END
      END
     return;
    END

   if (Memo("LDM"))
    BEGIN
     if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
     else if (MomCPU<CPUM7700) WrError(1500);
     else
      BEGIN
       DecodeAdr(2,MModAbs8+MModAbs16+MModIdxX8+MModIdxX16);
       if (AdrType!=ModNone)
	BEGIN
	 switch (AdrType)
          BEGIN
	   case ModAbs8  : BAsmCode[0]=0x64; break;
	   case ModAbs16 : BAsmCode[0]=0x9c; break;
	   case ModIdxX8 : BAsmCode[0]=0x74; break;
	   case ModIdxX16: BAsmCode[0]=0x9e; break;
	  END
	 memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
	 WordSize=(Reg_M==0);
	 ArgCnt=1; DecodeAdr(1,MModImm);
	 if (AdrType==ModNone) CodeLen=0;
	 else
	  BEGIN
	   memcpy(BAsmCode+CodeLen,AdrVals,AdrCnt); CodeLen+=AdrCnt;
	  END
	END
      END
     return;
    END

   if (Memo("STZ"))
    BEGIN
     if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
     else if (MomCPU!=CPU65816) WrError(1500);
     else
      BEGIN
       DecodeAdr(1,MModAbs8+MModAbs16+MModIdxX8+MModIdxX16);
       if (AdrType!=ModNone)
	BEGIN
	 switch (AdrType)
          BEGIN
	   case ModAbs8  : BAsmCode[0]=0x64; break;
	   case ModAbs16 : BAsmCode[0]=0x9c; break;
	   case ModIdxX8 : BAsmCode[0]=0x74; break;
	   case ModIdxX16: BAsmCode[0]=0x9e; break;
	  END
	 memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt;
	END
      END
     return;
    END

   if ((Memo("MVN")) OR (Memo("MVP")))
    BEGIN
     if (ArgCnt!=2) WrError(1110);
     else
      BEGIN
       AdrLong=EvalIntExpression(ArgStr[1],Int32,&OK);
       if (OK)
	BEGIN
	 Mask=EvalIntExpression(ArgStr[2],Int32,&OK);
	 if (OK)
	  if (((Mask & 0xff000000)!=0) OR ((AdrLong & 0xff000000)!=0)) WrError(1320);
	  else
	   BEGIN
	    BAsmCode[0]=(Memo("MVN")) ? 0x54 : 0x44;
	    BAsmCode[1]=AdrLong >> 16;
	    BAsmCode[2]=Mask >> 16;
	    CodeLen=3;
	   END
	END
      END
     return;
    END

   if ((Memo("PSH")) OR (Memo("PUL")))
    BEGIN
     if (ArgCnt==0) WrError(1110);
     else if (MomCPU<CPUM7700) WrError(1500);
     else
      BEGIN
       BAsmCode[0]=0xeb+(Ord(Memo("PUL")) << 4);
       BAsmCode[1]=0; OK=True;
       z=1;
       while ((z<=ArgCnt) AND (OK))
	BEGIN
	 if (*ArgStr[z]=='#')
	  BAsmCode[1]|=EvalIntExpression(ArgStr[z]+1,Int8,&OK);
	 else
	  BEGIN
	   Start=0;
	   while ((Start<PushRegCnt) AND (strcasecmp(PushRegs[Start],ArgStr[z])!=0)) Start++;
	   OK=(Start<PushRegCnt);
	   if (OK) BAsmCode[1]|=1l << Start;
	   else WrXError(1980,ArgStr[z]);
	  END
	 z++;
	END
       if (OK) CodeLen=2;
      END
     return;
    END

   if (Memo("PEA"))
    BEGIN
     WordSize=True;
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       DecodeAdr(1,MModImm);
       if (AdrType!=ModNone)
        BEGIN
         CodeLen=1+AdrCnt; BAsmCode[0]=0xf4;
         memcpy(BAsmCode+1,AdrVals,AdrCnt);
        END
      END
     return;
    END

   if (Memo("PEI"))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       if (*ArgStr[1]=='#') strcpy(ArgStr[1],ArgStr[1]+1);
       DecodeAdr(1,MModAbs8);
       if (AdrType!=ModNone)
        BEGIN
         CodeLen=1+AdrCnt; BAsmCode[0]=0xd4;
         memcpy(BAsmCode+1,AdrVals,AdrCnt);
        END
      END
     return;
    END

   if (Memo("PER"))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       Rel=True;
       if (*ArgStr[1]=='#')
        BEGIN
         strcpy(ArgStr[1],ArgStr[1]+1); Rel=False;
        END
       BAsmCode[0]=0x62;
       if (Rel)
        BEGIN
         AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK)-(EProgCounter()+2);
         if (OK)
          if ((AdrLong<-32768) OR (AdrLong>32767)) WrError(1370);
          else
           BEGIN
            CodeLen=3; BAsmCode[1]=AdrLong & 0xff;
            BAsmCode[2]=(AdrLong >> 8) & 0xff;
           END
        END
       else
        BEGIN
         z=EvalIntExpression(ArgStr[1],Int16,&OK);
         if (OK)
          BEGIN
           CodeLen=3; BAsmCode[1]=Lo(z); BAsmCode[2]=Hi(z);
          END
        END
      END
     return;
    END

   WrXError(1200,OpPart);
END

	static void InitCode_7700(void)
BEGIN
   SaveInitProc();
   Reg_PG=0;
   Reg_DT=0;
   Reg_X=0;
   Reg_M=0;
   Reg_DPR=0;
END

	static Boolean IsDef_7700(void)
BEGIN
   return False;
END

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

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

   PCSymbol="*"; HeaderID=0x19; NOPCode=0xea;
   DivideChars=","; HasAttrs=False;

   ValidSegs=1 << SegCode;
   Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0;
   SegLimits[SegCode] = 0xffffffl;

   MakeCode=MakeCode_7700; IsDef=IsDef_7700;
   SwitchFrom=SwitchFrom_7700; InitFields();
END


	void code7700_init(void)
BEGIN
   CPU65816=AddCPU("65816"    ,SwitchTo_7700);
   CPUM7700=AddCPU("MELPS7700",SwitchTo_7700);
   CPUM7750=AddCPU("MELPS7750",SwitchTo_7700);
   CPUM7751=AddCPU("MELPS7751",SwitchTo_7700);


   SaveInitProc=InitPassProc; InitPassProc=InitCode_7700;
END