From 333b605b2afd472b823aeda0adf0e8b1ea9843c0 Mon Sep 17 00:00:00 2001
From: fishsoupisgood <github@madingley.org>
Date: Mon, 27 May 2019 02:41:51 +0100
Subject: initial commit from asl-1.41r8.tar.gz

---
 codest7.c | 878 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 878 insertions(+)
 create mode 100644 codest7.c

(limited to 'codest7.c')

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
+
+
-- 
cgit v1.2.3