diff options
Diffstat (limited to 'codest9.c')
| -rw-r--r-- | codest9.c | 1878 |
1 files changed, 1878 insertions, 0 deletions
diff --git a/codest9.c b/codest9.c new file mode 100644 index 0000000..bf54690 --- /dev/null +++ b/codest9.c @@ -0,0 +1,1878 @@ +/* codest9.c */ +/*****************************************************************************/ +/* AS-Portierung */ +/* */ +/* Codegenerator SGS-Thomson ST9 */ +/* */ +/* Historie: 10. 2.1997 Grundsteinlegung */ +/* 1. 7.1998 Warnungen bei is...()-Funktionen beseitigt */ +/* 2. 1.1999 ChkPC umgestellt */ +/* 30. 1.1999 Formate maschinenunabhaengig gemacht */ +/* */ +/*****************************************************************************/ + +#include "stdinc.h" +#include <ctype.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" + + +typedef struct + { + char *Name; + Word Code; + } FixedOrder; + +typedef struct + { + char *Name; + int len; + Word Code; + } ALUOrder; + + +#define WorkOfs 0xd0 + +#define ModNone (-1) +#define ModReg 0 +#define MModReg (1l << ModReg) /* Rn */ +#define ModWReg 1 +#define MModWReg (1l << ModWReg) /* rn */ +#define ModRReg 2 +#define MModRReg (1l << ModRReg) /* RRn */ +#define ModWRReg 3 +#define MModWRReg (1l << ModWRReg) /* rrn */ +#define ModIReg 4 +#define MModIReg (1l << ModIReg) /* (Rn) */ +#define ModIWReg 5 +#define MModIWReg (1l << ModIWReg) /* (rn) */ +#define ModIRReg 6 +#define MModIRReg (1l << ModIRReg) /* (RRn) */ +#define ModIWRReg 7 +#define MModIWRReg (1l << ModIWRReg) /* (rrn) */ +#define ModIncWReg 8 +#define MModIncWReg (1l << ModIncWReg) /* (rn)+ */ +#define ModIncWRReg 9 +#define MModIncWRReg (1l << ModIncWRReg) /* (rrn)+ */ +#define ModDecWRReg 10 +#define MModDecWRReg (1l << ModDecWRReg) /* -(rrn) */ +#define ModDisp8WReg 11 +#define MModDisp8WReg (1l << ModDisp8WReg) /* d8(rn) */ +#define ModDisp8WRReg 12 +#define MModDisp8WRReg (1l << ModDisp8WRReg) /* d8(rrn) */ +#define ModDisp16WRReg 13 +#define MModDisp16WRReg (1l << ModDisp16WRReg) /* d16(rrn) */ +#define ModDispRWRReg 14 +#define MModDispRWRReg (1l << ModDispRWRReg) /* rrm(rrn */ +#define ModAbs 15 +#define MModAbs (1l << ModAbs) /* NN */ +#define ModImm 16 +#define MModImm (1l << ModImm) /* #N/#NN */ +#define ModDisp8RReg 17 +#define MModDisp8RReg (1l << ModDisp8RReg) /* d8(RRn) */ +#define ModDisp16RReg 18 +#define MModDisp16RReg (1l << ModDisp16RReg) /* d16(RRn) */ + +#define FixedOrderCnt 12 +#define ALUOrderCnt 10 +#define RegOrderCnt 13 +#define Reg16OrderCnt 8 +#define Bit2OrderCnt 4 +#define Bit1OrderCnt 4 +#define ConditionCnt 20 +#define LoadOrderCnt 4 + + +static CPUVar CPUST9020,CPUST9030,CPUST9040,CPUST9050; + +static FixedOrder *FixedOrders; +static ALUOrder *ALUOrders; +static FixedOrder *RegOrders; +static FixedOrder *Reg16Orders; +static FixedOrder *Bit2Orders; +static FixedOrder *Bit1Orders; +static FixedOrder *Conditions; +static FixedOrder *LoadOrders; + +static ShortInt AdrMode,AbsSeg; +static Byte AdrPart,OpSize; +static Byte AdrVals[3]; + +static SimpProc SaveInitProc; +static LongInt DPAssume; + +/*--------------------------------------------------------------------------*/ + + static void AddFixed(char *NName, Word NCode) +BEGIN + if (InstrZ>=FixedOrderCnt) exit(255); + FixedOrders[InstrZ].Name=NName; + FixedOrders[InstrZ++].Code=NCode; +END + + static void AddALU(char *NName, Word NCode) +BEGIN + if (InstrZ>=ALUOrderCnt) exit(255); + ALUOrders[InstrZ].Name=NName; + ALUOrders[InstrZ].len=strlen(NName); + ALUOrders[InstrZ++].Code=NCode; +END + + static void AddReg(char *NName, Word NCode) +BEGIN + if (InstrZ>=RegOrderCnt) exit(255); + RegOrders[InstrZ].Name=NName; + RegOrders[InstrZ++].Code=NCode; +END + + static void AddReg16(char *NName, Word NCode) +BEGIN + if (InstrZ>=Reg16OrderCnt) exit(255); + Reg16Orders[InstrZ].Name=NName; + Reg16Orders[InstrZ++].Code=NCode; +END + + static void AddBit2(char *NName, Word NCode) +BEGIN + if (InstrZ>=Bit2OrderCnt) exit(255); + Bit2Orders[InstrZ].Name=NName; + Bit2Orders[InstrZ++].Code=NCode; +END + + static void AddBit1(char *NName, Word NCode) +BEGIN + if (InstrZ>=Bit1OrderCnt) exit(255); + Bit1Orders[InstrZ].Name=NName; + Bit1Orders[InstrZ++].Code=NCode; +END + + static void AddCondition(char *NName, Word NCode) +BEGIN + if (InstrZ>=ConditionCnt) exit(255); + Conditions[InstrZ].Name=NName; + Conditions[InstrZ++].Code=NCode; +END + + static void AddLoad(char *NName, Word NCode) +BEGIN + if (InstrZ>=LoadOrderCnt) exit(255); + LoadOrders[InstrZ].Name=NName; + LoadOrders[InstrZ++].Code=NCode; +END + + static void InitFields(void) +BEGIN + FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0; + AddFixed("CCF" ,0x0061); AddFixed("DI" ,0x0010); + AddFixed("EI" ,0x0000); AddFixed("HALT",0xbf01); + AddFixed("IRET",0x00d3); AddFixed("NOP" ,0x00ff); + AddFixed("RCF" ,0x0011); AddFixed("RET" ,0x0046); + AddFixed("SCF" ,0x0001); AddFixed("SDM" ,0x00fe); + AddFixed("SPM" ,0x00ee); AddFixed("WFI" ,0xef01); + + ALUOrders=(ALUOrder *) malloc(sizeof(ALUOrder)*ALUOrderCnt); InstrZ=0; + AddALU("ADC", 3); AddALU("ADD", 4); AddALU("AND", 1); + AddALU("CP" , 9); AddALU("OR" , 0); AddALU("SBC", 2); + AddALU("SUB", 5); AddALU("TCM", 8); AddALU("TM" ,10); + AddALU("XOR", 6); + + RegOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*RegOrderCnt); InstrZ=0; + AddReg("CLR" ,0x90); AddReg("CPL" ,0x80); AddReg("DA" ,0x70); + AddReg("DEC" ,0x40); AddReg("INC" ,0x50); AddReg("POP" ,0x76); + AddReg("POPU",0x20); AddReg("RLC" ,0xb0); AddReg("ROL" ,0xa0); + AddReg("ROR" ,0xc0); AddReg("RRC" ,0xd0); AddReg("SRA" ,0xe0); + AddReg("SWAP",0xf0); + + Reg16Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*Reg16OrderCnt); InstrZ=0; + AddReg16("DECW" ,0xcf); AddReg16("EXT" ,0xc6); + AddReg16("INCW" ,0xdf); AddReg16("POPUW",0xb7); + AddReg16("POPW" ,0x75); AddReg16("RLCW" ,0x8f); + AddReg16("RRCW" ,0x36); AddReg16("SRAW" ,0x2f); + + Bit2Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*Bit2OrderCnt); InstrZ=0; + AddBit2("BAND",0x1f); AddBit2("BLD" ,0xf2); + AddBit2("BOR" ,0x0f); AddBit2("BXOR",0x6f); + + Bit1Orders=(FixedOrder *) malloc(sizeof(FixedOrder)*Bit1OrderCnt); InstrZ=0; + AddBit1("BCPL",0x6f); AddBit1("BRES" ,0x1f); + AddBit1("BSET",0x0f); AddBit1("BTSET",0xf2); + + Conditions=(FixedOrder *) malloc(sizeof(FixedOrder)*ConditionCnt); InstrZ=0; + AddCondition("F" ,0x0); AddCondition("T" ,0x8); + AddCondition("C" ,0x7); AddCondition("NC" ,0xf); + AddCondition("Z" ,0x6); AddCondition("NZ" ,0xe); + AddCondition("PL" ,0xd); AddCondition("MI" ,0x5); + AddCondition("OV" ,0x4); AddCondition("NOV" ,0xc); + AddCondition("EQ" ,0x6); AddCondition("NE" ,0xe); + AddCondition("GE" ,0x9); AddCondition("LT" ,0x1); + AddCondition("GT" ,0xa); AddCondition("LE" ,0x2); + AddCondition("UGE" ,0xf); AddCondition("UL" ,0x7); + AddCondition("UGT" ,0xb); AddCondition("ULE" ,0x3); + + LoadOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*LoadOrderCnt); InstrZ=0; + AddLoad("LDPP",0x00); AddLoad("LDDP",0x10); + AddLoad("LDPD",0x01); AddLoad("LDDD",0x11); +END + + static void DeinitFields(void) +BEGIN + free(FixedOrders); + free(ALUOrders); + free(RegOrders); + free(Reg16Orders); + free(Bit2Orders); + free(Bit1Orders); + free(Conditions); + free(LoadOrders); +END + +/*--------------------------------------------------------------------------*/ + + static Boolean DecodeReg(char *Asc_O, Byte *Erg, Byte *Size) +BEGIN + Boolean Res; + char *Asc; + + Asc=Asc_O; + + if (strlen(Asc)<2) return False; + if (*Asc!='r') return False; Asc++; + if (*Asc=='r') + BEGIN + if (strlen(Asc)<2) return False; + *Size=1; Asc++; + END + else *Size=0; + + *Erg=ConstLongInt(Asc,&Res); + if ((NOT Res) OR (*Erg>15)) return False; + if ((*Size==1) AND (Odd(*Erg))) return False; + + return True; +END + + static void ChkAdr(LongWord Mask) +BEGIN + if ((AdrMode!=ModNone) AND (((1l << AdrMode) & Mask)==0)) + BEGIN + WrError(1350); AdrMode=ModNone; AdrCnt=0; + END +END + + static void DecodeAdr(char *Asc_O, LongWord Mask) +BEGIN + Word AdrWord; + int level; + Byte flg,Size; + Boolean OK; + String Reg,Asc; + char *p; + + AdrMode=ModNone; AdrCnt=0; + strmaxcpy(Asc,Asc_O,255); + + /* immediate */ + + if (*Asc=='#') + BEGIN + switch (OpSize) + BEGIN + case 0: + AdrVals[0]=EvalIntExpression(Asc+1,Int8,&OK); + break; + case 1: + AdrWord=EvalIntExpression(Asc+1,Int16,&OK); + AdrVals[0]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord); + break; + END + if (OK) + BEGIN + AdrMode=ModImm; AdrCnt=OpSize+1; + END + ChkAdr(Mask); return; + END + + /* Arbeitsregister */ + + if (DecodeReg(Asc,&AdrPart,&Size)) + BEGIN + if (Size==0) + if ((Mask & MModWReg)!=0) AdrMode=ModWReg; + else + BEGIN + AdrVals[0]=WorkOfs+AdrPart; AdrCnt=1; AdrMode=ModReg; + END + else + if ((Mask & MModWRReg)!=0) AdrMode=ModWRReg; + else + BEGIN + AdrVals[0]=WorkOfs+AdrPart; AdrCnt=1; AdrMode=ModRReg; + END + ChkAdr(Mask); return; + END + + /* Postinkrement */ + + if (Asc[strlen(Asc)-1]=='+') + BEGIN + if ((*Asc!='(') OR (Asc[strlen(Asc)-2]!=')')) WrError(1350); + else + BEGIN + strcpy(Asc,Asc+1); Asc[strlen(Asc)-2]='\0'; + if (NOT DecodeReg(Asc,&AdrPart,&Size)) WrXError(1445,Asc); + AdrMode=(Size==0) ? ModIncWReg : ModIncWRReg; + END + ChkAdr(Mask); return; + END + + /* Predekrement */ + + if ((*Asc=='-') AND (Asc[1]=='(') AND (Asc[strlen(Asc)-1]==')')) + BEGIN + strcpy(Reg,Asc+2); Reg[strlen(Reg)-1]='\0'; + if (DecodeReg(Reg,&AdrPart,&Size)) + BEGIN + if (Size==0) WrError(1350); else AdrMode=ModDecWRReg; + ChkAdr(Mask); return; + END + END + + /* indirekt<->direkt */ + + if ((Asc[strlen(Asc)-1]!=')') OR (strlen(Asc)<3)) + BEGIN + OK=False; p=Asc; + END + else + BEGIN + level=0; p=Asc+strlen(Asc)-2; flg=0; + while ((p>=Asc) AND (level>=0)) + BEGIN + switch (*p) + BEGIN + case '(': if (flg==0) level--; break; + case ')': if (flg==0) level++; break; + case '\'': if (((flg & 2)==0)) flg^=1; break; + case '"': if (((flg & 1)==0)) flg^=2; break; + END + p--; + END + OK=(level==-1) AND ((p<Asc) OR ((*p=='.') OR (*p=='_') OR (isdigit(((unsigned int)*p)&0xff)) OR (isalpha(((unsigned int)*p)&0xff)))); + END + + /* indirekt */ + + if (OK) + BEGIN + strcpy(Reg,p+2); Reg[strlen(Reg)-1]='\0'; p[1]='\0'; + if (DecodeReg(Reg,&AdrPart,&Size)) + if (Size==0) /* d(r) */ + BEGIN + AdrVals[0]=EvalIntExpression(Asc,Int8,&OK); + if (OK) + BEGIN + if (((Mask & MModIWReg)!=0) AND (AdrVals[0]==0)) AdrMode=ModIWReg; + else if (((Mask & MModIReg)!=0) AND (AdrVals[0]==0)) + BEGIN + AdrVals[0]=WorkOfs+AdrPart; AdrMode=ModIReg; AdrCnt=1; + END + else + BEGIN + AdrMode=ModDisp8WReg; AdrCnt=1; + END + END + END + else /* ...(rr) */ + BEGIN + if (DecodeReg(Asc,AdrVals,&Size)) + BEGIN /* rr(rr) */ + if (Size!=1) WrError(1350); + else + BEGIN + AdrMode=ModDispRWRReg; AdrCnt=1; + END + END + else + BEGIN /* d(rr) */ + AdrWord=EvalIntExpression(Asc,Int16,&OK); + if ((AdrWord==0) AND ((Mask & (MModIRReg+MModIWRReg))!=0)) + BEGIN + if (((Mask & MModIWRReg)!=0)) AdrMode=ModIWRReg; + else + BEGIN + AdrMode=ModIRReg; AdrVals[0]=AdrPart+WorkOfs; AdrCnt=1; + END + END + else if ((AdrWord<0x100) AND ((Mask & (MModDisp8WRReg+MModDisp8RReg))!=0)) + BEGIN + if (((Mask & MModDisp8WRReg)!=0)) + BEGIN + AdrVals[0]=Lo(AdrWord); AdrCnt=1; AdrMode=ModDisp8WRReg; + END + else + BEGIN + AdrVals[0]=AdrPart+WorkOfs; AdrVals[1]=Lo(AdrWord); + AdrCnt=2; AdrMode=ModDisp8RReg; + END + END + else if (((Mask & MModDisp16WRReg)!=0)) + BEGIN + AdrVals[0]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord); + AdrCnt=2; AdrMode=ModDisp16WRReg; + END + else + BEGIN + AdrVals[0]=AdrPart+WorkOfs; + AdrVals[2]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord); + AdrCnt=3; AdrMode=ModDisp16RReg; + END + END + END + + else /* ...(RR) */ + BEGIN + AdrWord=EvalIntExpression(Reg,UInt9,&OK); + if (((TypeFlag & (1 << SegReg))==0)) WrError(1350); + else if (AdrWord<0xff) + BEGIN + AdrVals[0]=Lo(AdrWord); + AdrWord=EvalIntExpression(Asc,Int8,&OK); + if (AdrWord!=0) WrError(1320); + else + BEGIN + AdrCnt=1; AdrMode=ModIReg; + END + END + else if ((AdrWord>0x1ff) OR (Odd(AdrWord))) WrError(1350); + else + BEGIN + AdrVals[0]=Lo(AdrWord); + AdrWord=EvalIntExpression(Asc,Int16,&OK); + if ((AdrWord==0) AND ((Mask & MModIRReg)!=0)) + BEGIN + AdrCnt=1; AdrMode=ModIRReg; + END + else if ((AdrWord<0x100) AND ((Mask & MModDisp8RReg)!=0)) + BEGIN + AdrVals[1]=Lo(AdrWord); AdrCnt=2; AdrMode=ModDisp8RReg; + END + else + BEGIN + AdrVals[2]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord); + AdrCnt=3; AdrMode=ModDisp16RReg; + END + END + END + ChkAdr(Mask); return; + END + + /* direkt */ + + AdrWord=EvalIntExpression(Asc,UInt16,&OK); + if (OK) + if (((TypeFlag & (1 << SegReg)))==0) + BEGIN + AdrMode=ModAbs; + AdrVals[0]=Hi(AdrWord); AdrVals[1]=Lo(AdrWord); + AdrCnt=2; ChkSpace(AbsSeg); + END + else if (AdrWord<0xff) + BEGIN + AdrMode=ModReg; AdrVals[0]=Lo(AdrWord); AdrCnt=1; + END + else if ((AdrWord>0x1ff) OR (Odd(AdrWord))) WrError(1350); + else + BEGIN + AdrMode=ModRReg; AdrVals[0]=Lo(AdrWord); AdrCnt=1; + END + + ChkAdr(Mask); +END + + static Boolean SplitBit(char *Asc, Byte *Erg) +BEGIN + char *p; + Integer val; + Boolean OK,Inv; + + p=RQuotPos(Asc,'.'); + if ((p==Nil) OR (p==Asc+strlen(Asc)+1)) + BEGIN + if (*Asc=='!') + BEGIN + Inv=True; strcpy(Asc,Asc+1); + END + else Inv=False; + val=EvalIntExpression(Asc,UInt8,&OK); + if (OK) + BEGIN + *Erg=val & 15; if (Inv) *Erg^=1; + sprintf(Asc, "r%d", (int)(val >> 4)); + return True; + END + return False; + END + + if (p[1]=='!') + *Erg=1+(EvalIntExpression(p+2,UInt3,&OK) << 1); + else + *Erg=EvalIntExpression(p+1,UInt3,&OK) << 1; + *p='\0'; + return OK; +END + +/*--------------------------------------------------------------------------*/ + + static Boolean DecodePseudo(void) +BEGIN +#define ASSUMEST9Count 1 +static ASSUMERec ASSUMEST9s[ASSUMEST9Count]= + {{"DP", &DPAssume, 0, 1, 0x0}}; + Byte Bit; + + if (Memo("REG")) + BEGIN + CodeEquate(SegReg,0,0x1ff); + return True; + END + + if (Memo("BIT")) + BEGIN + if (ArgCnt!=1) WrError(1110); + else if (SplitBit(ArgStr[1],&Bit)) + BEGIN + DecodeAdr(ArgStr[1],MModWReg); + if (AdrMode==ModWReg) + BEGIN + PushLocHandle(-1); + EnterIntSymbol(LabPart,(AdrPart << 4)+Bit,SegNone,False); + PopLocHandle(); + sprintf(ListLine,"=r%d.%s%c", (int)AdrPart, + (Odd(Bit))?"!":"", (Bit >> 1)+AscOfs); + END + END + return True; + END + + if (Memo("ASSUME")) + BEGIN + CodeASSUME(ASSUMEST9s,ASSUMEST9Count); + return True; + END + + return False; +END + + static void MakeCode_ST9(void) +BEGIN + Integer AdrInt; + int z; + Boolean OK; + Byte HReg,HPart; + Word Mask1,Mask2,AdrWord; + + CodeLen=0; DontPrint=False; OpSize=0; + AbsSeg=(DPAssume==1) ? SegData : SegCode; + + /* zu ignorierendes */ + + if (Memo("")) return; + + /* Pseudoanweisungen */ + + if (DecodePseudo()) return; + + if (DecodeIntelPseudo(True)) return; + + /* ohne Argument */ + + for (z=0; z<FixedOrderCnt; z++) + if (Memo(FixedOrders[z].Name)) + BEGIN + if (ArgCnt!=0) WrError(1110); + else + BEGIN + OK=Hi(FixedOrders[z].Code)!=0; + if (OK) BAsmCode[0]=Hi(FixedOrders[z].Code); + CodeLen=Ord(OK); + BAsmCode[CodeLen++]=Lo(FixedOrders[z].Code); + END + return; + END + + /* Datentransfer */ + + if ((Memo("LD")) OR (Memo("LDW"))) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + if (OpPart[strlen(OpPart)-1]=='W') + BEGIN + OpSize=1; Mask1=MModWRReg; Mask2=MModRReg; + END + else + BEGIN + Mask1=MModWReg; Mask2=MModReg; + END; + DecodeAdr(ArgStr[1],Mask1+Mask2+MModIWReg+MModDisp8WReg+MModIncWReg+ + MModIWRReg+MModIncWRReg+MModDecWRReg+MModDisp8WRReg+ + MModDisp16WRReg+MModDispRWRReg+MModAbs+MModIRReg); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask1+Mask2+MModIWReg+MModDisp8WReg+MModIWRReg+ + MModIncWRReg+MModDecWRReg+MModDispRWRReg+MModDisp8WRReg+ + MModDisp16WRReg+MModAbs+MModImm); + switch (AdrMode) + BEGIN + case ModWReg: + BAsmCode[0]=(HReg << 4)+8; BAsmCode[1]=WorkOfs+AdrPart; + CodeLen=2; + break; + case ModWRReg: + BAsmCode[0]=0xe3; BAsmCode[1]=(HReg << 4)+AdrPart; + CodeLen=2; + break; + case ModReg: + BAsmCode[0]=(HReg << 4)+8; BAsmCode[1]=AdrVals[0]; + CodeLen=2; + break; + case ModRReg: + BAsmCode[0]=0xef; BAsmCode[1]=AdrVals[0]; + BAsmCode[2]=HReg+WorkOfs; CodeLen=3; + break; + case ModIWReg: + if (OpSize==0) + BEGIN + BAsmCode[0]=0xe4; BAsmCode[1]=(HReg << 4)+AdrPart; + CodeLen=2; + END + else + BEGIN + BAsmCode[0]=0xa6; BAsmCode[1]=0xf0+AdrPart; + BAsmCode[2]=WorkOfs+HReg; CodeLen=3; + END + break; + case ModDisp8WReg: + BAsmCode[0]=0xb3+(OpSize*0x2b); + BAsmCode[1]=(HReg << 4)+AdrPart; + BAsmCode[2]=AdrVals[0]; CodeLen=3; + break; + case ModIWRReg: + BAsmCode[0]=0xb5+(OpSize*0x2e); + BAsmCode[1]=(HReg << 4)+AdrPart+OpSize; + CodeLen=2; + break; + case ModIncWRReg: + BAsmCode[0]=0xb4+(OpSize*0x21); + BAsmCode[1]=0xf1+AdrPart; + BAsmCode[2]=WorkOfs+HReg; CodeLen=3; + break; + case ModDecWRReg: + BAsmCode[0]=0xc2+OpSize; + BAsmCode[1]=0xf1+AdrPart; + BAsmCode[2]=WorkOfs+HReg; CodeLen=3; + break; + case ModDispRWRReg: + BAsmCode[0]=0x60; + BAsmCode[1]=(0x10*(1-OpSize))+(AdrVals[0] << 4)+AdrPart; + BAsmCode[2]=0xf0+HReg; CodeLen=3; + break; + case ModDisp8WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=0xf1+AdrPart; + BAsmCode[2]=AdrVals[0]; BAsmCode[3]=HReg+WorkOfs; + CodeLen=4; + break; + case ModDisp16WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=0xf0+AdrPart; + memcpy(BAsmCode+2,AdrVals,AdrCnt); BAsmCode[2+AdrCnt]=HReg+WorkOfs; + CodeLen=3+AdrCnt; + break; + case ModAbs: + BAsmCode[0]=0xc4+(OpSize*0x1e); + BAsmCode[1]=0xf0+AdrPart; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + CodeLen=2+AdrCnt; + break; + case ModImm: + if (OpSize==0) + BEGIN + BAsmCode[0]=(HReg << 4)+0x0c; + memcpy(BAsmCode+1,AdrVals,AdrCnt); + CodeLen=1+AdrCnt; + END + else + BEGIN + BAsmCode[0]=0xbf; BAsmCode[1]=WorkOfs+HReg; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + CodeLen=2+AdrCnt; + END + break; + END + break; + case ModReg: + case ModRReg: + HReg=AdrVals[0]; + DecodeAdr(ArgStr[2],Mask1+Mask2+MModIWReg+MModIWRReg+MModIncWRReg+ + MModDecWRReg+MModDispRWRReg+MModDisp8WRReg+MModDisp16WRReg+ + MModImm); + switch (AdrMode) + BEGIN + case ModWReg: + BAsmCode[0]=(AdrPart << 4)+0x09; BAsmCode[1]=HReg; CodeLen=2; + break; + case ModWRReg: + BAsmCode[0]=0xef; BAsmCode[1]=WorkOfs+AdrPart; + BAsmCode[2]=HReg; CodeLen=3; + break; + case ModReg: + case ModRReg: + BAsmCode[0]=0xf4-(OpSize*5); + BAsmCode[1]=AdrVals[0]; + BAsmCode[2]=HReg; CodeLen=3; + break; + case ModIWReg: + BAsmCode[0]=0xe7-(0x41*OpSize); BAsmCode[1]=0xf0+AdrPart; + BAsmCode[2]=HReg; CodeLen=3; + break; + case ModIWRReg: + BAsmCode[0]=0x72+(OpSize*12); + BAsmCode[1]=0xf1+AdrPart-OpSize; BAsmCode[2]=HReg; + CodeLen=3; + break; + case ModIncWRReg: + BAsmCode[0]=0xb4+(0x21*OpSize); + BAsmCode[1]=0xf1+AdrPart; BAsmCode[2]=HReg; + CodeLen=3; + break; + case ModDecWRReg: + BAsmCode[0]=0xc2+OpSize; + BAsmCode[1]=0xf1+AdrPart; BAsmCode[2]=HReg; + CodeLen=3; + break; + case ModDisp8WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=0xf1+AdrPart; + BAsmCode[2]=AdrVals[0]; + BAsmCode[3]=HReg; CodeLen=4; + break; + case ModDisp16WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=0xf0+AdrPart; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + BAsmCode[2+AdrCnt]=HReg; CodeLen=3+AdrCnt; + break; + case ModImm: + BAsmCode[0]=0xf5-(OpSize*0x36); + BAsmCode[1]=HReg; + memcpy(BAsmCode+2,AdrVals,2); CodeLen=2+AdrCnt; + break; + END + break; + case ModIWReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2+Mask1); + switch (AdrMode) + BEGIN + case ModWReg: + BAsmCode[0]=0xe5; BAsmCode[1]=(HReg << 4)+AdrPart; CodeLen=2; + break; + case ModWRReg: + BAsmCode[0]=0x96; BAsmCode[1]=WorkOfs+AdrPart; + BAsmCode[2]=0xf0+HReg; CodeLen=3; + break; + case ModReg: + case ModRReg: + BAsmCode[0]=0xe6-(0x50*OpSize); BAsmCode[1]=AdrVals[0]; + BAsmCode[2]=0xf0+HReg; CodeLen=3; + break; + END + break; + case ModDisp8WReg: + BAsmCode[2]=AdrVals[0]; HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask1); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + BAsmCode[0]=0xb2+(OpSize*0x2c); + BAsmCode[1]=(AdrPart << 4)+(OpSize << 4)+HReg; + CodeLen=3; + break; + END + break; + case ModIncWReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],MModIncWRReg*(1-OpSize)); + switch (AdrMode) + BEGIN + case ModIncWRReg: + BAsmCode[0]=0xd7; BAsmCode[1]=(HReg << 4)+AdrPart+1; CodeLen=2; + break; + END + break; + case ModIWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],(MModIWReg*(1-OpSize))+Mask1+Mask2+MModIWRReg+MModImm); + switch (AdrMode) + BEGIN + case ModIWReg: + BAsmCode[0]=0xb5; BAsmCode[1]=(AdrPart << 4)+HReg+1; CodeLen=2; + break; + case ModWReg: + BAsmCode[0]=0x72; BAsmCode[1]=0xf0+HReg; + BAsmCode[2]=AdrPart+WorkOfs; + CodeLen=3; + break; + case ModWRReg: + BAsmCode[0]=0xe3; BAsmCode[1]=(HReg << 4)+0x10+AdrPart; + CodeLen=2; + break; + case ModReg: + case ModRReg: + BAsmCode[0]=0x72+(OpSize*0x4c); + BAsmCode[1]=0xf0+HReg+OpSize; BAsmCode[2]=AdrVals[0]; + CodeLen=3; + break; + case ModIWRReg: + if (OpSize==0) + BEGIN + BAsmCode[0]=0x73; + BAsmCode[1]=0xf0+AdrPart; + BAsmCode[2]=WorkOfs+HReg; CodeLen=3; + END + else + BEGIN + BAsmCode[0]=0xe3; BAsmCode[1]=0x11+(HReg << 4)+AdrPart; + CodeLen=2; + END + break; + case ModImm: + BAsmCode[0]=0xf3-(OpSize*0x35); + BAsmCode[1]=0xf0+HReg; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + END + break; + case ModIncWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2+(MModIncWReg*(1-OpSize))); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0xb4+(OpSize*0x21); + BAsmCode[1]=0xf0+HReg; BAsmCode[2]=AdrVals[0]; + CodeLen=3; + break; + case ModIncWReg: + BAsmCode[0]=0xd7; BAsmCode[1]=(AdrPart << 4)+HReg; + CodeLen=2; + break; + END; + break; + case ModDecWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0xc2+OpSize; + BAsmCode[1]=0xf0+HReg; BAsmCode[2]=AdrVals[0]; + CodeLen=3; + break; + END + break; + case ModDispRWRReg: + HReg=AdrPart; HPart=AdrVals[0]; + DecodeAdr(ArgStr[2],Mask1); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + BAsmCode[0]=0x60; + BAsmCode[1]=(0x10*(1-OpSize))+0x01+(HPart << 4)+HReg; + BAsmCode[2]=0xf0+AdrPart; + CodeLen=3; + break; + END + break; + case ModDisp8WRReg: + BAsmCode[2]=AdrVals[0]; HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2+(OpSize*MModImm)); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0x26+(OpSize*0x60); + BAsmCode[1]=0xf1+HReg; BAsmCode[3]=AdrVals[0]; + CodeLen=4; + break; + case ModImm: + BAsmCode[0]=0x06; BAsmCode[1]=0xf1+HReg; + memcpy(BAsmCode+3,AdrVals,AdrCnt); CodeLen=3+AdrCnt; + break; + END + break; + case ModDisp16WRReg: + memcpy(BAsmCode+2,AdrVals,2); HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2+(OpSize*MModImm)); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0x26+(OpSize*0x60); + BAsmCode[1]=0xf0+HReg; BAsmCode[4]=AdrVals[0]; + CodeLen=5; + break; + case ModImm: + BAsmCode[0]=0x06; BAsmCode[1]=0xf0+HReg; + memcpy(BAsmCode+4,AdrVals,AdrCnt); CodeLen=4+AdrCnt; + break; + END + break; + case ModAbs: + memcpy(BAsmCode+2,AdrVals,2); + DecodeAdr(ArgStr[2],Mask1+MModImm); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + BAsmCode[0]=0xc5+(OpSize*0x1d); + BAsmCode[1]=0xf0+AdrPart+OpSize; + CodeLen=4; + break; + case ModImm: + memmove(BAsmCode+2+AdrCnt,BAsmCode+2,2); BAsmCode[0]=0x2f+(OpSize*7); + BAsmCode[1]=0xf1; memcpy(BAsmCode+2,AdrVals,AdrCnt); + CodeLen=4+AdrCnt; + break; + END + break; + case ModIRReg: + HReg=AdrVals[0]; + DecodeAdr(ArgStr[2],MModIWRReg*(1-OpSize)); + switch (AdrMode) + BEGIN + case ModIWRReg: + BAsmCode[0]=0x73; BAsmCode[1]=0xf0+AdrPart; BAsmCode[2]=HReg; + CodeLen=3; + break; + END + break; + END + END + return; + END + + for (z=0; z<LoadOrderCnt; z++) + if (Memo(LoadOrders[z].Name)) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModIncWRReg); + if (AdrMode==ModIncWRReg) + BEGIN + HReg=AdrPart << 4; + DecodeAdr(ArgStr[2],MModIncWRReg); + if (AdrMode==ModIncWRReg) + BEGIN + BAsmCode[0]=0xd6; + BAsmCode[1]=LoadOrders[z].Code+HReg+AdrPart; + CodeLen=2; + END + END + END + return; + END + + if ((Memo("PEA")) OR (Memo("PEAU"))) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModDisp8RReg+MModDisp16RReg); + if (AdrMode!=ModNone) + BEGIN + BAsmCode[0]=0x8f; + BAsmCode[1]=0x01+(2*Ord(Memo("PEAU"))); + memcpy(BAsmCode+2,AdrVals,AdrCnt); + BAsmCode[2]+=AdrCnt-2; + CodeLen=2+AdrCnt; + END + END + return; + END + + if ((Memo("PUSH")) OR (Memo("PUSHU"))) + BEGIN + z=Ord(Memo("PUSHU")); + if (ArgCnt!=1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModReg+MModIReg+MModImm); + switch (AdrMode) + BEGIN + case ModReg: + BAsmCode[0]=0x66-(z*0x36); BAsmCode[1]=AdrVals[0]; + CodeLen=2; + break; + case ModIReg: + BAsmCode[0]=0xf7-(z*0xc6); BAsmCode[1]=AdrVals[0]; + CodeLen=2; + break; + case ModImm: + BAsmCode[0]=0x8f; BAsmCode[1]=0xf1+(z*2); + BAsmCode[2]=AdrVals[0]; CodeLen=3; + break; + END + END + return; + END + + if ((Memo("PUSHW")) OR (Memo("PUSHUW"))) + BEGIN + z=Ord(Memo("PUSHUW")); OpSize=1; + if (ArgCnt!=1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModRReg+MModImm); + switch (AdrMode) + BEGIN + case ModRReg: + BAsmCode[0]=0x74+(z*0x42); BAsmCode[1]=AdrVals[0]; + CodeLen=2; + break; + case ModImm: + BAsmCode[0]=0x8f; BAsmCode[1]=0xc1+(z*2); + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + END + END + return; + END + + if (Memo("XCH")) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModReg); + if (AdrMode==ModReg) + BEGIN + BAsmCode[2]=AdrVals[0]; + DecodeAdr(ArgStr[2],MModReg); + if (AdrMode==ModReg) + BEGIN + BAsmCode[1]=AdrVals[0]; + BAsmCode[0]=0x16; + CodeLen=3; + END + END + END + return; + END + + /* Arithmetik */ + + for (z=0; z<ALUOrderCnt; z++) + if ((strncmp(OpPart,ALUOrders[z].Name,ALUOrders[z].len)==0) AND ((OpPart[ALUOrders[z].len]=='\0') OR (OpPart[ALUOrders[z].len]=='W'))) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + if (OpPart[strlen(OpPart)-1]=='W') + BEGIN + OpSize=1; Mask1=MModWRReg; Mask2=MModRReg; + END + else + BEGIN + Mask1=MModWReg; Mask2=MModReg; + END + DecodeAdr(ArgStr[1],Mask1+Mask2+MModIWReg+MModIWRReg+MModIncWRReg+ + MModDecWRReg+MModDispRWRReg+MModDisp8WRReg+MModDisp16WRReg+ + MModAbs+MModIRReg); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask1+MModIWReg+Mask2+MModIWRReg+MModIncWRReg+ + MModDecWRReg+MModDispRWRReg+MModDisp8WRReg+MModDisp16WRReg+ + MModAbs+MModImm); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + BAsmCode[0]=(ALUOrders[z].Code << 4)+2+(OpSize*12); + BAsmCode[1]=(HReg << 4)+AdrPart; + CodeLen=2; + break; + case ModIWReg: + if (OpSize==0) + BEGIN + BAsmCode[0]=(ALUOrders[z].Code << 4)+3; BAsmCode[1]=(HReg << 4)+AdrPart; + CodeLen=2; + END + else + BEGIN + BAsmCode[0]=0xa6; BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart; + BAsmCode[2]=WorkOfs+HReg; CodeLen=3; + END + break; + case ModReg: + case ModRReg: + BAsmCode[0]=(ALUOrders[z].Code << 4)+4+(OpSize*3); + BAsmCode[1]=AdrVals[0]; BAsmCode[2]=HReg+WorkOfs; + CodeLen=3; + break; + case ModIWRReg: + if (OpSize==0) + BEGIN + BAsmCode[0]=0x72; BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+1; + BAsmCode[2]=HReg+WorkOfs; + CodeLen=3; + END + else + BEGIN + BAsmCode[0]=(ALUOrders[z].Code << 4)+0x0e; + BAsmCode[1]=(HReg << 4)+AdrPart+1; + CodeLen=2; + END + break; + case ModIncWRReg: + BAsmCode[0]=0xb4+(OpSize*0x21); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+1; + BAsmCode[2]=HReg+WorkOfs; + CodeLen=3; + break; + case ModDecWRReg: + BAsmCode[0]=0xc2+OpSize; + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+1; + BAsmCode[2]=HReg+WorkOfs; + CodeLen=3; + break; + case ModDispRWRReg: + BAsmCode[0]=0x60; + BAsmCode[1]=0x10*(1-OpSize)+(AdrVals[0] << 4)+AdrPart; + BAsmCode[2]=(ALUOrders[z].Code << 4)+HReg; + CodeLen=3; + break; + case ModDisp8WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+1; + BAsmCode[2]=AdrVals[0]; BAsmCode[3]=WorkOfs+HReg; + CodeLen=4; + break; + case ModDisp16WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + BAsmCode[2+AdrCnt]=WorkOfs+HReg; + CodeLen=3+AdrCnt; + break; + case ModAbs: + BAsmCode[0]=0xc4+(OpSize*30); + BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + CodeLen=2+AdrCnt; + break; + case ModImm: + BAsmCode[0]=(ALUOrders[z].Code << 4)+5+(OpSize*2); + BAsmCode[1]=WorkOfs+HReg+OpSize; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + CodeLen=2+AdrCnt; + break; + END + break; + case ModReg: + case ModRReg: + HReg=AdrVals[0]; + DecodeAdr(ArgStr[2],Mask2+MModIWReg+MModIWRReg+MModIncWRReg+MModDecWRReg+ + MModDisp8WRReg+MModDisp16WRReg+MModImm); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=(ALUOrders[z].Code << 4)+4+(OpSize*3); CodeLen=3; + BAsmCode[1]=AdrVals[0]; BAsmCode[2]=HReg; + break; + case ModIWReg: + BAsmCode[0]=0xa6+65*(1-OpSize); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart; + BAsmCode[2]=HReg; CodeLen=3; + break; + case ModIWRReg: + BAsmCode[0]=0x72+(OpSize*12); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+(1-OpSize); + BAsmCode[2]=HReg; CodeLen=3; + break; + case ModIncWRReg: + BAsmCode[0]=0xb4+(OpSize*0x21); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+1; + BAsmCode[2]=HReg; CodeLen=3; + break; + case ModDecWRReg: + BAsmCode[0]=0xc2+OpSize; + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+1; + BAsmCode[2]=HReg; CodeLen=3; + break; + case ModDisp8WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+1; + BAsmCode[2]=AdrVals[0]; BAsmCode[3]=HReg; CodeLen=4; + break; + case ModDisp16WRReg: + BAsmCode[0]=0x7f+(OpSize*7); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart; + memcpy(BAsmCode+2,AdrVals,AdrCnt); BAsmCode[2+AdrCnt]=HReg; + CodeLen=3+AdrCnt; + break; + case ModImm: + BAsmCode[0]=(ALUOrders[z].Code << 4)+5+(OpSize*2); + memcpy(BAsmCode+2,AdrVals,AdrCnt); BAsmCode[1]=HReg+OpSize; + CodeLen=2+AdrCnt; + break; + END + break; + case ModIWReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0xe6-(OpSize*0x50); BAsmCode[1]=AdrVals[0]; + BAsmCode[2]=(ALUOrders[z].Code << 4)+HReg; CodeLen=3; + break; + END + break; + case ModIWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],(OpSize*MModWRReg)+Mask2+MModIWRReg+MModImm); + switch (AdrMode) + BEGIN + case ModWRReg: + BAsmCode[0]=(ALUOrders[z].Code << 4)+0x0e; + BAsmCode[1]=(HReg << 4)+0x10+AdrPart; CodeLen=2; + break; + case ModReg: + case ModRReg: + BAsmCode[0]=0x72+(OpSize*76); + BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg+OpSize; + BAsmCode[2]=AdrVals[0]; CodeLen=3; + break; + case ModIWRReg: + if (OpSize==0) + BEGIN + BAsmCode[0]=0x73; BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart; + BAsmCode[2]=HReg+WorkOfs; CodeLen=3; + END + else + BEGIN + BAsmCode[0]=(ALUOrders[z].Code << 4)+0x0e; + BAsmCode[1]=0x11+(HReg << 4)+AdrPart; + CodeLen=2; + END + break; + case ModImm: + BAsmCode[0]=0xf3-(OpSize*0x35); + BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + END + break; + case ModIncWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0xb4+(OpSize*0x21); + BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg; + BAsmCode[2]=AdrVals[0]; CodeLen=3; + break; + END + break; + case ModDecWRReg: + HReg=AdrPart; + DecodeAdr(ArgStr[2],Mask2); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0xc2+OpSize; + BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg; + BAsmCode[2]=AdrVals[0]; CodeLen=3; + break; + END + break; + case ModDispRWRReg: + HReg=AdrPart; HPart=AdrVals[0]; + DecodeAdr(ArgStr[2],Mask1); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + BAsmCode[0]=0x60; + BAsmCode[1]=0x11-(OpSize*0x10)+(HPart << 4)+HReg; + BAsmCode[2]=(ALUOrders[z].Code << 4)+AdrPart; CodeLen=3; + break; + END + break; + case ModDisp8WRReg: + HReg=AdrPart; BAsmCode[2]=AdrVals[0]; + DecodeAdr(ArgStr[2],Mask2+(OpSize*MModImm)); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0x26+(OpSize*0x60); + BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg+1; + BAsmCode[3]=AdrVals[0]+OpSize; CodeLen=4; + break; + case ModImm: + BAsmCode[0]=0x06; BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg+1; + memcpy(BAsmCode+3,AdrVals,AdrCnt); CodeLen=3+AdrCnt; + break; + END + break; + case ModDisp16WRReg: + HReg=AdrPart; memcpy(BAsmCode+2,AdrVals,2); + DecodeAdr(ArgStr[2],Mask2+(OpSize*MModImm)); + switch (AdrMode) + BEGIN + case ModReg: + case ModRReg: + BAsmCode[0]=0x26+(OpSize*0x60); + BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg; + BAsmCode[4]=AdrVals[0]+OpSize; CodeLen=5; + break; + case ModImm: + BAsmCode[0]=0x06; BAsmCode[1]=(ALUOrders[z].Code << 4)+HReg; + memcpy(BAsmCode+4,AdrVals,AdrCnt); CodeLen=4+AdrCnt; + break; + END + break; + case ModAbs: + memcpy(BAsmCode+2,AdrVals,2); + DecodeAdr(ArgStr[2],Mask1+MModImm); + switch (AdrMode) + BEGIN + case ModWReg: + case ModWRReg: + BAsmCode[0]=0xc5+(OpSize*29); + BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart+OpSize; + CodeLen=4; + break; + case ModImm: + memmove(BAsmCode+2+AdrCnt,BAsmCode+2,2); memcpy(BAsmCode+2,AdrVals,AdrCnt); + BAsmCode[0]=0x2f+(OpSize*7); + BAsmCode[1]=(ALUOrders[z].Code << 4)+1; + CodeLen=4+AdrCnt; + break; + END + break; + case ModIRReg: + HReg=AdrVals[0]; + DecodeAdr(ArgStr[2],MModIWRReg*(1-OpSize)); + switch (AdrMode) + BEGIN + case ModIWRReg: + BAsmCode[0]=0x73; BAsmCode[1]=(ALUOrders[z].Code << 4)+AdrPart; + BAsmCode[2]=HReg; CodeLen=3; + break; + END + break; + END + END + return; + END + + for (z=0; z<RegOrderCnt; z++) + if (Memo(RegOrders[z].Name)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModReg+MModIReg); + switch (AdrMode) + BEGIN + case ModReg: + BAsmCode[0]=RegOrders[z].Code; BAsmCode[1]=AdrVals[0]; CodeLen=2; + break; + case ModIReg: + BAsmCode[0]=RegOrders[z].Code+1; BAsmCode[1]=AdrVals[0]; CodeLen=2; + break; + END + END + return; + END + + for (z=0; z<Reg16OrderCnt; z++) + if (Memo(Reg16Orders[z].Name)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModRReg); + switch (AdrMode) + BEGIN + case ModRReg: + BAsmCode[0]=Reg16Orders[z].Code; BAsmCode[1]=AdrVals[0]+Ord(Memo("EXT")); + CodeLen=2; + break; + END + END + return; + END + + if ((Memo("DIV")) OR (Memo("MUL"))) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModWRReg); + if (AdrMode==ModWRReg) + BEGIN + HReg=AdrPart; + DecodeAdr(ArgStr[2],MModWReg); + if (AdrMode==ModWReg) + BEGIN + BAsmCode[0]=0x5f-(0x10*Ord(Memo("MUL"))); + BAsmCode[1]=(HReg << 4)+AdrPart; + CodeLen=2; + END + END + END + return; + END + + if (Memo("DIVWS")) + BEGIN + if (ArgCnt!=3) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModWRReg); + if (AdrMode==ModWRReg) + BEGIN + HReg=AdrPart; + DecodeAdr(ArgStr[2],MModWRReg); + if (AdrMode==ModWRReg) + BEGIN + BAsmCode[2]=(HReg << 4)+AdrPart; + DecodeAdr(ArgStr[3],MModRReg); + if (AdrMode==ModRReg) + BEGIN + BAsmCode[0]=0x56; BAsmCode[1]=AdrVals[0]; + CodeLen=3; + END + END + END + END + return; + END + + /* Bitoperationen */ + + for (z=0; z<Bit2OrderCnt; z++) + if (Memo(Bit2Orders[z].Name)) + BEGIN + if (ArgCnt!=2) WrError(1110); + else if (SplitBit(ArgStr[1],&HReg)) + if (Odd(HReg)) WrError(1350); + else + BEGIN + DecodeAdr(ArgStr[1],MModWReg); + if (AdrMode==ModWReg) + BEGIN + HReg=(HReg << 4)+AdrPart; + if (SplitBit(ArgStr[2],&HPart)) + BEGIN + DecodeAdr(ArgStr[2],MModWReg); + if (AdrMode==ModWReg) + BEGIN + HPart=(HPart << 4)+AdrPart; + BAsmCode[0]=Bit2Orders[z].Code; + if (Memo("BLD")) + BEGIN + BAsmCode[1]=HPart | 0x10; BAsmCode[2]=HReg | (HPart & 0x10); + END + else if (Memo("BXOR")) + BEGIN + BAsmCode[1]=0x10+HReg; BAsmCode[2]=HPart; + END + else + BEGIN + BAsmCode[1]=0x10+HReg; BAsmCode[2]=HPart ^ 0x10; + END + CodeLen=3; + END + END + END + END + return; + END + + for (z=0; z<Bit1OrderCnt; z++) + if (Memo(Bit1Orders[z].Name)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else if (SplitBit(ArgStr[1],&HReg)) + if (Odd(HReg)) WrError(1350); + else + BEGIN + DecodeAdr(ArgStr[1],MModWReg+(Ord(Memo("BTSET"))*MModIWRReg)); + switch (AdrMode) + BEGIN + case ModWReg: + BAsmCode[0]=Bit1Orders[z].Code; BAsmCode[1]=(HReg << 4)+AdrPart; + CodeLen=2; + break; + case ModIWRReg: + BAsmCode[0]=0xf6; BAsmCode[1]=(HReg << 4)+AdrPart; + CodeLen=2; + break; + END + END + return; + END + + /* Spruenge */ + + if ((Memo("BTJF")) OR (Memo("BTJT"))) + BEGIN + if (ArgCnt!=2) WrError(1110); + else if (SplitBit(ArgStr[1],&HReg)) + if (Odd(HReg)) WrError(1350); + else + BEGIN + DecodeAdr(ArgStr[1],MModWReg); + if (AdrMode==ModWReg) + BEGIN + BAsmCode[1]=(HReg << 4)+AdrPart+(Ord(Memo("BTJF")) << 4); + AdrInt=EvalIntExpression(ArgStr[2],UInt16,&OK)-(EProgCounter()+3); + if (OK) + if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370); + else + BEGIN + BAsmCode[0]=0xaf; BAsmCode[2]=AdrInt & 0xff; CodeLen=3; + ChkSpace(SegCode); + END + END + END + return; + END + + if ((Memo("JP")) OR (Memo("CALL"))) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + AbsSeg=SegCode; + DecodeAdr(ArgStr[1],MModIRReg+MModAbs); + switch (AdrMode) + BEGIN + case ModIRReg: + BAsmCode[0]=0x74+(Ord(Memo("JP"))*0x60); + BAsmCode[1]=AdrVals[0]+Ord(Memo("CALL")); CodeLen=2; + break; + case ModAbs: + BAsmCode[0]=0x8d+(Ord(Memo("CALL"))*0x45); + memcpy(BAsmCode+1,AdrVals,AdrCnt); CodeLen=1+AdrCnt; + break; + END + END + return; + END + + if ((Memo("CPJFI")) OR (Memo("CPJTI"))) + BEGIN + if (ArgCnt!=3) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModWReg); + if (AdrMode==ModWReg) + BEGIN + HReg=AdrPart; + DecodeAdr(ArgStr[2],MModIWRReg); + if (AdrMode==ModIWRReg) + BEGIN + BAsmCode[1]=(AdrPart << 4)+(Ord(Memo("CPJTI")) << 4)+HReg; + AdrInt=EvalIntExpression(ArgStr[3],UInt16,&OK)-(EProgCounter()+3); + if (OK) + if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370); + else + BEGIN + ChkSpace(SegCode); + BAsmCode[0]=0x9f; BAsmCode[2]=AdrInt & 0xff; + CodeLen=3; + END + END + END + END + return; + END + + if (Memo("DJNZ")) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModWReg); + if (AdrMode==ModWReg) + BEGIN + BAsmCode[0]=(AdrPart << 4)+0x0a; + AdrInt=EvalIntExpression(ArgStr[2],UInt16,&OK)-(EProgCounter()+2); + if (OK) + if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370); + else + BEGIN + ChkSpace(SegCode); + BAsmCode[1]=AdrInt & 0xff; + CodeLen=2; + END + END + END + return; + END + + if (Memo("DWJNZ")) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModRReg); + if (AdrMode==ModRReg) + BEGIN + BAsmCode[1]=AdrVals[0]; + AdrInt=EvalIntExpression(ArgStr[2],UInt16,&OK)-(EProgCounter()+3); + if (OK) + if ((NOT SymbolQuestionable) AND ((AdrInt<-128) OR (AdrInt>127))) WrError(1370); + else + BEGIN + ChkSpace(SegCode); + BAsmCode[0]=0xc6; BAsmCode[2]=AdrInt & 0xff; + CodeLen=3; + END + END + END + return; + END + + for (z=0; z<ConditionCnt; z++) + if ((*OpPart=='J') AND (OpPart[1]=='P') AND (strcmp(OpPart+2,Conditions[z].Name)==0)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + AdrWord=EvalIntExpression(ArgStr[1],UInt16,&OK); + if (OK) + BEGIN + ChkSpace(SegCode); + BAsmCode[0]=0x0d+(Conditions[z].Code << 4); + BAsmCode[1]=Hi(AdrWord); BAsmCode[2]=Lo(AdrWord); + CodeLen=3; + END + END + return; + END + else if ((*OpPart=='J') AND (OpPart[1]=='R') AND (strcmp(OpPart+2,Conditions[z].Name)==0)) + BEGIN + if (ArgCnt!=1) WrError(1110); + 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 + ChkSpace(SegCode); + BAsmCode[0]=0x0b+(Conditions[z].Code << 4); BAsmCode[1]=AdrInt & 0xff; + CodeLen=2; + END + END + return; + END + + /* Besonderheiten */ + + if (Memo("SPP")) + BEGIN + if (ArgCnt!=1) WrError(1110); + else if (*ArgStr[1]!='#') WrError(1350); + else + BEGIN + BAsmCode[1]=(EvalIntExpression(ArgStr[1]+1,UInt6,&OK) << 2)+0x02; + if (OK) + BEGIN + BAsmCode[0]=0xc7; CodeLen=2; + END + END + return; + END + + if ((Memo("SRP")) OR (Memo("SRP0")) OR (Memo("SRP1"))) + BEGIN + if (ArgCnt!=1) WrError(1110); + else if (*ArgStr[1]!='#') WrError(1350); + else + BEGIN + BAsmCode[1]=EvalIntExpression(ArgStr[1]+1,UInt5,&OK) << 3; + if (OK) + BEGIN + BAsmCode[0]=0xc7; CodeLen=2; + if (strlen(OpPart)==4) BAsmCode[1]+=4; + if (OpPart[strlen(OpPart)-1]=='1') BAsmCode[1]++; + END + END + return; + END + + /* Fakes... */ + + if (Memo("SLA")) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModWReg+MModReg+MModIWRReg); + switch (AdrMode) + BEGIN + case ModWReg: + BAsmCode[0]=0x42; BAsmCode[1]=(AdrPart << 4)+AdrPart; + CodeLen=2; + break; + case ModReg: + BAsmCode[0]=0x44; + BAsmCode[1]=AdrVals[0]; + BAsmCode[2]=AdrVals[0]; + CodeLen=3; + break; + case ModIWRReg: + BAsmCode[0]=0x73; BAsmCode[1]=0x40+AdrPart; + BAsmCode[2]=WorkOfs+AdrPart; CodeLen=3; + break; + END + END + return; + END + + if (Memo("SLAW")) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1],MModWRReg+MModRReg+MModIWRReg); + switch (AdrMode) + BEGIN + case ModWRReg: + BAsmCode[0]=0x4e; BAsmCode[1]=(AdrPart << 4)+AdrPart; + CodeLen=2; + break; + case ModRReg: + BAsmCode[0]=0x47; + BAsmCode[1]=AdrVals[0]; + BAsmCode[2]=AdrVals[0]; + CodeLen=3; + break; + case ModIWRReg: + BAsmCode[0]=0x4e; BAsmCode[1]=0x11+(AdrPart << 4)+AdrPart; + CodeLen=2; + break; + END + END + return; + END + + WrXError(1200,OpPart); +END + + static void InitCode_ST9(void) +BEGIN + SaveInitProc(); + + DPAssume=0; +END + + static Boolean IsDef_ST9(void) +BEGIN + return (Memo("REG") OR Memo("BIT")); +END + + static void SwitchFrom_ST9(void) +BEGIN + DeinitFields(); +END + + static void InternSymbol_ST9(char *Asc, TempResult *Erg) +BEGIN + String h; + Boolean Err; + Boolean Pair; + + Erg->Typ=TempNone; + if ((strlen(Asc)<2) OR (*Asc!='R')) return; + + strmaxcpy(h,Asc+1,255); + if (*h=='R') + BEGIN + if (strlen(h)<2) return; + Pair=True; strcpy(h,h+1); + END + else Pair=False; + Erg->Contents.Int=ConstLongInt(h,&Err); + if ((NOT Err) OR (Erg->Contents.Int<0) OR (Erg->Contents.Int>255)) return; + if ((Erg->Contents.Int & 0xf0)==0xd0) return; + if ((Pair) AND (Odd(Erg->Contents.Int))) return; + + if (Pair) Erg->Contents.Int+=0x100; + Erg->Typ=TempInt; TypeFlag|=(1 << SegReg); +END + + static void SwitchTo_ST9(void) +BEGIN + TurnWords=False; ConstMode=ConstModeIntel; SetIsOccupied=False; + + PCSymbol="PC"; HeaderID=0x32; NOPCode=0xff; + DivideChars=","; HasAttrs=False; + + ValidSegs=(1<<SegCode)|(1<<SegData)|(1<<SegReg); + Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0; + SegLimits[SegCode] = 0xffff; + Grans[SegData]=1; ListGrans[SegData]=1; SegInits[SegData]=0; + SegLimits[SegData] = 0xffff; + Grans[SegReg ]=1; ListGrans[SegReg ]=1; SegInits[SegReg ]=0; + SegLimits[SegReg ] = 0xff; + + MakeCode=MakeCode_ST9; IsDef=IsDef_ST9; + SwitchFrom=SwitchFrom_ST9; InternSymbol=InternSymbol_ST9; + + InitFields(); +END + + void codest9_init(void) +BEGIN + CPUST9020=AddCPU("ST9020",SwitchTo_ST9); + CPUST9030=AddCPU("ST9030",SwitchTo_ST9); + CPUST9040=AddCPU("ST9040",SwitchTo_ST9); + CPUST9050=AddCPU("ST9050",SwitchTo_ST9); + SaveInitProc=InitPassProc; InitPassProc=InitCode_ST9; +END + + |