aboutsummaryrefslogtreecommitdiffstats
path: root/codest7.c
diff options
context:
space:
mode:
Diffstat (limited to 'codest7.c')
-rw-r--r--codest7.c878
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
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-16 20:35:56 +0000