dect
/
asl
Archived
13
0
Fork 0
Code Issues Releases Activity
This repository has been archived on 2022-02-17. You can view files and clone it, but cannot push or open issues or pull requests.
asl/code68.c

848 lines
23 KiB
C
Raw Permalink Blame History

/* code68.c */
/*****************************************************************************/
/* AS-Portierung */
/* */
/* Codegenerator fuer 68xx Prozessoren */
/* */
/* Historie: 13. 8.1996 Grundsteinlegung */
/* 2. 1.1998 ChkPC ersetzt */
/* */
/*****************************************************************************/
#include "stdinc.h"
#include <string.h>
#include <ctype.h>
#include "bpemu.h"
#include "strutil.h"
#include "asmdef.h"
#include "asmpars.h"
#include "asmsub.h"
#include "codepseudo.h"
#include "codevars.h"
#include "asmitree.h"
/*---------------------------------------------------------------------------*/
typedef struct
{
char *Name;
CPUVar MinCPU,MaxCPU;
Word Code;
} FixedOrder;
typedef struct
{
char *Name;
Byte Code;
} BaseOrder;
typedef struct
{
char *Name;
Boolean MayImm;
Byte Code;
} ALU8Order;
typedef struct
{
Boolean MayImm;
CPUVar MinCPU; /* Shift andere ,Y */
Byte PageShift; /* 0 : nix Pg 2 */
Byte Code; /* 1 : Pg 3 Pg 4 */
} ALU16Order; /* 2 : nix Pg 4 */
/* 3 : Pg 2 Pg 3 */
#define ModNone (-1)
#define ModAcc 0
#define MModAcc (1<<ModAcc)
#define ModDir 1
#define MModDir (1<<ModDir)
#define ModExt 2
#define MModExt (1<<ModExt)
#define ModInd 3
#define MModInd (1<<ModInd)
#define ModImm 4
#define MModImm (1<<ModImm)
#define Page2Prefix 0x18
#define Page3Prefix 0x1a
#define Page4Prefix 0xcd
#define FixedOrderCnt 45
#define RelOrderCnt 19
#define ALU8OrderCnt 11
#define ALU16OrderCnt 13
#define Sing8OrderCnt 12
#define Bit63OrderCnt 4
static ShortInt OpSize;
static Byte PrefCnt; /* Anzahl Befehlspraefixe */
static ShortInt AdrMode; /* Ergebnisadressmodus */
static Byte AdrPart; /* Adressierungsmodusbits im Opcode */
static Byte AdrVals[4]; /* Adressargument */
static FixedOrder *FixedOrders;
static BaseOrder *RelOrders;
static ALU8Order *ALU8Orders;
static ALU16Order *ALU16Orders;
static BaseOrder *Bit63Orders;
static BaseOrder *Sing8Orders;
static PInstTable InstTable;
static CPUVar CPU6800,CPU6301,CPU6811;
/*---------------------------------------------------------------------------*/
static void DecodeAdr(int StartInd, int StopInd, Byte Erl)
BEGIN
String Asc;
Boolean OK,ErrOcc;
Word AdrWord;
Byte Bit8;
AdrMode=ModNone; AdrPart=0; strmaxcpy(Asc,ArgStr[StartInd],255); ErrOcc=False;
/* eine Komponente ? */
if (StartInd==StopInd)
BEGIN
/* Akkumulatoren ? */
if (strcasecmp(Asc,"A")==0)
BEGIN
if ((MModAcc & Erl)!=0) AdrMode=ModAcc;
END
else if (strcasecmp(Asc,"B")==0)
BEGIN
if ((MModAcc & Erl)!=0)
BEGIN
AdrMode=ModAcc; AdrPart=1;
END
END
/* immediate ? */
else if ((strlen(Asc)>1) AND (*Asc=='#'))
BEGIN
if ((MModImm & Erl)!=0)
BEGIN
if (OpSize==1)
BEGIN
AdrWord=EvalIntExpression(Asc+1,Int16,&OK);
if (OK)
BEGIN
AdrMode=ModImm;
AdrVals[AdrCnt++]=Hi(AdrWord); AdrVals[AdrCnt++]=Lo(AdrWord);
END
else ErrOcc=True;
END
else
BEGIN
AdrVals[AdrCnt]=EvalIntExpression(Asc+1,Int8,&OK);
if (OK)
BEGIN
AdrMode=ModImm; AdrCnt++;
END
else ErrOcc=True;
END
END
END
/* absolut ? */
else
BEGIN
Bit8=0;
if (*Asc=='<')
BEGIN
Bit8=2; strcpy(Asc,Asc+1);
END
else if (*Asc=='>')
BEGIN
Bit8=1; strcpy(Asc,Asc+1);
END
if ((Bit8==2) OR ((MModExt & Erl)==0))
AdrWord=EvalIntExpression(Asc,Int8,&OK);
else
AdrWord=EvalIntExpression(Asc,Int16,&OK);
if (OK)
BEGIN
if (((MModDir & Erl)!=0) AND (Bit8!=1) AND ((Bit8==2) OR ((MModExt & Erl)==0) OR (Hi(AdrWord)==0)))
BEGIN
if (Hi(AdrWord)!=0)
BEGIN
WrError(1340); ErrOcc=True;
END
else
BEGIN
AdrMode=ModDir; AdrPart=1;
AdrVals[AdrCnt++]=Lo(AdrWord);
END
END
else if ((MModExt & Erl)!=0)
BEGIN
AdrMode=ModExt; AdrPart=3;
AdrVals[AdrCnt++]=Hi(AdrWord); AdrVals[AdrCnt++]=Lo(AdrWord);
END
END
else ErrOcc=True;
END
END
/* zwei Komponenten ? */
else if (StartInd+1==StopInd)
BEGIN
/* indiziert ? */
if (((strcasecmp(ArgStr[StopInd],"X")==0) OR (strcasecmp(ArgStr[StopInd],"Y")==0)))
BEGIN
if ((MModInd & Erl)!=0)
BEGIN
AdrWord=EvalIntExpression(Asc,Int8,&OK);
if (OK)
if ((MomCPU<CPU6811) AND (strcasecmp(ArgStr[StartInd+1],"Y")==0))
BEGIN
WrError(1505); ErrOcc=True;
END
else
BEGIN
AdrVals[AdrCnt++]=Lo(AdrWord);
AdrMode=ModInd; AdrPart=2;
if (strcasecmp(ArgStr[StartInd+1],"Y")==0)
BEGIN
BAsmCode[PrefCnt++]=0x18;
END
END
else ErrOcc=True;
END
END
else
BEGIN
WrXError(1445,ArgStr[StopInd]); ErrOcc=True;
END
END
else
BEGIN
WrError(1110); ErrOcc=True;
END
if ((NOT ErrOcc) AND (AdrMode==ModNone)) WrError(1350);
END
static void AddPrefix(Byte Prefix)
BEGIN
BAsmCode[PrefCnt++]=Prefix;
END
static void Try2Split(int Src)
BEGIN
Integer z;
char *p;
KillPrefBlanks(ArgStr[Src]); KillPostBlanks(ArgStr[Src]);
p=ArgStr[Src]+strlen(ArgStr[Src])-1;
while ((p>ArgStr[Src]) AND (NOT isspace((unsigned int) *p))) p--;
if (p>ArgStr[Src])
BEGIN
for (z=ArgCnt; z>=Src; z--) strcpy(ArgStr[z+1],ArgStr[z]); ArgCnt++;
strcpy(ArgStr[Src+1],p+1); *p='\0';
KillPostBlanks(ArgStr[Src]); KillPrefBlanks(ArgStr[Src+1]);
END
END
/*---------------------------------------------------------------------------*/
static void DecodeFixed(Word Index)
BEGIN
FixedOrder *forder=FixedOrders+Index;
if (ArgCnt!=0) WrError(1110);
else if ((MomCPU<forder->MinCPU) OR (MomCPU>forder->MaxCPU)) WrError(1500);
else if (Hi(forder->Code)!=0)
BEGIN
CodeLen=2;
BAsmCode[0]=Hi(forder->Code);
BAsmCode[1]=Lo(forder->Code);
END
else
BEGIN
CodeLen=1;
BAsmCode[0]=Lo(forder->Code);
END
END
static void DecodeRel(Word Index)
BEGIN
BaseOrder *forder=RelOrders+Index;
Integer AdrInt;
Boolean OK;
if (ArgCnt!=1) WrError(1110);
else
BEGIN
AdrInt=EvalIntExpression(ArgStr[1],Int16,&OK);
if (OK)
BEGIN
AdrInt-=EProgCounter()+2;
if (((AdrInt<-128) OR (AdrInt>127)) AND (NOT SymbolQuestionable)) WrError(1370);
else
BEGIN
CodeLen=2; BAsmCode[0]=forder->Code; BAsmCode[1]=Lo(AdrInt);
END
END
END
END
static void DecodeALU16(Word Index)
BEGIN
ALU16Order *forder=ALU16Orders+Index;
OpSize=1;
if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
else if (MomCPU<forder->MinCPU) WrError(1500);
else
BEGIN
DecodeAdr(1,ArgCnt,(forder->MayImm?MModImm:0)+MModInd+MModExt+MModDir);
if (AdrMode!=ModNone)
BEGIN
switch (forder->PageShift)
BEGIN
case 1:
if (PrefCnt==1) BAsmCode[PrefCnt-1]=Page4Prefix;
else AddPrefix(Page3Prefix);
break;
case 2:
if (PrefCnt==1) BAsmCode[PrefCnt-1]=Page4Prefix;
break;
case 3:
if (PrefCnt==0) AddPrefix((AdrMode==ModInd)?Page3Prefix:Page2Prefix);
break;
END
BAsmCode[PrefCnt]=forder->Code+(AdrPart << 4);
CodeLen=PrefCnt+1+AdrCnt;
memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
END
END
END
static void DecodeBit63(Word Index)
BEGIN
BaseOrder *forder=Bit63Orders+Index;
if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
else if (MomCPU!=CPU6301) WrError(1500);
else
BEGIN
DecodeAdr(1,1,MModImm);
if (AdrMode!=ModNone)
BEGIN
DecodeAdr(2,ArgCnt,MModDir+MModInd);
if (AdrMode!=ModNone)
BEGIN
BAsmCode[PrefCnt]=forder->Code;
if (AdrMode==ModDir) BAsmCode[PrefCnt]+=0x10;
CodeLen=PrefCnt+1+AdrCnt;
memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
END
END
END
END
static void DecodeJMP(Word Index)
BEGIN
if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
else
BEGIN
DecodeAdr(1,ArgCnt,MModExt+MModInd);
if (AdrMode!=ModImm)
BEGIN
CodeLen=PrefCnt+1+AdrCnt;
BAsmCode[PrefCnt]=0x4e + (AdrPart << 4);
memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
END
END
END
static void DecodeJSR(Word Index)
BEGIN
if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
else
BEGIN
DecodeAdr(1,ArgCnt,MModDir+MModExt+MModInd);
if (AdrMode!=ModImm)
BEGIN
CodeLen=PrefCnt+1+AdrCnt;
BAsmCode[PrefCnt]=0x8d+(AdrPart << 4);
memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
END
END
END
static void DecodeBRxx(Word Index)
BEGIN
Boolean OK;
Byte Mask;
Integer AdrInt;
if (ArgCnt==1)
BEGIN
Try2Split(1); Try2Split(1);
END
else if (ArgCnt==2)
BEGIN
Try2Split(ArgCnt); Try2Split(2);
END
if ((ArgCnt<3) OR (ArgCnt>4)) WrError(1110);
else if (MomCPU<CPU6811) WrError(1500);
else
BEGIN
if (*ArgStr[ArgCnt-1]=='#') strcpy(ArgStr[ArgCnt-1],ArgStr[ArgCnt-1]+1);
Mask=EvalIntExpression(ArgStr[ArgCnt-1],Int8,&OK);
if (OK)
BEGIN
DecodeAdr(1,ArgCnt-2,MModDir+MModInd);
if (AdrMode!=ModNone)
BEGIN
AdrInt=EvalIntExpression(ArgStr[ArgCnt],Int16,&OK);
if (OK)
BEGIN
AdrInt-=EProgCounter()+3+PrefCnt+AdrCnt;
if ((AdrInt<-128) OR (AdrInt>127)) WrError(1370);
else
BEGIN
CodeLen=PrefCnt+3+AdrCnt;
BAsmCode[PrefCnt]=0x12+Index;
if (AdrMode==ModInd) BAsmCode[PrefCnt]+=12;
memcpy(BAsmCode+PrefCnt+1,AdrVals,AdrCnt);
BAsmCode[PrefCnt+1+AdrCnt]=Mask;
BAsmCode[PrefCnt+2+AdrCnt]=Lo(AdrInt);
END
END
END
END
END
END
static void DecodeBxx(Word Index)
BEGIN
Byte Mask;
Boolean OK;
int z;
if (MomCPU==CPU6301)
BEGIN
strcpy(ArgStr[ArgCnt+1],ArgStr[1]);
for (z=1; z<=ArgCnt-1; z++) strcpy(ArgStr[z],ArgStr[z+1]);
strcpy(ArgStr[ArgCnt],ArgStr[ArgCnt+1]);
END
if ((ArgCnt>=1) AND (ArgCnt<=2)) Try2Split(ArgCnt);
if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
else if (MomCPU<CPU6301) WrError(1500);
else
BEGIN
if (*ArgStr[ArgCnt]=='#') strcpy(ArgStr[ArgCnt],ArgStr[ArgCnt]+1);
Mask=EvalIntExpression(ArgStr[ArgCnt],Int8,&OK);
if ((OK) AND (MomCPU==CPU6301))
if (Mask>7)
BEGIN
WrError(1320); OK=False;
END
else
BEGIN
Mask=1 << Mask;
if (Index==1) Mask=0xff-Mask;
END
if (OK)
BEGIN
DecodeAdr(1,ArgCnt-1,MModDir+MModInd);
if (AdrMode!=ModNone)
BEGIN
CodeLen=PrefCnt+2+AdrCnt;
if (MomCPU==CPU6301)
BEGIN
BAsmCode[PrefCnt]=0x62-Index;
if (AdrMode==ModDir) BAsmCode[PrefCnt]+=0x10;
BAsmCode[1+PrefCnt]=Mask;
memcpy(BAsmCode+2+PrefCnt,AdrVals,AdrCnt);
END
else
BEGIN
BAsmCode[PrefCnt]=0x14+Index;
if (AdrMode==ModInd) BAsmCode[PrefCnt]+=8;
memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
BAsmCode[1+PrefCnt+AdrCnt]=Mask;
END
END
END
END
END
static void DecodeBTxx(Word Index)
BEGIN
Boolean OK;
Byte AdrByte;
if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
else if (MomCPU!=CPU6301) WrError(1500);
else
BEGIN
AdrByte=EvalIntExpression(ArgStr[1],Int8,&OK);
if (OK)
if (AdrByte>7) WrError(1320);
else
BEGIN
DecodeAdr(2,ArgCnt,MModDir+MModInd);
if (AdrMode!=ModNone)
BEGIN
CodeLen=PrefCnt+2+AdrCnt;
BAsmCode[1+PrefCnt]=1 << AdrByte;
memcpy(BAsmCode+2+PrefCnt,AdrVals,AdrCnt);
BAsmCode[PrefCnt]=0x65;
BAsmCode[PrefCnt]+=Index;
if (AdrMode==ModDir) BAsmCode[PrefCnt]+=0x10;
END
END
END
END
/*---------------------------------------------------------------------------*/
static void AddFixed(char *NName, CPUVar NMin, CPUVar NMax, Word NCode)
BEGIN
if (InstrZ>=FixedOrderCnt) exit(255);
FixedOrders[InstrZ].Name=NName;
FixedOrders[InstrZ].MinCPU=NMin;
FixedOrders[InstrZ].MaxCPU=NMax;
FixedOrders[InstrZ].Code=NCode;
AddInstTable(InstTable,NName,InstrZ++,DecodeFixed);
END
static void AddRel(char *NName, Byte NCode)
BEGIN
if (InstrZ>=RelOrderCnt) exit(255);
RelOrders[InstrZ].Name=NName;
RelOrders[InstrZ].Code=NCode;
AddInstTable(InstTable,NName,InstrZ++,DecodeRel);
END
static void AddALU8(char *NName, Boolean NMay, Byte NCode)
BEGIN
if (InstrZ>=ALU8OrderCnt) exit(255);
ALU8Orders[InstrZ].Name=NName;
ALU8Orders[InstrZ].MayImm=NMay;
ALU8Orders[InstrZ++].Code=NCode;
END
static void AddALU16(char *NName, Boolean NMay, CPUVar NMin, Byte NShift, Byte NCode)
BEGIN
if (InstrZ>=ALU16OrderCnt) exit(255);
ALU16Orders[InstrZ].MayImm=NMay;
ALU16Orders[InstrZ].MinCPU=NMin;
ALU16Orders[InstrZ].PageShift=NShift;
ALU16Orders[InstrZ].Code=NCode;
AddInstTable(InstTable,NName,InstrZ++,DecodeALU16);
END
static void AddSing8(char *NName, Byte NCode)
BEGIN
if (InstrZ>=Sing8OrderCnt) exit(255);
Sing8Orders[InstrZ].Name=NName;
Sing8Orders[InstrZ++].Code=NCode;
END
static void AddBit63(char *NName, Byte NCode)
BEGIN
if (InstrZ>=Bit63OrderCnt) exit(255);
Bit63Orders[InstrZ].Name=NName;
Bit63Orders[InstrZ].Code=NCode;
AddInstTable(InstTable,NName,InstrZ++,DecodeBit63);
END
static void InitFields(void)
BEGIN
InstTable=CreateInstTable(201);
AddInstTable(InstTable,"JMP",0,DecodeJMP);
AddInstTable(InstTable,"JSR",0,DecodeJSR);
AddInstTable(InstTable,"BRCLR",1,DecodeBRxx);
AddInstTable(InstTable,"BRSET",0,DecodeBRxx);
AddInstTable(InstTable,"BCLR",1,DecodeBxx);
AddInstTable(InstTable,"BSET",0,DecodeBxx);
AddInstTable(InstTable,"BTST",6,DecodeBTxx);
AddInstTable(InstTable,"BTGL",0,DecodeBTxx);
FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0;
AddFixed("ABA" ,CPU6800, CPU6811, 0x001b); AddFixed("ABX" ,CPU6301, CPU6811, 0x003a);
AddFixed("ABY" ,CPU6811, CPU6811, 0x183a); AddFixed("ASLD" ,CPU6301, CPU6811, 0x0005);
AddFixed("CBA" ,CPU6800, CPU6811, 0x0011); AddFixed("CLC" ,CPU6800, CPU6811, 0x000c);
AddFixed("CLI" ,CPU6800, CPU6811, 0x000e); AddFixed("CLV" ,CPU6800, CPU6811, 0x000a);
AddFixed("DAA" ,CPU6800, CPU6811, 0x0019); AddFixed("DES" ,CPU6800, CPU6811, 0x0034);
AddFixed("DEX" ,CPU6800, CPU6811, 0x0009); AddFixed("DEY" ,CPU6811, CPU6811, 0x1809);
AddFixed("FDIV" ,CPU6811, CPU6811, 0x0003); AddFixed("IDIV" ,CPU6811, CPU6811, 0x0002);
AddFixed("INS" ,CPU6800, CPU6811, 0x0031); AddFixed("INX" ,CPU6800, CPU6811, 0x0008);
AddFixed("INY" ,CPU6811, CPU6811, 0x1808); AddFixed("LSLD" ,CPU6301, CPU6811, 0x0005);
AddFixed("LSRD" ,CPU6301, CPU6811, 0x0004); AddFixed("MUL" ,CPU6301, CPU6811, 0x003d);
AddFixed("NOP" ,CPU6800, CPU6811, 0x0001); AddFixed("PSHX" ,CPU6301, CPU6811, 0x003c);
AddFixed("PSHY" ,CPU6811, CPU6811, 0x183c); AddFixed("PULX" ,CPU6301, CPU6811, 0x0038);
AddFixed("PULY" ,CPU6811, CPU6811, 0x1838); AddFixed("RTI" ,CPU6800, CPU6811, 0x003b);
AddFixed("RTS" ,CPU6800, CPU6811, 0x0039); AddFixed("SBA" ,CPU6800, CPU6811, 0x0010);
AddFixed("SEC" ,CPU6800, CPU6811, 0x000d); AddFixed("SEI" ,CPU6800, CPU6811, 0x000f);
AddFixed("SEV" ,CPU6800, CPU6811, 0x000b); AddFixed("SLP" ,CPU6301, CPU6301, 0x001a);
AddFixed("STOP" ,CPU6811, CPU6811, 0x00cf); AddFixed("SWI" ,CPU6800, CPU6811, 0x003f);
AddFixed("TAB" ,CPU6800, CPU6811, 0x0016); AddFixed("TAP" ,CPU6800, CPU6811, 0x0006);
AddFixed("TBA" ,CPU6800, CPU6811, 0x0017); AddFixed("TPA" ,CPU6800, CPU6811, 0x0007);
AddFixed("TSX" ,CPU6800, CPU6811, 0x0030); AddFixed("TSY" ,CPU6811, CPU6811, 0x1830);
AddFixed("TXS" ,CPU6800, CPU6811, 0x0035); AddFixed("TYS" ,CPU6811, CPU6811, 0x1835);
AddFixed("WAI" ,CPU6800, CPU6811, 0x003e); AddFixed("XGDX" ,CPU6811, CPU6811, 0x008f);
AddFixed("XGDY" ,CPU6811, CPU6811, 0x188f);
RelOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*RelOrderCnt); InstrZ=0;
AddRel("BCC", 0x24); AddRel("BCS", 0x25);
AddRel("BEQ", 0x27); AddRel("BGE", 0x2c);
AddRel("BGT", 0x2e); AddRel("BHI", 0x22);
AddRel("BHS", 0x24); AddRel("BLE", 0x2f);
AddRel("BLO", 0x25); AddRel("BLS", 0x23);
AddRel("BLT", 0x2d); AddRel("BMI", 0x2b);
AddRel("BNE", 0x26); AddRel("BPL", 0x2a);
AddRel("BRA", 0x20); AddRel("BRN", 0x21);
AddRel("BSR", 0x8d); AddRel("BVC", 0x28);
AddRel("BVS", 0x29);
ALU8Orders=(ALU8Order *) malloc(sizeof(ALU8Order)*ALU8OrderCnt); InstrZ=0;
AddALU8("ADC",True , 0x89);
AddALU8("ADD",True , 0x8b);
AddALU8("AND",True , 0x84);
AddALU8("BIT",True , 0x85);
AddALU8("CMP",True , 0x81);
AddALU8("EOR",True , 0x88);
AddALU8("LDA",True , 0x86);
AddALU8("ORA",True , 0x8a);
AddALU8("SBC",True , 0x82);
AddALU8("STA",False, 0x87);
AddALU8("SUB",True , 0x80);
ALU16Orders=(ALU16Order *) malloc(sizeof(ALU16Order)*ALU16OrderCnt); InstrZ=0;
AddALU16("ADDD", True , CPU6301, 0, 0xc3);
AddALU16("CPD" , True , CPU6811, 1, 0x83);
AddALU16("CPX" , True , CPU6800, 2, 0x8c);
AddALU16("CPY" , True , CPU6811, 3, 0x8c);
AddALU16("LDD" , True , CPU6301, 0, 0xcc);
AddALU16("LDS" , True , CPU6800, 0, 0x8e);
AddALU16("LDX" , True , CPU6800, 2, 0xce);
AddALU16("LDY" , True , CPU6811, 3, 0xce);
AddALU16("STD" , False, CPU6301, 0, 0xcd);
AddALU16("STS" , False, CPU6800, 0, 0x8f);
AddALU16("STX" , False, CPU6800, 2, 0xcf);
AddALU16("STY" , False, CPU6811, 3, 0xcf);
AddALU16("SUBD", True , CPU6301, 0, 0x83);
Sing8Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Sing8OrderCnt); InstrZ=0;
AddSing8("ASL", 0x48);
AddSing8("ASR", 0x47);
AddSing8("CLR", 0x4f);
AddSing8("COM", 0x43);
AddSing8("DEC", 0x4a);
AddSing8("INC", 0x4c);
AddSing8("LSL", 0x48);
AddSing8("LSR", 0x44);
AddSing8("NEG", 0x40);
AddSing8("ROL", 0x49);
AddSing8("ROR", 0x46);
AddSing8("TST", 0x4d);
Bit63Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Bit63OrderCnt); InstrZ=0;
AddBit63("AIM", 0x61); AddBit63("EIM", 0x65);
AddBit63("OIM", 0x62); AddBit63("TIM", 0x6b);
END
static void DeinitFields(void)
BEGIN
DestroyInstTable(InstTable);
free(FixedOrders);
free(RelOrders);
free(ALU8Orders);
free(ALU16Orders);
free(Sing8Orders);
free(Bit63Orders);
END
static Boolean SplitAcc(char *Op)
BEGIN
char Ch;
Integer z;
int OpLen=strlen(Op),OpPartLen=strlen(OpPart);
Ch=OpPart[OpPartLen-1];
if ((OpLen+1==OpPartLen) AND
(strncmp(OpPart,Op,OpLen)==0) AND
((Ch=='A') OR (Ch=='B')))
BEGIN
for (z=ArgCnt; z>=1; z--) strcpy(ArgStr[z+1],ArgStr[z]);
ArgStr[1][0]=Ch; ArgStr[1][1]='\0';
OpPart[OpPartLen-1]='\0'; ArgCnt++;
END
return (Memo(Op));
END
static Boolean DecodePseudo(void)
BEGIN
return False;
END
static void MakeCode_68(void)
BEGIN
int z;
CodeLen=0; DontPrint=False; PrefCnt=0; AdrCnt=0; OpSize=0;
/* Operandengroesse festlegen */
if (*AttrPart!='\0')
switch (toupper(*AttrPart))
BEGIN
case 'B':OpSize=0; break;
case 'W':OpSize=1; break;
case 'L':OpSize=2; break;
case 'Q':OpSize=3; break;
case 'S':OpSize=4; break;
case 'D':OpSize=5; break;
case 'X':OpSize=6; break;
case 'P':OpSize=7; break;
default:
WrError(1107); return;
END
/* zu ignorierendes */
if (*OpPart=='\0') return;
/* Pseudoanweisungen */
if (DecodePseudo()) return;
if (DecodeMotoPseudo(True)) return;
if (DecodeMoto16Pseudo(OpSize,True)) return;
/* gehashtes */
if (LookupInstTable(InstTable,OpPart)) return;
/* Anweisungen ohne Argument */
/* Sonderfall : XGDX hat anderen Code bei 6301 !!!! */
if ((MomCPU==CPU6301) AND (Memo("XGDX")))
BEGIN
if (ArgCnt!=0) WrError(1110);
else
BEGIN
CodeLen=1; BAsmCode[0]=0x18;
END
return;
END
for (z=0; z<ALU8OrderCnt; z++)
if (SplitAcc(ALU8Orders[z].Name))
BEGIN
if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110);
else
BEGIN
DecodeAdr(2,ArgCnt,((ALU8Orders[z].MayImm)?MModImm:0)+MModInd+MModExt+MModDir);
if (AdrMode!=ModNone)
BEGIN
BAsmCode[PrefCnt]=
ALU8Orders[z].Code+(AdrPart << 4);
DecodeAdr(1,1,1);
if (AdrMode!=ModNone)
BEGIN
BAsmCode[PrefCnt]+=AdrPart << 6;
CodeLen=PrefCnt+1+AdrCnt;
memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
END
END
END
return;
END
for (z=0; z<Sing8OrderCnt; z++)
if (SplitAcc(Sing8Orders[z].Name))
BEGIN
if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
else
BEGIN
DecodeAdr(1,ArgCnt,MModAcc+MModExt+MModInd);
if (AdrMode!=ModNone)
BEGIN
CodeLen=PrefCnt+1+AdrCnt;
BAsmCode[PrefCnt]=Sing8Orders[z].Code+(AdrPart << 4);
memcpy(BAsmCode+1+PrefCnt,AdrVals,AdrCnt);
END
END
return;
END
if ((SplitAcc("PSH")) OR (SplitAcc("PUL")))
BEGIN
if (ArgCnt!=1) WrError(1110);
else
BEGIN
DecodeAdr(1,1,MModAcc);
if (AdrMode!=ModNone)
BEGIN
CodeLen=1; BAsmCode[0]=0x32+AdrPart;
if (Memo("PSH")) BAsmCode[0]+=4;
END
END
return;
END
WrXError(1200,OpPart);
END
static Boolean IsDef_68(void)
BEGIN
return False;
END
static void SwitchFrom_68()
BEGIN
DeinitFields();
END
static void SwitchTo_68(void)
BEGIN
TurnWords=False; ConstMode=ConstModeMoto; SetIsOccupied=False;
PCSymbol="*"; HeaderID=0x61; NOPCode=0x01;
DivideChars=","; HasAttrs=True; AttrChars=".";
ValidSegs=1<<SegCode;
Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0;
SegLimits[SegCode] = 0xffff;
MakeCode=MakeCode_68; IsDef=IsDef_68;
SwitchFrom=SwitchFrom_68; InitFields();
AddMoto16PseudoONOFF();
SetFlag(&DoPadding,DoPaddingName,False);
END
void code68_init(void)
BEGIN
CPU6800=AddCPU("6800",SwitchTo_68);
CPU6301=AddCPU("6301",SwitchTo_68);
CPU6811=AddCPU("6811",SwitchTo_68);
END
Reference in New Issue View Git Blame Copy Permalink