diff options
Diffstat (limited to 'codest7.c')
-rw-r--r-- | codest7.c | 878 |
1 files changed, 878 insertions, 0 deletions
diff --git a/codest7.c b/codest7.c new file mode 100644 index 0000000..da714f8 --- /dev/null +++ b/codest7.c @@ -0,0 +1,878 @@ +/* codest7.c */ +/*****************************************************************************/ +/* AS-Portierung */ +/* */ +/* Codegenerator SGS-Thomson ST7 */ +/* */ +/* Historie: 21. 5.1997 Grundsteinlegung */ +/* 2. 1.1999 ChkPC ersetzt */ +/* */ +/*****************************************************************************/ + +#include "stdinc.h" + +#include <ctype.h> +#include <string.h> + +#include "bpemu.h" +#include "strutil.h" +#include "nls.h" +#include "asmdef.h" +#include "asmsub.h" +#include "asmpars.h" +#include "codepseudo.h" +#include "codevars.h" + + +typedef struct + { + char *Name; + Word Code; + } FixedOrder; + +typedef struct + { + char *Name; + Word Code; + Boolean MayImm; + } AriOrder; + + +#define FixedOrderCnt 11 +#define AriOrderCnt 8 +#define RMWOrderCnt 13 +#define RelOrderCnt 20 + + +#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 ModIX 3 +#define MModIX (1l << ModIX) +#define ModIX8 4 +#define MModIX8 (1l << ModIX8) +#define ModIX16 5 +#define MModIX16 (1l << ModIX16) +#define ModIY 6 +#define MModIY (1l << ModIY) +#define ModIY8 7 +#define MModIY8 (1l << ModIY8) +#define ModIY16 8 +#define MModIY16 (1l << ModIY16) +#define ModIAbs8 9 +#define MModIAbs8 (1l << ModIAbs8) +#define ModIAbs16 10 +#define MModIAbs16 (1l << ModIAbs16) +#define ModIXAbs8 11 +#define MModIXAbs8 (1l << ModIXAbs8) +#define ModIXAbs16 12 +#define MModIXAbs16 (1l << ModIXAbs16) +#define ModIYAbs8 13 +#define MModIYAbs8 (1l << ModIYAbs8) +#define ModIYAbs16 14 +#define MModIYAbs16 (1l << ModIYAbs16) +#define ModA 15 +#define MModA (1l << ModA) +#define ModX 16 +#define MModX (1l << ModX) +#define ModY 17 +#define MModY (1l << ModY) +#define ModS 18 +#define MModS (1l << ModS) +#define ModCCR 19 +#define MModCCR (1l << ModCCR) + + +static CPUVar CPUST7; + +static FixedOrder *FixedOrders; +static AriOrder *AriOrders; +static FixedOrder *RMWOrders; +static FixedOrder *RelOrders; + +static ShortInt AdrType; +static Byte AdrPart,OpSize,PrefixCnt; +static Byte AdrVals[3]; + +/*--------------------------------------------------------------------------*/ + + static void AddFixed(char *NName, Byte NCode) +BEGIN + if (InstrZ>=FixedOrderCnt) exit(255); + FixedOrders[InstrZ].Name=NName; + FixedOrders[InstrZ++].Code=NCode; +END + + static void AddAri(char *NName, Byte NCode, Boolean NMay) +BEGIN + if (InstrZ>=AriOrderCnt) exit(255); + AriOrders[InstrZ].Name=NName; + AriOrders[InstrZ].Code=NCode; + AriOrders[InstrZ++].MayImm=NMay; +END + + static void AddRMW(char *NName, Byte NCode) +BEGIN + if (InstrZ>=RMWOrderCnt) exit(255); + RMWOrders[InstrZ].Name=NName; + RMWOrders[InstrZ++].Code=NCode; +END + + static void AddRel(char *NName, Byte NCode) +BEGIN + if (InstrZ>=RelOrderCnt) exit(255); + RelOrders[InstrZ].Name=NName; + RelOrders[InstrZ++].Code=NCode; +END + + static void InitFields(void) +BEGIN + InstrZ=0; FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); + AddFixed("HALT" ,0x8e); AddFixed("IRET" ,0x80); AddFixed("NOP" ,0x9d); + AddFixed("RCF" ,0x98); AddFixed("RET" ,0x81); AddFixed("RIM" ,0x9a); + AddFixed("RSP" ,0x9c); AddFixed("SCF" ,0x99); AddFixed("SIM" ,0x9b); + AddFixed("TRAP" ,0x83); AddFixed("WFI" ,0x8f); + + InstrZ=0; AriOrders=(AriOrder *) malloc(sizeof(AriOrder)*AriOrderCnt); + AddAri("ADC" ,0x09,True ); AddAri("ADD" ,0x0b,True ); AddAri("AND" ,0x04,True ); + AddAri("BCP" ,0x05,True ); AddAri("OR" ,0x0a,True ); AddAri("SBC" ,0x02,True ); + AddAri("SUB" ,0x00,True ); AddAri("XOR" ,0x08,True ); + + InstrZ=0; RMWOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*RMWOrderCnt); + AddRMW("CLR" ,0x0f); AddRMW("CPL" ,0x03); AddRMW("DEC" ,0x0a); + AddRMW("INC" ,0x0c); AddRMW("NEG" ,0x00); AddRMW("RLC" ,0x09); + AddRMW("RRC" ,0x06); AddRMW("SLA" ,0x08); AddRMW("SLL" ,0x08); + AddRMW("SRA" ,0x07); AddRMW("SRL" ,0x04); AddRMW("SWAP",0x0e); + AddRMW("TNZ" ,0x0d); + + InstrZ=0; RelOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*RelOrderCnt); + AddRel("CALLR",0xad); AddRel("JRA" ,0x20); AddRel("JRC" ,0x25); + AddRel("JREQ" ,0x27); AddRel("JRF" ,0x21); AddRel("JRH" ,0x29); + AddRel("JRIH" ,0x2f); AddRel("JRIL" ,0x2e); AddRel("JRM" ,0x2d); + AddRel("JRMI" ,0x2b); AddRel("JRNC" ,0x24); AddRel("JRNE" ,0x26); + AddRel("JRNH" ,0x28); AddRel("JRNM" ,0x2c); AddRel("JRPL" ,0x2a); + AddRel("JRT" ,0x20); AddRel("JRUGE",0x24); AddRel("JRUGT",0x22); + AddRel("JRULE",0x23); AddRel("JRULT",0x25); +END + + static void DeinitFields(void) +BEGIN + free(FixedOrders); + free(AriOrders); + free(RMWOrders); + free(RelOrders); +END + +/*--------------------------------------------------------------------------*/ + + static void AddPrefix(Byte Pref) +BEGIN + BAsmCode[PrefixCnt++]=Pref; +END + + static void DecideSize(LongInt Mask, char *Asc, LongInt Type1, LongInt Type2, Byte Part1, Byte Part2) +BEGIN + enum {None,I8,I16} Size; + Word Value; + Boolean OK; + int l=strlen(Asc); + + if ((l>=3) AND (Asc[l-2]=='.')) + BEGIN + if (toupper(Asc[l-1])=='B') + BEGIN + Size=I8; Asc[l-2]='\0'; + END + else if (toupper(Asc[l-1])=='W') + BEGIN + Size=I16; Asc[l-2]='\0'; + END + else Size=None; + END + else Size=None; + + if (Size==I8) Value=EvalIntExpression(Asc,UInt8,&OK); + else Value=EvalIntExpression(Asc,Int16,&OK); + + if (OK) + if ((Size==I8) OR (((Mask & (1l << Type1))!=0) AND (Size==None) AND (Hi(Value)==0))) + BEGIN + AdrVals[0]=Lo(Value); AdrCnt=1; + AdrPart=Part1; AdrType=Type1; + END + else + BEGIN + AdrVals[0]=Hi(Value); AdrVals[1]=Lo(Value); AdrCnt=2; + AdrPart=Part2; AdrType=Type2; + END +END + + static void DecideASize(LongInt Mask, char *Asc, LongInt Type1, LongInt Type2, Byte Part1, Byte Part2) +BEGIN + Boolean I16; + Boolean OK; + int l=strlen(Asc); + + if ((l>=3) AND (Asc[l-2]=='.') AND (toupper(Asc[l-1])=='W')) + BEGIN + I16=True; Asc[l-2]='\0'; + END + else if (((Mask & (1l << Type1)))==0) I16=True; + else I16=False; + + AdrVals[0]=EvalIntExpression(Asc,UInt8,&OK); + if (OK) + BEGIN + AdrCnt=1; + if (I16) + BEGIN + AdrPart=Part2; AdrType=Type2; + END + else + BEGIN + AdrPart=Part1; AdrType=Type1; + END + END +END + + static void ChkAdr(LongInt Mask) +BEGIN + if ( (AdrType!=ModNone) AND ((Mask & (1l << AdrType))==0) ) + BEGIN + WrError(1350); AdrType=ModNone; AdrCnt=0; + END +END + + static void DecodeAdr(char *Asc_O, LongInt Mask) +BEGIN + Boolean OK,YReg; + String Asc,Asc2; + char *p; + + strmaxcpy(Asc,Asc_O,255); + + AdrType=ModNone; AdrCnt=0; + + /* Register ? */ + + if (strcasecmp(Asc,"A")==0) + BEGIN + AdrType=ModA; ChkAdr(Mask); return; + END + + if (strcasecmp(Asc,"X")==0) + BEGIN + AdrType=ModX; ChkAdr(Mask); return; + END + + if (strcasecmp(Asc,"Y")==0) + BEGIN + AdrType=ModY; AddPrefix(0x90); ChkAdr(Mask); return; + END + + if (strcasecmp(Asc,"S")==0) + BEGIN + AdrType=ModS; ChkAdr(Mask); return; + END + + if (strcasecmp(Asc,"CC")==0) + BEGIN + AdrType=ModCCR; ChkAdr(Mask); return; + END + + /* immediate ? */ + + if (*Asc=='#') + BEGIN + AdrVals[0]=EvalIntExpression(Asc+1,Int8,&OK); + if (OK) + BEGIN + AdrType=ModImm; AdrPart=0xa; AdrCnt=1; + END + ChkAdr(Mask); return; + END + + /* speicherindirekt ? */ + + if ((*Asc=='[') AND (Asc[strlen(Asc)-1]==']')) + BEGIN + strcpy(Asc,Asc+1); Asc[strlen(Asc)-1]='\0'; + DecideASize(Mask,Asc,ModIAbs8,ModIAbs16,0xb,0xc); + if (AdrType!=ModNone) AddPrefix(0x92); + ChkAdr(Mask); return; + END + + /* sonstwie indirekt ? */ + + if (IsIndirect(Asc)) + BEGIN + strcpy(Asc,Asc+1); Asc[strlen(Asc)-1]='\0'; + + /* ein oder zwei Argumente ? */ + + p=QuotPos(Asc,','); + if (p==Nil) + BEGIN + AdrPart=0xf; + if (strcasecmp(Asc,"X")==0) AdrType=ModIX; + else if (strcasecmp(Asc,"Y")==0) + BEGIN + AdrType=ModIY; AddPrefix(0x90); + END + else WrXError(1445,Asc); + ChkAdr(Mask); return; + END + + strmaxcpy(Asc2,p+1,255); *p='\0'; + + if (strcasecmp(Asc,"X")==0) + BEGIN + strmaxcpy(Asc,Asc2,255); YReg=False; + END + else if (strcasecmp(Asc2,"X")==0) YReg=False; + else if (strcasecmp(Asc,"Y")==0) + BEGIN + strmaxcpy(Asc,Asc2,255); YReg=True; + END + else if (strcasecmp(Asc2,"Y")==0) YReg=True; + else + BEGIN + WrError(1350); return; + END + + /* speicherindirekt ? */ + + if ((*Asc=='[') AND (Asc[strlen(Asc)-1]==']')) + BEGIN + strcpy(Asc,Asc+1); Asc[strlen(Asc)-1]='\0'; + if (YReg) + BEGIN + DecideASize(Mask,Asc,ModIYAbs8,ModIYAbs16,0xe,0xd); + if (AdrType!=ModNone) AddPrefix(0x91); + END + else + BEGIN + DecideASize(Mask,Asc,ModIXAbs8,ModIXAbs16,0xe,0xd); + if (AdrType!=ModNone) AddPrefix(0x92); + END + END + else + BEGIN + if (YReg) DecideSize(Mask,Asc,ModIY8,ModIY16,0xe,0xd); + else DecideSize(Mask,Asc,ModIX8,ModIX16,0xe,0xd); + if ((AdrType!=ModNone) AND (YReg)) AddPrefix(0x90); + END + + ChkAdr(Mask); return; + END + + /* dann absolut */ + + DecideSize(Mask,Asc,ModAbs8,ModAbs16,0xb,0xc); + + ChkAdr(Mask); +END + +/*--------------------------------------------------------------------------*/ + + static Boolean DecodePseudo(void) +BEGIN + return False; +END + + static void MakeCode_ST7(void) +BEGIN + Integer AdrInt; + int z; + LongInt Mask; + Boolean OK; + + CodeLen=0; DontPrint=False; OpSize=1; PrefixCnt=0; + + /* zu ignorierendes */ + + if (Memo("")) return; + + /* Attribut verarbeiten */ + + 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 + + /* Pseudoanweisungen */ + + if (DecodePseudo()) return; + + if (DecodeMotoPseudo(True)) return; + if (DecodeMoto16Pseudo(OpSize,True)) return; + + /* ohne Argument */ + + for (z=0; z<FixedOrderCnt; z++) + if (Memo(FixedOrders[z].Name)) + BEGIN + if (ArgCnt!=0) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + BAsmCode[PrefixCnt]=FixedOrders[z].Code; CodeLen=PrefixCnt+1; + END + return; + END + + /* Datentransfer */ + + if (Memo("LD")) + BEGIN + if (ArgCnt!=2) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + DecodeAdr(ArgStr[1],MModA+MModX+MModY+MModS+ + MModImm+MModAbs8+MModAbs16+MModIX+MModIX8+MModIX16+MModIY+ + MModIY8+MModIY16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16+ + MModIYAbs8+MModIYAbs16); + + switch (AdrType) + BEGIN + case ModA: + DecodeAdr(ArgStr[2],MModImm+MModAbs8+MModAbs16+MModIX+MModIX8+MModIX16+MModIY+ + MModIY8+MModIY16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16+ + MModIYAbs8+MModIYAbs16+MModX+MModY+MModS); + switch (AdrType) + BEGIN + case ModX: + case ModY: + BAsmCode[PrefixCnt]=0x9f; CodeLen=PrefixCnt+1; + break; + case ModS: + BAsmCode[PrefixCnt]=0x9e; CodeLen=PrefixCnt+1; + break; + default: + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x06+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + break; + case ModX: + DecodeAdr(ArgStr[2],MModImm+MModAbs8+MModAbs16+MModIX+MModIX8+ + MModIX16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16+ + MModA+MModY+MModS); + switch (AdrType) + BEGIN + case ModA: + BAsmCode[PrefixCnt]=0x97; CodeLen=PrefixCnt+1; + break; + case ModY: + BAsmCode[0]=0x93; CodeLen=1; + break; + case ModS: + BAsmCode[PrefixCnt]=0x96; CodeLen=PrefixCnt+1; + break; + default: + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x0e + (AdrPart << 4); /* ANSI :-O */ + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + break; + case ModY: + PrefixCnt=0; + DecodeAdr(ArgStr[2],MModImm+MModAbs8+MModAbs16+MModIY+MModIY8+ + MModIY16+MModIAbs8+MModIAbs16+MModIYAbs8+MModIYAbs16+ + MModA+MModX+MModS); + switch (AdrType) + BEGIN + case ModA: + AddPrefix(0x90); BAsmCode[PrefixCnt]=0x97; CodeLen=PrefixCnt+1; + break; + case ModX: + AddPrefix(0x90); BAsmCode[PrefixCnt]=0x93; CodeLen=PrefixCnt+1; + break; + case ModS: + AddPrefix(0x90); BAsmCode[PrefixCnt]=0x96; CodeLen=PrefixCnt+1; + break; + default: + if (AdrType!=ModNone) + BEGIN + if (PrefixCnt==0) AddPrefix(0x90); + if (BAsmCode[0]==0x92) BAsmCode[0]--; + BAsmCode[PrefixCnt]=0x0e + (AdrPart << 4); /* ANSI :-O */ + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + break; + case ModS: + DecodeAdr(ArgStr[2],MModA+MModX+MModY); + switch (AdrType) + BEGIN + case ModA: + BAsmCode[PrefixCnt]=0x95; CodeLen=PrefixCnt+1; + break; + case ModX: + case ModY: + BAsmCode[PrefixCnt]=0x94; CodeLen=PrefixCnt+1; + break; + END + break; + default: + if (AdrType!=ModNone) + BEGIN + PrefixCnt=0; DecodeAdr(ArgStr[2],MModA+MModX+MModY); + switch (AdrType) + BEGIN + case ModA: + Mask=MModAbs8+MModAbs16+MModIX+MModIX8+MModIX16+MModIY+ + MModIY8+MModIY16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16+ + MModIYAbs8+MModIYAbs16; + DecodeAdr(ArgStr[1],Mask); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x07+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + break; + case ModX: + DecodeAdr(ArgStr[1],MModAbs8+MModAbs16+MModIX+MModIX8+ + MModIX16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x0f+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + break; + case ModY: + PrefixCnt=0; + DecodeAdr(ArgStr[1],MModAbs8+MModAbs16+MModIY+MModIY8+ + MModIY16+MModIAbs8+MModIAbs16+MModIYAbs8+MModIYAbs16); + if (AdrType!=ModNone) + BEGIN + if (PrefixCnt==0) AddPrefix(0x90); + if (BAsmCode[0]==0x92) BAsmCode[0]--; + BAsmCode[PrefixCnt]=0x0f+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + break; + END + END + END + END + return; + END + + if ((Memo("PUSH")) OR (Memo("POP"))) + BEGIN + if (ArgCnt!=1) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + DecodeAdr(ArgStr[1],MModA+MModX+MModY+MModCCR); + if (AdrType!=ModNone) + BEGIN + switch (AdrType) + BEGIN + case ModA: BAsmCode[PrefixCnt]=0x84; break; + case ModX: + case ModY: BAsmCode[PrefixCnt]=0x85; break; + case ModCCR: BAsmCode[PrefixCnt]=0x86; break; + END + if (Memo("PUSH")) BAsmCode[PrefixCnt]+=4; + CodeLen=PrefixCnt+1; + END + END + return; + END + + /* Arithmetik */ + + if (Memo("CP")) + BEGIN + if (ArgCnt!=2) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + DecodeAdr(ArgStr[1],MModA+MModX+MModY); + switch (AdrType) + BEGIN + case ModA: + Mask=MModImm+MModAbs8+MModAbs16+MModIX+MModIX8+MModIX16+MModIY+ + MModIY8+MModIY16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16+ + MModIYAbs8+MModIYAbs16; + DecodeAdr(ArgStr[2],Mask); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x01+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + break; + case ModX: + DecodeAdr(ArgStr[2],MModImm+MModAbs8+MModAbs16+MModIX+MModIX8+ + MModIX16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x03+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + break; + case ModY: + PrefixCnt=0; + DecodeAdr(ArgStr[2],MModImm+MModAbs8+MModAbs16+MModIY+MModIY8+ + MModIY16+MModIAbs8+MModIAbs16+MModIYAbs8+MModIYAbs16); + if (AdrType!=ModNone) + BEGIN + if (PrefixCnt==0) AddPrefix(0x90); + if (BAsmCode[0]==0x92) BAsmCode[0]--; + BAsmCode[PrefixCnt]=0x03+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + break; + END + END + return; + END + + for (z=0; z<AriOrderCnt; z++) + if (Memo(AriOrders[z].Name)) + BEGIN + if (ArgCnt!=2) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + DecodeAdr(ArgStr[1],MModA); + if (AdrType==ModA) + BEGIN + Mask=MModAbs8+MModAbs16+MModIX+MModIX8+MModIX16+MModIY+ + MModIY8+MModIY16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16+ + MModIYAbs8+MModIYAbs16; + if (AriOrders[z].MayImm) Mask+=MModImm; + DecodeAdr(ArgStr[2],Mask); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=AriOrders[z].Code+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + END + return; + END + + for (z=0; z<RMWOrderCnt; z++) + if (Memo(RMWOrders[z].Name)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + DecodeAdr(ArgStr[1],MModA+MModX+MModY+MModAbs8+MModIX+MModIX8+ + MModIY+MModIY8+MModIAbs8+MModIXAbs8+MModIYAbs8); + switch (AdrType) + BEGIN + case ModA: + BAsmCode[PrefixCnt]=0x40+RMWOrders[z].Code; CodeLen=PrefixCnt+1; + break; + case ModX: + case ModY: + BAsmCode[PrefixCnt]=0x50+RMWOrders[z].Code; CodeLen=PrefixCnt+1; + break; + default: + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=RMWOrders[z].Code+((AdrPart-8) << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + END + return; + END + + if (Memo("MUL")) + BEGIN + if (ArgCnt!=2) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + DecodeAdr(ArgStr[2],MModA); + if (AdrType!=ModNone) + BEGIN + DecodeAdr(ArgStr[1],MModX+MModY); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x42; CodeLen=PrefixCnt+1; + END + END + END + return; + END + + /* Bitbefehle */ + + if ((Memo("BRES")) OR (Memo("BSET"))) + BEGIN + if (ArgCnt!=2) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else if (*ArgStr[2]!='#') WrError(1350); + else + BEGIN + z=EvalIntExpression(ArgStr[2]+1,UInt3,&OK); + if (OK) + BEGIN + DecodeAdr(ArgStr[1],MModAbs8+MModIAbs8); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x10+Ord(Memo("BRES"))+(z << 1); + memcpy(BAsmCode+1+PrefixCnt,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + END + return; + END + + if ((Memo("BTJF")) OR (Memo("BTJT"))) + BEGIN + if (ArgCnt!=3) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else if (*ArgStr[2]!='#') WrError(1350); + else + BEGIN + z=EvalIntExpression(ArgStr[2]+1,UInt3,&OK); + if (OK) + BEGIN + DecodeAdr(ArgStr[1],MModAbs8+MModIAbs8); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x00+Ord(Memo("BTJF"))+(z << 1); + memcpy(BAsmCode+1+PrefixCnt,AdrVals,AdrCnt); + AdrInt=EvalIntExpression(ArgStr[3],UInt16,&OK)-(EProgCounter()+PrefixCnt+1+AdrCnt); + if (OK) + if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370); + else + BEGIN + BAsmCode[PrefixCnt+1+AdrCnt]=AdrInt & 0xff; + CodeLen=PrefixCnt+1+AdrCnt+1; + END + END + END + END + return; + END + + /* Spruenge */ + + if ((Memo("JP")) OR (Memo("CALL"))) + BEGIN + if (ArgCnt!=1) WrError(1110); + else if (*AttrPart!='\0') WrError(1100); + else + BEGIN + Mask=MModAbs8+MModAbs16+MModIX+MModIX8+MModIX16+MModIY+ + MModIY8+MModIY16+MModIAbs8+MModIAbs16+MModIXAbs8+MModIXAbs16+ + MModIYAbs8+MModIYAbs16; + DecodeAdr(ArgStr[1],Mask); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=0x0c+Ord(Memo("CALL"))+(AdrPart << 4); + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + return; + END + + for (z=0; z<RelOrderCnt; z++) + if (Memo(RelOrders[z].Name)) + BEGIN + if (*AttrPart!='\0') WrError(1100); + else if (ArgCnt!=1) WrError(1110); + else if (*ArgStr[1]=='[') + BEGIN + DecodeAdr(ArgStr[1],MModIAbs8); + if (AdrType!=ModNone) + BEGIN + BAsmCode[PrefixCnt]=RelOrders[z].Code; + memcpy(BAsmCode+PrefixCnt+1,AdrVals,AdrCnt); + CodeLen=PrefixCnt+1+AdrCnt; + END + END + else + BEGIN + AdrInt=EvalIntExpression(ArgStr[1],UInt16,&OK)-(EProgCounter()+2); + if (OK) + if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370); + else + BEGIN + BAsmCode[0]=RelOrders[z].Code; BAsmCode[1]=AdrInt & 0xff; + CodeLen=2; + END + END + return; + END + + /* nix gefunden */ + + WrXError(1200,OpPart); +END + + static Boolean IsDef_ST7(void) +BEGIN + return False; +END + + static void SwitchFrom_ST7(void) +BEGIN + DeinitFields(); +END + + static void SwitchTo_ST7(void) +BEGIN + TurnWords=False; ConstMode=ConstModeMoto; SetIsOccupied=False; + + PCSymbol="PC"; HeaderID=0x33; NOPCode=0x9d; + DivideChars=","; HasAttrs=True; AttrChars="."; + + ValidSegs=1<<SegCode; + Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0; + SegLimits[SegCode] = 0xffff; + + MakeCode=MakeCode_ST7; IsDef=IsDef_ST7; + SwitchFrom=SwitchFrom_ST7; InitFields(); + AddMoto16PseudoONOFF(); + + SetFlag(&DoPadding,DoPaddingName,False); +END + + void codest7_init(void) +BEGIN + CPUST7=AddCPU("ST7",SwitchTo_ST7); +END + + |