aboutsummaryrefslogtreecommitdiffstats
path: root/code7700.c
diff options
context:
space:
mode:
Diffstat (limited to 'code7700.c')
-rw-r--r--code7700.c1304
1 files changed, 1304 insertions, 0 deletions
diff --git a/code7700.c b/code7700.c
new file mode 100644
index 0000000..b7fb20b
--- /dev/null
+++ b/code7700.c
@@ -0,0 +1,1304 @@
+/* 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