From 333b605b2afd472b823aeda0adf0e8b1ea9843c0 Mon Sep 17 00:00:00 2001 From: fishsoupisgood Date: Mon, 27 May 2019 02:41:51 +0100 Subject: initial commit from asl-1.41r8.tar.gz --- code7700.c | 1304 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1304 insertions(+) create mode 100644 code7700.c (limited to 'code7700.c') 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 + +#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> 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> (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; z127) 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; z3)) 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 (MomCPU2) 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 (MomCPU2)) 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 (MomCPU127))) + 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> (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; z2)) 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; z2)) 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 (MomCPU2)) 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 (MomCPU32767)) 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 -- cgit v1.2.3