/* code3203x.c */
/*****************************************************************************/
/* AS-Portierung                                                             */
/*                                                                           */
/* Codegenerator TMS320C3x-Familie                                           */               
/*                                                                           */
/* Historie: 12.12.1996 Grundsteinlegung                                     */               
/*            7. 7.1998 Fix Zugriffe auf CharTransTable wg. signed chars     */
/*           18. 8.1998 BookKeeping-Aufruf in RES                            */
/*            3. 1.1998 ChkPC-Anpassung                                      */
/*                                                                           */
/*****************************************************************************/

#include "stdinc.h"
#include <ctype.h>
#include <string.h>

#include "nls.h"
#include "endian.h"
#include "bpemu.h"
#include "strutil.h"
#include "chunks.h"
#include "asmdef.h"
#include "asmsub.h"
#include "asmpars.h"
#include "asmcode.h"
#include "codepseudo.h"
#include "codevars.h"


#define ConditionCount 28
#define FixedOrderCount 3
#define RotOrderCount 4
#define StkOrderCount 4
#define GenOrderCount 41
#define ParOrderCount 8
#define SingOrderCount 3

typedef struct
         {
          char *Name;
          Byte Code;
         } Condition;

typedef struct
         {
          char *Name;
          LongWord Code;
         } FixedOrder;

typedef struct
         {
          char *Name;
          int NameLen;
          Boolean May1,May3;
          Byte Code,Code3;
          Boolean OnlyMem;
          Boolean SwapOps;
          Boolean ImmFloat;
          Byte ParMask,Par3Mask;
          Byte PCodes[8],P3Codes[8];
         } GenOrder;

typedef struct
         {
          char *Name;
          LongWord Code;
          Byte Mask;
         } SingOrder;


static CPUVar CPU32030,CPU32031;
static SimpProc SaveInitProc;

static Boolean NextPar,ThisPar;
static Byte PrevARs,ARs;
static char PrevOp[7];
static int z2;
static ShortInt PrevSrc1Mode,PrevSrc2Mode,PrevDestMode;
static ShortInt CurrSrc1Mode,CurrSrc2Mode,CurrDestMode;
static Word PrevSrc1Part,PrevSrc2Part,PrevDestPart;
static Word CurrSrc1Part,CurrSrc2Part,CurrDestPart;

static Condition *Conditions;
static FixedOrder *FixedOrders;
static char **RotOrders;
static char **StkOrders;
static GenOrder *GenOrders;
static char **ParOrders;
static SingOrder *SingOrders;

static LongInt DPValue;

/*-------------------------------------------------------------------------*/
/* Befehlstabellenverwaltung */

	static void AddCondition(char *NName, Byte NCode)
BEGIN
   if (InstrZ>=ConditionCount) exit(255);
   Conditions[InstrZ].Name=NName;
   Conditions[InstrZ++].Code=NCode;
END

	static void AddFixed(char *NName, LongWord NCode)
BEGIN
   if (InstrZ>=FixedOrderCount) exit(255);
   FixedOrders[InstrZ].Name=NName;
   FixedOrders[InstrZ++].Code=NCode;
END

	static void AddSing(char *NName, LongWord NCode, Byte NMask)
BEGIN
   if (InstrZ>=SingOrderCount) exit(255);
   SingOrders[InstrZ].Name=NName;
   SingOrders[InstrZ].Code=NCode;
   SingOrders[InstrZ++].Mask=NMask;
END

	static void AddGen(char *NName, Boolean NMay1, Boolean NMay3,
                           Byte NCode, Byte NCode3,
			   Boolean NOnly, Boolean NSwap, Boolean NImm,
                           Byte NMask1, Byte NMask3,
			   Byte C20, Byte C21, Byte C22, Byte C23, Byte C24,
                           Byte C25, Byte C26, Byte C27, Byte C30, Byte C31,
                           Byte C32, Byte C33, Byte C34, Byte C35, Byte C36,
                           Byte C37)
BEGIN
   if (InstrZ>=GenOrderCount) exit(255);
   GenOrders[InstrZ].Name=NName;
   GenOrders[InstrZ].NameLen=strlen(NName);
   GenOrders[InstrZ].May1=NMay1; GenOrders[InstrZ].May3=NMay3;
   GenOrders[InstrZ].Code=NCode; GenOrders[InstrZ].Code3=NCode3;
   GenOrders[InstrZ].OnlyMem=NOnly; GenOrders[InstrZ].SwapOps=NSwap;
   GenOrders[InstrZ].ImmFloat=NImm;
   GenOrders[InstrZ].ParMask=NMask1; GenOrders[InstrZ].Par3Mask=NMask3;
   GenOrders[InstrZ].PCodes[0]=C20;  GenOrders[InstrZ].PCodes[1]=C21;
   GenOrders[InstrZ].PCodes[2]=C22;  GenOrders[InstrZ].PCodes[3]=C23;
   GenOrders[InstrZ].PCodes[4]=C24;  GenOrders[InstrZ].PCodes[5]=C25;
   GenOrders[InstrZ].PCodes[6]=C26;  GenOrders[InstrZ].PCodes[7]=C27;
   GenOrders[InstrZ].P3Codes[0]=C30; GenOrders[InstrZ].P3Codes[1]=C31;
   GenOrders[InstrZ].P3Codes[2]=C32; GenOrders[InstrZ].P3Codes[3]=C33;
   GenOrders[InstrZ].P3Codes[4]=C34; GenOrders[InstrZ].P3Codes[5]=C35;
   GenOrders[InstrZ].P3Codes[6]=C36; GenOrders[InstrZ++].P3Codes[7]=C37;
END

	static void InitFields(void)
BEGIN
   Conditions=(Condition *) malloc(sizeof(Condition)*ConditionCount); InstrZ=0;
   AddCondition("U"  ,0x00); AddCondition("LO" ,0x01);
   AddCondition("LS" ,0x02); AddCondition("HI" ,0x03);
   AddCondition("HS" ,0x04); AddCondition("EQ" ,0x05);
   AddCondition("NE" ,0x06); AddCondition("LT" ,0x07);
   AddCondition("LE" ,0x08); AddCondition("GT" ,0x09);
   AddCondition("GE" ,0x0a); AddCondition("Z"  ,0x05);
   AddCondition("NZ" ,0x06); AddCondition("P"  ,0x09);
   AddCondition("N"  ,0x07); AddCondition("NN" ,0x0a);
   AddCondition("NV" ,0x0c); AddCondition("V"  ,0x0d);
   AddCondition("NUF",0x0e); AddCondition("UF" ,0x0f);
   AddCondition("NC" ,0x04); AddCondition("C"  ,0x01);
   AddCondition("NLV",0x10); AddCondition("LV" ,0x11);
   AddCondition("NLUF",0x12);AddCondition("LUF",0x13);
   AddCondition("ZUF",0x14); AddCondition(""   ,0x00);

   FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCount); InstrZ=0;
   AddFixed("IDLE",0x06000000); AddFixed("SIGI",0x16000000);
   AddFixed("SWI" ,0x66000000);

   RotOrders=(char **) malloc(sizeof(char *)*RotOrderCount); InstrZ=0;
   RotOrders[InstrZ++]="ROL"; RotOrders[InstrZ++]="ROLC";
   RotOrders[InstrZ++]="ROR"; RotOrders[InstrZ++]="RORC";

   StkOrders=(char **) malloc(sizeof(char *)*StkOrderCount); InstrZ=0;
   StkOrders[InstrZ++]="POP";  StkOrders[InstrZ++]="POPF";
   StkOrders[InstrZ++]="PUSH"; StkOrders[InstrZ++]="PUSHF";

   GenOrders=(GenOrder *) malloc(sizeof(GenOrder)*GenOrderCount); InstrZ=0;
/*         Name         May3      Cd3       Swap       PM1                                              PCodes3     */
/*                May1        Cd1     OMem        ImmF     PM3           PCodes1                                    */
   AddGen("ABSF" ,True ,False,0x00,0xff,False,False,True , 4, 0,
	  0xff,0xff,0x04,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("ABSI" ,True ,False,0x01,0xff,False,False,False, 8, 0,
	  0xff,0xff,0xff,0x05,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("ADDC" ,False,True ,0x02,0x00,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("ADDF" ,False,True ,0x03,0x01,False,False,True , 0, 4,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0x06,0xff,0xff,0xff,0xff,0xff);
   AddGen("ADDI" ,False,True ,0x04,0x02,False,False,False, 0, 8,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x07,0xff,0xff,0xff,0xff);
   AddGen("AND"  ,False,True ,0x05,0x03,False,False,False, 0, 8,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x08,0xff,0xff,0xff,0xff);
   AddGen("ANDN" ,False,True ,0x06,0x04,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("ASH"  ,False,True ,0x07,0x05,False,False,False, 0, 8,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x09,0xff,0xff,0xff,0xff);
   AddGen("CMPF" ,False,True ,0x08,0x06,False,False,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("CMPI" ,False,True ,0x09,0x07,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("FIX"  ,True ,False,0x0a,0xff,False,False,True , 8, 0,
	  0xff,0xff,0xff,0x0a,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("FLOAT",True ,False,0x0b,0xff,False,False,False, 4, 0,
	  0xff,0xff,0x0b,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("LDE"  ,False,False,0x0d,0xff,False,False,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("LDF"  ,False,False,0x0e,0xff,False,False,True , 5, 0,
	  0x02,0xff,0x0c,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("LDFI" ,False,False,0x0f,0xff,True ,False,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("LDI"  ,False,False,0x10,0xff,False,False,False,10, 0,
	  0xff,0x03,0xff,0x0d,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("LDII" ,False,False,0x11,0xff,True ,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("LDM"  ,False,False,0x12,0xff,False,False,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("LSH"  ,False,True ,0x13,0x08,False,False,False, 0, 8,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x0e,0xff,0xff,0xff,0xff);
   AddGen("MPYF" ,False,True ,0x14,0x09,False,False,True , 0,52,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0x0f,0xff,0x00,0x01,0xff,0xff);
   AddGen("MPYI" ,False,True ,0x15,0x0a,False,False,False, 0,200,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x10,0xff,0xff,0x02,0x03);
   AddGen("NEGB" ,True ,False,0x16,0xff,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("NEGF" ,True ,False,0x17,0xff,False,False,True , 4, 0,
	  0xff,0xff,0x11,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("NEGI" ,True ,False,0x18,0xff,False,False,False, 8, 0,
	  0xff,0xff,0xff,0x12,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("NORM" ,True ,False,0x1a,0xff,False,False,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("NOT"  ,True ,False,0x1b,0xff,False,False,False, 8, 0,
	  0xff,0xff,0xff,0x13,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("OR"   ,False,True ,0x20,0x0b,False,False,False, 0, 8,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x14,0xff,0xff,0xff,0xff);
   AddGen("RND"  ,True ,False,0x22,0xff,False,False,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("STF"  ,False,False,0x28,0xff,True ,True ,True , 4, 0,
	  0xff,0xff,0x00,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("STFI" ,False,False,0x29,0xff,True ,True ,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("STI"  ,False,False,0x2a,0xff,True ,True ,False, 8, 0,
	  0xff,0xff,0xff,0x01,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("STII" ,False,False,0x2b,0xff,True ,True ,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("SUBB" ,False,True ,0x2d,0x0c,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("SUBC" ,False,False,0x2e,0xff,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("SUBF" ,False,True ,0x2f,0x0d,False,False,True , 0, 4,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0x15,0xff,0xff,0xff,0xff,0xff);
   AddGen("SUBI" ,False,True ,0x30,0x0e,False,False,False, 0, 8,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x16,0xff,0xff,0xff,0xff);
   AddGen("SUBRB",False,False,0x31,0xff,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("SUBRF",False,False,0x32,0xff,False,False,True , 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("SUBRI",False,False,0x33,0xff,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("TSTB" ,False,True ,0x34,0x0f,False,False,False, 0, 0,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
   AddGen("XOR"  ,False,True ,0x35,0x10,False,False,False, 0, 8,
	  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0x17,0xff,0xff,0xff,0xff);

   ParOrders=(char **) malloc(sizeof(char *)*ParOrderCount); InstrZ=0;
   ParOrders[InstrZ++]="LDF";   ParOrders[InstrZ++]="LDI";
   ParOrders[InstrZ++]="STF";   ParOrders[InstrZ++]="STI";
   ParOrders[InstrZ++]="ADDF3"; ParOrders[InstrZ++]="SUBF3";
   ParOrders[InstrZ++]="ADDI3"; ParOrders[InstrZ++]="SUBI3";

   SingOrders=(SingOrder *) malloc(sizeof(SingOrder)*SingOrderCount); InstrZ=0;
   AddSing("IACK",0x1b000000,6);
   AddSing("NOP" ,0x0c800000,5);
   AddSing("RPTS",0x139b0000,15);
END

	static void DeinitFields(void)
BEGIN
   free(Conditions);
   free(FixedOrders);
   free(RotOrders);
   free(StkOrders);
   free(GenOrders);
   free(ParOrders);
   free(SingOrders);
END

/*-------------------------------------------------------------------------*/
/* Gleitkommawandler */

	static void SplitExt(Double Inp, LongInt *Expo, LongWord *Mant)
BEGIN
   Byte Field[8];
   Boolean Sign;
   int z;

   Double_2_ieee8(Inp,Field,False);
   Sign=(Field[7]>0x7f);
   *Expo=(((LongWord) Field[7]&0x7f)<<4)+(Field[6]>>4);
   *Mant=Field[6]&0x0f; if (*Expo!=0) *Mant|=0x10;
   for (z=5; z>2; z--) *Mant=((*Mant)<<8)|Field[z];
   *Mant=((*Mant)<<3)+(Field[2]>>5);
   *Expo-=0x3ff;
   if (Sign) *Mant=0xffffffff-(*Mant);
   *Mant=(*Mant)^0x80000000;
END

	static Boolean ExtToShort(Double Inp, Word *Erg)
BEGIN
   LongInt Expo;
   LongWord Mant;

   if (Inp==0) *Erg=0x8000;
   else
    BEGIN
     SplitExt(Inp,&Expo,&Mant);
     if (abs(Expo)>7)
      BEGIN
       WrError((Expo>0)?1320:1315);
       return False;
      END
     *Erg=((Expo << 12) & 0xf000) | ((Mant >> 20) & 0xfff);
    END
   return True;
END

	static Boolean ExtToSingle(Double Inp, LongWord *Erg)
BEGIN
   LongInt Expo;
   LongWord Mant;

   if (Inp==0) *Erg=0x80000000;
   else
    BEGIN
     SplitExt(Inp,&Expo,&Mant);
     if (abs(Expo)>127)
      BEGIN
       WrError((Expo>0)?1320:1315);
       return False;
      END
     *Erg=((Expo << 24) & 0xff000000)+(Mant >> 8);
    END
   return True;
END

	static Boolean ExtToExt(Double Inp, LongWord *ErgL, LongWord *ErgH)
BEGIN
   LongInt Exp;

   if (Inp==0)
    BEGIN
     *ErgH=0x80; *ErgL=0x00000000;
    END
   else
    BEGIN
     SplitExt(Inp,&Exp,ErgL);
     if (abs(Exp)>127)
      BEGIN
       WrError((Exp>0)?1320:1315);
       return False;
      END
     *ErgH=Exp&0xff;
    END
   return True;
END

/*-------------------------------------------------------------------------*/
/* Adressparser */

#define ModNone (-1)
#define ModReg 0
#define MModReg (1 << ModReg)
#define ModDir 1
#define MModDir (1 << ModDir)
#define ModInd 2
#define MModInd (1 << ModInd)
#define ModImm 3
#define MModImm (1 << ModImm)

static ShortInt AdrMode;
static LongInt AdrPart;

	static Boolean DecodeReg(char *Asc, Byte *Erg)
BEGIN
#define RegCnt 12
#define RegStart 0x10
    static char *Regs[RegCnt]=
	{"DP","IR0","IR1","BK","SP","ST","IE","IF","IOF","RS","RE","RC"};
    Boolean Err;

   if ((toupper(*Asc)=='R') AND (strlen(Asc)<=3) AND (strlen(Asc)>=2))
    BEGIN
     *Erg=ConstLongInt(Asc+1,&Err);
     if ((Err) AND (*Erg<=0x1b)) return True;
    END

   if ((strlen(Asc)==3) AND (toupper(*Asc)=='A') AND (toupper(Asc[1])=='R') AND (Asc[2]>='0') AND (Asc[2]<='7'))
    BEGIN
     *Erg=Asc[2]-'0'+8; return True;
    END

   *Erg=0;
   while ((*Erg<RegCnt) AND (strcasecmp(Regs[*Erg],Asc)!=0)) (*Erg)++;
   if (*Erg<RegCnt)
    BEGIN
     *Erg+=RegStart; return True;
    END

   return False;
END

	static void ChkAdr(Byte Erl)
BEGIN
   if ((AdrMode!=ModNone) AND ((Erl & (1 << AdrMode))==0))
    BEGIN
     AdrMode=ModNone; WrError(1350);
    END
END

	static void DecodeAdr(char *Asc, Byte Erl, Boolean ImmFloat)
BEGIN
   Byte HReg;
   Integer Disp;
   char *p;
   int l;
   Double f;
   Word fi;
   LongInt AdrLong;
   Boolean BitRev,Circ;
   String NDisp;
   Boolean OK;
   enum {ModBase,ModAdd,ModSub,ModPreInc,ModPreDec,ModPostInc,ModPostDec} Mode;

   KillBlanks(Asc);

   AdrMode=ModNone;

   /* I. Register? */

   if (DecodeReg(Asc,&HReg))
    BEGIN
     AdrMode=ModReg; AdrPart=HReg; ChkAdr(Erl); return;
    END

   /* II. indirekt ? */

   if (*Asc=='*')
    BEGIN
     /* II.1. Erkennungszeichen entfernen */

     strcpy(Asc,Asc+1);

     /* II.2. Extrawuerste erledigen */

     BitRev=False; Circ=False;
     if (toupper(Asc[strlen(Asc)-1])=='B')
      BEGIN
       BitRev=True; Asc[strlen(Asc)-1]='\0';
      END
     else if (Asc[strlen(Asc)-1]=='%')
      BEGIN
       Circ=True; Asc[strlen(Asc)-1]='\0';
      END

     /* II.3. Displacement entfernen und auswerten:
	     0..255-->Displacement
	     -1,-2 -->IR0,IR1
	     -3    -->Default */

     p=QuotPos(Asc,'(');
     if (p!=Nil)
      BEGIN
       if (Asc[strlen(Asc)-1]!=')')
	BEGIN
	 WrError(1350); return;
	END
       *p='\0'; strmaxcpy(NDisp,p+1,255); NDisp[strlen(NDisp)-1]='\0';
       if (strcasecmp(NDisp,"IR0")==0) Disp=(-1);
       else if (strcasecmp(NDisp,"IR1")==0) Disp=(-2);
       else
	BEGIN
	 Disp=EvalIntExpression(NDisp,UInt8,&OK);
	 if (NOT OK) return;
	END
      END
     else Disp=(-3);

     /* II.4. Addieren/Subtrahieren mit/ohne Update? */

     l=strlen(Asc);
     if (*Asc=='-')
      BEGIN
       if (Asc[1]=='-')
	BEGIN
	 Mode=ModPreDec; strcpy(Asc,Asc+2);
	END
       else
	BEGIN
	 Mode=ModSub; strcpy(Asc,Asc+1);
	END
      END
     else if (*Asc=='+')
      BEGIN
       if (Asc[1]=='+')
	BEGIN
	 Mode=ModPreInc; strcpy(Asc,Asc+2);
	END
       else
	BEGIN
	 Mode=ModAdd; strcpy(Asc,Asc+1);
	END
      END
     else if (Asc[l-1]=='-')
      BEGIN
       if (Asc[l-2]=='-')
	BEGIN
	 Mode=ModPostDec; Asc[l-2]='\0';
	END
       else
	BEGIN
	 WrError(1350); return;
	END
      END
     else if (Asc[l-1]=='+')
      BEGIN
       if (Asc[l-2]=='+')
	BEGIN
	 Mode=ModPostInc; Asc[l-2]='\0';
	END
       else
	BEGIN
	 WrError(1350); return;
	END
      END
     else Mode=ModBase;

     /* II.5. Rest muss Basisregister sein */

     if ((NOT DecodeReg(Asc,&HReg)) OR (HReg<8) OR (HReg>15))
      BEGIN
       WrError(1350); return;
      END
     HReg-=8;
     if ((ARs & (1l << HReg))==0) ARs+=1l << HReg;
     else WrXError(210,Asc);

     /* II.6. Default-Displacement explizit machen */

     if (Disp==-3)
      Disp=(Mode==ModBase) ? 0 : 1;

     /* II.7. Entscheidungsbaum */

     switch (Mode)
      BEGIN
       case ModBase:
       case ModAdd:
        if ((Circ) OR (BitRev)) WrError(1350);
        else
         BEGIN
	  switch (Disp)
           BEGIN
	    case -2: AdrPart=0x8000; break;
	    case -1: AdrPart=0x4000; break;
	    case  0: AdrPart=0xc000; break;
	    default: AdrPart=Disp;
	   END
	  AdrPart+=((Word)HReg) << 8; AdrMode=ModInd;
         END
        break;
       case ModSub:
        if ((Circ) OR (BitRev)) WrError(1350);
        else
         BEGIN
	  switch (Disp)
           BEGIN
	    case -2: AdrPart=0x8800; break;
	    case -1: AdrPart=0x4800; break;
	    case  0: AdrPart=0xc000; break;
	    default: AdrPart=0x0800+Disp;
	   END
	  AdrPart+=((Word)HReg) << 8; AdrMode=ModInd;
         END
        break;
       case ModPreInc:
        if ((Circ) OR (BitRev)) WrError(1350);
        else
         BEGIN
	  switch (Disp)
           BEGIN
	    case -2: AdrPart=0x9000; break;
	    case -1: AdrPart=0x5000; break;
	    default: AdrPart=0x1000+Disp;
	   END
	  AdrPart+=((Word)HReg) << 8; AdrMode=ModInd;
         END
        break;
       case ModPreDec:
        if ((Circ) OR (BitRev)) WrError(1350);
        else
         BEGIN
	  switch (Disp)
           BEGIN
	    case -2: AdrPart=0x9800; break;
	    case -1: AdrPart=0x5800; break;
	    default: AdrPart=0x1800+Disp;
	   END
	  AdrPart+=((Word)HReg) << 8; AdrMode=ModInd;
         END
        break;
       case ModPostInc:
        if (BitRev)
         BEGIN
  	  if (Disp!=-1) WrError(1350);
 	  else
 	   BEGIN
 	    AdrPart=0xc800+(((Word)HReg) << 8); AdrMode=ModInd;
 	   END
         END
        else
         BEGIN
 	  switch (Disp)
           BEGIN
 	    case -2: AdrPart=0xa000; break;
 	    case -1: AdrPart=0x6000; break;
 	    default: AdrPart=0x2000+Disp;
 	   END
 	  if (Circ) AdrPart+=0x1000;
 	  AdrPart+=((Word)HReg) << 8; AdrMode=ModInd;
         END
        break;
       case ModPostDec:
        if (BitRev) WrError(1350);
        else
         BEGIN
  	  switch (Disp)
           BEGIN
 	    case -2: AdrPart=0xa800; break;
 	    case -1: AdrPart=0x6800; break;
 	    default: AdrPart=0x2800+Disp; break;
 	   END
 	  if (Circ) AdrPart+=0x1000;
 	  AdrPart+=((Word)HReg) << 8; AdrMode=ModInd;
         END
        break;
      END

     ChkAdr(Erl); return;
    END

   /* III. absolut */

   if (*Asc=='@')
    BEGIN
     AdrLong=EvalIntExpression(Asc+1,UInt24,&OK);
     if (OK)
      BEGIN
       if ((DPValue!=-1) AND ((AdrLong >> 16)!=DPValue)) WrError(110);
       AdrMode=ModDir; AdrPart=AdrLong & 0xffff;
      END
     ChkAdr(Erl); return;
    END

   /* IV. immediate */

   if (ImmFloat)
    BEGIN
     f=EvalFloatExpression(Asc,Float64,&OK);
     if (OK)
      if (ExtToShort(f,&fi))
       BEGIN
	AdrPart=fi; AdrMode=ModImm;
       END
    END
   else
    BEGIN
     AdrPart=EvalIntExpression(Asc,Int16,&OK);
     if (OK)
      BEGIN
       AdrPart&=0xffff; AdrMode=ModImm;
      END
    END

   ChkAdr(Erl);
END

	static Word EffPart(Byte Mode, Word Part)
BEGIN
   switch (Mode)
    BEGIN
     case ModReg: return Lo(Part);
     case ModInd: return Hi(Part);
     default: WrError(10000); return 0;
    END
END

/*-------------------------------------------------------------------------*/
/* Code-Erzeugung */

	static Boolean DecodePseudo(void)
BEGIN
#define ASSUME3203Count 1
   static ASSUMERec ASSUME3203s[ASSUME3203Count]=
                 {{"DP", &DPValue, -1, 0xff, 0x100}};

   Boolean OK;
   int z,z2;
   LongInt Size;
   Double f;
   TempResult t;

   if (Memo("ASSUME"))
    BEGIN
     CodeASSUME(ASSUME3203s,ASSUME3203Count);
     return True;
    END

   if (Memo("SINGLE"))
    BEGIN
     if (ArgCnt==0) WrError(1110);
     else
      BEGIN
       OK=True;
       for (z=1; z<=ArgCnt; z++)
	if (OK)
	 BEGIN
	  f=EvalFloatExpression(ArgStr[z],Float64,&OK);
	  if (OK)
	   OK=OK AND ExtToSingle(f,DAsmCode+(CodeLen++));
	 END
       if (NOT OK) CodeLen=0;
      END
     return True;
    END

   if (Memo("EXTENDED"))
    BEGIN
     if (ArgCnt==0) WrError(1110);
     else
      BEGIN
       OK=True;
       for (z=1; z<=ArgCnt; z++)
	if (OK)
	 BEGIN
	  f=EvalFloatExpression(ArgStr[z],Float64,&OK);
	  if (OK)
	   OK=OK AND ExtToExt(f,DAsmCode+CodeLen+1,DAsmCode+CodeLen);
	  CodeLen+=2;
	 END
       if (NOT OK) CodeLen=0;
      END
     return True;
    END

   if (Memo("WORD"))
    BEGIN
     if (ArgCnt==0) WrError(1110);
     else
      BEGIN
       OK=True;
       for (z=1; z<=ArgCnt; z++)
	if (OK) DAsmCode[CodeLen++]=EvalIntExpression(ArgStr[z],Int32,&OK);
       if (NOT OK) CodeLen=0;
      END
     return True;
    END

   if (Memo("DATA"))
    BEGIN
     if (ArgCnt==0) WrError(1110);
     else
      BEGIN
       OK=True;
       for (z=1; z<=ArgCnt; z++)
	if (OK)
	 BEGIN
	  EvalExpression(ArgStr[z],&t);
	  switch (t.Typ)
           BEGIN
	    case TempInt:
#ifdef HAS64
             if (NOT RangeCheck(t.Contents.Int,Int32))
              BEGIN
               OK=False; WrError(1320);
              END
             else
#endif
	      DAsmCode[CodeLen++]=t.Contents.Int;
	     break;
	    case TempFloat:
	     if (NOT ExtToSingle(t.Contents.Float,DAsmCode+(CodeLen++))) OK=False;
             break;
	    case TempString:
	     for (z2=0; z2<strlen(t.Contents.Ascii); z2++)
	      BEGIN
	       if ((z2 & 3)==0) DAsmCode[CodeLen++]=0;
	       DAsmCode[CodeLen-1]+=
		  (((LongWord)CharTransTable[((usint)t.Contents.Ascii[z2])&0xff])) << (8*(3-(z2 & 3)));
	      END
	     break;
	    case TempNone:
             OK=False;
	   END
	 END
       if (NOT OK) CodeLen=0;
      END
     return True;
    END

   if (Memo("BSS"))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else
      BEGIN
       FirstPassUnknown=False;
       Size=EvalIntExpression(ArgStr[1],UInt24,&OK);
       if (FirstPassUnknown) WrError(1820);
       if ((OK) AND (NOT FirstPassUnknown))
	BEGIN
	 DontPrint=True;
	 CodeLen=Size;
	 BookKeeping();
	END
      END
     return True;
    END

   return False;
END

	static void JudgePar(GenOrder *Prim, int Sec, Byte *ErgMode, Byte *ErgCode)
BEGIN
   if (Sec>3) *ErgMode=3;
   else if (Prim->May3) *ErgMode=1;
   else *ErgMode=2;
   if (*ErgMode==2) *ErgCode=Prim->PCodes[Sec];
	       else *ErgCode=Prim->P3Codes[Sec];
END

	static LongWord EvalAdrExpression(char *Asc, Boolean *OK)
BEGIN
   if (*Asc=='@') strcpy(Asc,Asc+1);
   return EvalIntExpression(Asc,UInt24,OK);
END

	static void SwapMode(ShortInt *M1, ShortInt *M2)
BEGIN
   AdrMode=(*M1); *M1=(*M2); *M2=AdrMode;
END

	static void SwapPart(Word *P1, Word *P2)
BEGIN
   AdrPart=(*P1); *P1=(*P2); *P2=AdrPart;
END

	static void MakeCode_3203X(void)
BEGIN
   Boolean OK,Is3;
   Byte HReg,HReg2,Sum;
   int z,z3,l;
   LongInt AdrLong,DFlag,Disp;
   String HOp,Form;

   CodeLen=0; DontPrint=False;

   ThisPar=(strcmp(LabPart,"||")==0);
   if ((strlen(OpPart)>2) AND (strncmp(OpPart,"||",2)==0))
    BEGIN
     ThisPar=True; strcpy(OpPart,OpPart+2);
    END
   if ((NOT NextPar) AND (ThisPar))
    BEGIN
     WrError(1950); return;
    END
   ARs=0;

   /* zu ignorierendes */

   if (Memo("")) return;

   /* Pseudoanweisungen */

   if (DecodePseudo()) return;

   /* ohne Argument */

   for (z=0; z<FixedOrderCount; z++)
    if (Memo(FixedOrders[z].Name))
     BEGIN
      if (ArgCnt!=0) WrError(1110);
      else if (ThisPar) WrError(1950);
      else
       BEGIN
        DAsmCode[0]=FixedOrders[z].Code; CodeLen=1;
       END
      NextPar=False; return;
     END

   /* Arithmetik/Logik */

   for (z=0; z<GenOrderCount; z++)
    if ((strncmp(OpPart,GenOrders[z].Name,GenOrders[z].NameLen)==0)
    AND ((OpPart[GenOrders[z].NameLen]=='\0') OR (OpPart[GenOrders[z].NameLen]=='3')))
     BEGIN
      NextPar=False;
      /* Argumentzahl abgleichen */
      if (ArgCnt==1)
       if (GenOrders[z].May1)
        BEGIN
         ArgCnt=2; strcpy(ArgStr[2],ArgStr[1]);
        END
       else
        BEGIN
         WrError(1110); return;
        END
      if ((ArgCnt==3) AND (OpPart[strlen(OpPart)-1]!='3')) strcat(OpPart,"3");
      Is3=(OpPart[strlen(OpPart)-1]=='3');
      if ((GenOrders[z].SwapOps) AND (NOT Is3))
       BEGIN
        strcpy(ArgStr[3],ArgStr[1]); 
        strcpy(ArgStr[1],ArgStr[2]);
        strcpy(ArgStr[2],ArgStr[3]);
       END
      if ((Is3) AND (ArgCnt==2))
       BEGIN
        ArgCnt=3; strcpy(ArgStr[3],ArgStr[2]);
       END
      if ((ArgCnt<2) OR (ArgCnt>3) OR ((Is3) AND (NOT GenOrders[z].May3)))
       BEGIN
        WrError(1110); return;
       END
      /* Argumente parsen */
      if (Is3)
       BEGIN
        if (Memo("TSTB3"))
         BEGIN
          CurrDestMode=ModReg; CurrDestPart=0;
         END
        else
         BEGIN
          DecodeAdr(ArgStr[3],MModReg,GenOrders[z].ImmFloat);
          if (AdrMode==ModNone) return;
          CurrDestMode=AdrMode; CurrDestPart=AdrPart;
         END
        DecodeAdr(ArgStr[2],MModReg+MModInd,GenOrders[z].ImmFloat);
        if (AdrMode==ModNone) return;
        if ((AdrMode==ModInd) AND ((AdrPart & 0xe000)==0) AND (Lo(AdrPart)!=1))
         BEGIN
          WrError(1350); return;
         END
        CurrSrc2Mode=AdrMode; CurrSrc2Part=AdrPart;
        DecodeAdr(ArgStr[1],MModReg+MModInd,GenOrders[z].ImmFloat);
        if (AdrMode==ModNone) return;
        if ((AdrMode==ModInd) AND ((AdrPart & 0xe000)==0) AND (Lo(AdrPart)!=1))
         BEGIN
          WrError(1350); return;
         END
        CurrSrc1Mode=AdrMode; CurrSrc1Part=AdrPart;
       END
      else /* NOT Is3 */
       BEGIN
        DecodeAdr(ArgStr[1],MModDir+MModInd+((GenOrders[z].OnlyMem)?0:MModReg+MModImm),GenOrders[z].ImmFloat);
        if (AdrMode==ModNone) return;
        CurrSrc1Mode=AdrMode; CurrSrc1Part=AdrPart;
        DecodeAdr(ArgStr[2],MModReg+MModInd,GenOrders[z].ImmFloat);
        switch (AdrMode)
         BEGIN
          case ModReg:
           CurrDestMode=AdrMode; CurrDestPart=AdrPart;
           CurrSrc2Mode=CurrSrc1Mode; CurrSrc2Part=CurrSrc1Part;
           break;
          case ModInd:
           if (((strcmp(OpPart,"TSTB")!=0) AND (strcmp(OpPart,"CMPI")!=0) AND (strcmp(OpPart,"CMPF")!=0))
           OR  ((CurrSrc1Mode==ModDir) OR (CurrSrc1Mode==ModImm))
           OR  ((CurrSrc1Mode==ModInd) AND ((CurrSrc1Part & 0xe000)==0) AND (Lo(CurrSrc1Part)!=1))
           OR  (((AdrPart & 0xe000)==0) AND (Lo(AdrPart)!=1)))
            BEGIN
             WrError(1350); return;
            END
           else
            BEGIN
             Is3=True; CurrDestMode=ModReg; CurrDestPart=0;
             CurrSrc2Mode=AdrMode; CurrSrc2Part=AdrPart;
            END
           break;
          case ModNone: 
           return;
         END
       END
      /* auswerten: parallel... */
      if (ThisPar)
       BEGIN
        /* in Standardreihenfolge suchen */
        if (PrevOp[strlen(PrevOp)-1]=='3') HReg=GenOrders[z2].Par3Mask;
        else HReg=GenOrders[z2].ParMask;
        z3=0;
        while ((z3<ParOrderCount) AND ((NOT Odd(HReg)) OR (strcmp(ParOrders[z3],OpPart)!=0)))
         BEGIN
          z3++; HReg>>=1;
         END
        if (z3<ParOrderCount) JudgePar(GenOrders+z2,z3,&HReg,&HReg2);
        /* in gedrehter Reihenfolge suchen */
        else
         BEGIN
          if (OpPart[strlen(OpPart)-1]=='3') HReg=GenOrders[z].Par3Mask;
          else HReg=GenOrders[z].ParMask;
          z3=0;
          while ((z3<ParOrderCount) AND ((NOT Odd(HReg)) OR (strcmp(ParOrders[z3],PrevOp)!=0)))
           BEGIN
            z3++; HReg>>=1;
           END
          if (z3<ParOrderCount)
           BEGIN
            JudgePar(GenOrders+z,z3,&HReg,&HReg2);
            SwapMode(&CurrDestMode,&PrevDestMode);
            SwapMode(&CurrSrc1Mode,&PrevSrc1Mode);
            SwapMode(&CurrSrc2Mode,&PrevSrc2Mode);
            SwapPart(&CurrDestPart,&PrevDestPart);
            SwapPart(&CurrSrc1Part,&PrevSrc1Part);
            SwapPart(&CurrSrc2Part,&PrevSrc2Part);
           END
          else
           BEGIN
            WrError(1950); return;
           END
         END
        /* mehrfache Registernutzung ? */
        for (z3=0; z3<8; z3++)
         if ((ARs & PrevARs & (1l << z3))!=0)
          BEGIN
           sprintf(Form,"AR%d",z3); WrXError(210,Form);
          END
        /* 3 Basisfaelle */
        switch (HReg)
         BEGIN
          case 1:
           if ((strcmp(PrevOp,"LSH3")==0) OR (strcmp(PrevOp,"ASH3")==0) OR (strcmp(PrevOp,"SUBF3")==0) OR (strcmp(PrevOp,"SUBI3")==0))
            BEGIN
             SwapMode(&PrevSrc1Mode,&PrevSrc2Mode);
             SwapPart(&PrevSrc1Part,&PrevSrc2Part);
            END
           if ((PrevDestPart>7) OR (CurrDestPart>7))
            BEGIN
             WrError(1445); return;
            END
           /* Bei Addition und Multiplikation Kommutativitaet nutzen */
           if  ((PrevSrc2Mode==ModInd) AND (PrevSrc1Mode==ModReg)
            AND ((strncmp(PrevOp,"ADD",3)==0) OR (strncmp(PrevOp,"MPY",3)==0)
              OR (strncmp(PrevOp,"AND",3)==0) OR (strncmp(PrevOp,"XOR",3)==0)
              OR (strncmp(PrevOp,"OR",2)==0)))
            BEGIN
             SwapMode(&PrevSrc1Mode,&PrevSrc2Mode);
             SwapPart(&PrevSrc1Part,&PrevSrc2Part);
            END
           if ((PrevSrc2Mode!=ModReg) OR (PrevSrc2Part>7)
            OR (PrevSrc1Mode!=ModInd) OR (CurrSrc1Mode!=ModInd))
            BEGIN
             WrError(1355); return;
            END
           RetractWords(1);
           DAsmCode[0]=0xc0000000+(((LongWord)HReg2) << 25)
		      +(((LongWord)PrevDestPart) << 22)
		      +(((LongWord)PrevSrc2Part) << 19)
		      +(((LongWord)CurrDestPart) << 16)
		      +(CurrSrc1Part & 0xff00)+Hi(PrevSrc1Part);
           CodeLen=1; NextPar=False;
           break;
          case 2:
           if ((PrevDestPart>7) OR (CurrDestPart>7))
            BEGIN
             WrError(1445); return;
            END
           if ((PrevSrc1Mode!=ModInd) OR (CurrSrc1Mode!=ModInd))
            BEGIN
             WrError(1355); return;
            END
           RetractWords(1);
           DAsmCode[0]=0xc0000000+(((LongWord)HReg2) << 25)
		      +(((LongWord)PrevDestPart) << 22)
		      +(CurrSrc1Part & 0xff00)+Hi(PrevSrc1Part);
           if ((strcmp(PrevOp,OpPart)==0) AND (*OpPart=='L'))
            BEGIN
             DAsmCode[0]+=((LongWord)CurrDestPart) << 19;
             if (PrevDestPart==CurrDestPart) WrError(140);
            END
           else
            DAsmCode[0]+=((LongWord)CurrDestPart) << 16;
           CodeLen=1; NextPar=False;
           break;
          case 3:
           if ((PrevDestPart>1) OR (CurrDestPart<2) OR (CurrDestPart>3))
            BEGIN
             WrError(1445); return;
            END
           Sum=0;
           if (PrevSrc1Mode==ModInd) Sum++;
           if (PrevSrc2Mode==ModInd) Sum++;
           if (CurrSrc1Mode==ModInd) Sum++;
           if (CurrSrc2Mode==ModInd) Sum++;
           if (Sum!=2)
            BEGIN
             WrError(1355); return;
            END
           RetractWords(1);
           DAsmCode[0]=0x80000000+(((LongWord)HReg2) << 26)
	     	      +(((LongWord)PrevDestPart & 1) << 23)
		      +(((LongWord)CurrDestPart & 1) << 22);
           CodeLen=1;
           if (CurrSrc2Mode==ModReg)
            if (CurrSrc1Mode==ModReg)
             BEGIN
              DAsmCode[0]+=((LongWord)0x00000000)
                          +(((LongWord)CurrSrc2Part) << 19)
                          +(((LongWord)CurrSrc1Part) << 16)
                          +(PrevSrc2Part & 0xff00)+Hi(PrevSrc1Part);
             END
            else
             BEGIN
              DAsmCode[0]+=((LongWord)0x03000000)
                          +(((LongWord)CurrSrc2Part) << 16)
                          +Hi(CurrSrc1Part);
              if (PrevSrc1Mode==ModReg)
               DAsmCode[0]+=(((LongWord)PrevSrc1Part) << 19)+(PrevSrc2Part & 0xff00);
              else
               DAsmCode[0]+=(((LongWord)PrevSrc2Part) << 19)+(PrevSrc1Part & 0xff00);
             END
           else
            if (CurrSrc1Mode==ModReg)
             BEGIN
              DAsmCode[0]+=((LongWord)0x01000000)
                          +(((LongWord)CurrSrc1Part) << 16)
                          +Hi(CurrSrc2Part);
              if (PrevSrc1Mode==ModReg)
               DAsmCode[0]+=(((LongWord)PrevSrc1Part) << 19)+(PrevSrc2Part & 0xff00);
              else
               DAsmCode[0]+=(((LongWord)PrevSrc2Part) << 19)+(PrevSrc1Part & 0xff00);
             END
            else
             BEGIN
              DAsmCode[0]+=((LongWord)0x02000000)
                          +(((LongWord)PrevSrc2Part) << 19)
                          +(((LongWord)PrevSrc1Part) << 16)
                          +(CurrSrc2Part & 0xff00)+Hi(CurrSrc1Part);
             END
           break;
         END
       END
      /* ...sequentiell */
      else
       BEGIN
        PrevSrc1Mode=CurrSrc1Mode; PrevSrc1Part=CurrSrc1Part;
        PrevSrc2Mode=CurrSrc2Mode; PrevSrc2Part=CurrSrc2Part;
        PrevDestMode=CurrDestMode; PrevDestPart=CurrDestPart;
        strcpy(PrevOp,OpPart); PrevARs=ARs; z2=z;
        if (Is3)
         DAsmCode[0]=0x20000000+(((LongWord)GenOrders[z].Code3) << 23)
                    +(((LongWord)CurrDestPart) << 16)
       	            +(((LongWord)CurrSrc2Mode) << 20)+(EffPart(CurrSrc2Mode,CurrSrc2Part) << 8)
       	            +(((LongWord)CurrSrc1Mode) << 21)+EffPart(CurrSrc1Mode,CurrSrc1Part);
        else
         DAsmCode[0]=0x00000000+(((LongWord)GenOrders[z].Code) << 23)
       	            +(((LongWord)CurrSrc1Mode) << 21)+CurrSrc1Part
       	            +(((LongWord)CurrDestPart) << 16);
        CodeLen=1; NextPar=True;
       END
      return;
     END

   for (z=0; z<RotOrderCount; z++)
    if (Memo(RotOrders[z]))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else if (ThisPar) WrError(1950);
      else if (NOT DecodeReg(ArgStr[1],&HReg)) WrError(1350);
      else
       BEGIN
	DAsmCode[0]=0x11e00000+(((LongWord)z) << 23)+(((LongWord)HReg) << 16);
	CodeLen=1;
       END
      NextPar=False; return;
     END

   for (z=0; z<StkOrderCount; z++)
    if (Memo(StkOrders[z]))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else if (ThisPar) WrError(1950);
      else if (NOT DecodeReg(ArgStr[1],&HReg)) WrError(1350);
      else
       BEGIN
	DAsmCode[0]=0x0e200000+(((LongWord)z) << 23)+(((LongWord)HReg) << 16);
	CodeLen=1;
       END
      NextPar=False; return;
     END

   /* Datentransfer */

   if ((strncmp(OpPart,"LDI",3)==0) OR (strncmp(OpPart,"LDF",3)==0))
    BEGIN
     strcpy(HOp,OpPart); strcpy(OpPart,OpPart+3);
     for (z=0; z<ConditionCount; z++)
      if (Memo(Conditions[z].Name))
       BEGIN
	if (ArgCnt!=2) WrError(1110);
	else if (ThisPar) WrError(1950);
	else
	 BEGIN
	  DecodeAdr(ArgStr[2],MModReg,False);
	  if (AdrMode!=ModNone)
	   BEGIN
	    HReg=AdrPart;
	    DecodeAdr(ArgStr[1],MModReg+MModDir+MModInd+MModImm,HOp[2]=='F');
	    if (AdrMode!=ModNone)
	     BEGIN
	      DAsmCode[0]=0x40000000+(((LongWord)HReg) << 16)
			 +(((LongWord)Conditions[z].Code) << 23)
			 +(((LongWord)AdrMode) << 21)+AdrPart;
	      if (HOp[2]=='I') DAsmCode[0]+=0x10000000;
	      CodeLen=1;
	     END
	   END
	 END
	NextPar=False; return;
       END
     WrXError(1200,HOp); NextPar=False; return;
    END

   /* Sonderfall NOP auch ohne Argumente */

   if ((Memo("NOP")) AND (ArgCnt==0))
    BEGIN
     CodeLen=1; DAsmCode[0]=NOPCode; return;
    END

   /* Sonderfaelle */

   for (z=0; z<SingOrderCount; z++)
    if (Memo(SingOrders[z].Name))
     BEGIN
      if (ArgCnt!=1) WrError(1110);
      else if (ThisPar) WrError(1950);
      else
       BEGIN
	DecodeAdr(ArgStr[1],SingOrders[z].Mask,False);
	if (AdrMode!=ModNone)
	 BEGIN
	  DAsmCode[0]=SingOrders[z].Code+(((LongWord)AdrMode) << 21)+AdrPart;
	  CodeLen=1;
	 END
       END;
      NextPar=False; return;
     END

   if (Memo("LDP"))
    BEGIN
     if ((ArgCnt!=1) AND (ArgCnt!=2)) WrError(1110);
     else if (ThisPar) WrError(1950);
     else if ((ArgCnt==2) AND (strcasecmp(ArgStr[2],"DP")!=0)) WrError(1350);
     else
      BEGIN
       AdrLong=EvalAdrExpression(ArgStr[1],&OK);
       if (OK)
	BEGIN
	 DAsmCode[0]=0x08700000+(AdrLong >> 16);
	 CodeLen=1;
	END
      END
     NextPar=False; return;
    END

   /* Schleifen */

   if (Memo("RPTB"))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else if (ThisPar) WrError(1950);
     else
      BEGIN
       AdrLong=EvalAdrExpression(ArgStr[1],&OK);
       if (OK)
	BEGIN
	 DAsmCode[0]=0x64000000+AdrLong;
	 CodeLen=1;
	END
      END
     NextPar=False; return;
    END

   /* Spruenge */

   if ((Memo("BR")) OR (Memo("BRD")) OR (Memo("CALL")))
    BEGIN
     if (ArgCnt!=1) WrError(1110);
     else if (ThisPar) WrError(1950);
     else
      BEGIN
       AdrLong=EvalAdrExpression(ArgStr[1],&OK);
       if (OK)
	BEGIN
	 DAsmCode[0]=0x60000000+AdrLong;
	 if (Memo("BRD")) DAsmCode[0]+=0x01000000;
	 else if (Memo("CALL")) DAsmCode[0]+=0x02000000;
	 CodeLen=1;
	END
      END
     NextPar=False; return;
    END

   if (*OpPart=='B')
    BEGIN
     strcpy(HOp,OpPart);
     strcpy(OpPart,OpPart+1);
     l=strlen(OpPart);
     if ((l>=1) AND (OpPart[l-1]=='D'))
      BEGIN
       OpPart[l-1]='\0'; DFlag=1l << 21;
       Disp=3;
      END
     else
      BEGIN
       DFlag=0; Disp=1;
      END
     for (z=0; z<ConditionCount; z++)
      if (Memo(Conditions[z].Name))
       BEGIN
	if (ArgCnt!=1) WrError(1110);
        else if (ThisPar) WrError(1950);
	else if (DecodeReg(ArgStr[1],&HReg))
	 BEGIN
	  DAsmCode[0]=0x68000000+(((LongWord)Conditions[z].Code) << 16)+DFlag+HReg;
	  CodeLen=1;
	 END
	else
	 BEGIN
          AdrLong=EvalAdrExpression(ArgStr[1],&OK)-(EProgCounter()+Disp);
	  if (OK)
	   if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fffl) OR (AdrLong<-0x8000l))) WrError(1370);
	   else
	    BEGIN
	     DAsmCode[0]=0x6a000000+(((LongWord)Conditions[z].Code) << 16)+DFlag+(AdrLong & 0xffff);
	     CodeLen=1;
	    END
	 END
	NextPar=False; return;
       END
     WrXError(1200,HOp); NextPar=False; return;
    END

   if (strncmp(OpPart,"CALL",4)==0)
    BEGIN
     strcpy(HOp,OpPart); strcpy(OpPart,OpPart+4);
     for (z=0; z<ConditionCount; z++)
      if (Memo(Conditions[z].Name))
       BEGIN
	if (ArgCnt!=1) WrError(1110);
	else if (ThisPar) WrError(1950);
	else if (DecodeReg(ArgStr[1],&HReg))
	 BEGIN
	  DAsmCode[0]=0x70000000+(((LongWord)Conditions[z].Code) << 16)+HReg;
	  CodeLen=1;
	 END
	else
	 BEGIN
	  AdrLong=EvalAdrExpression(ArgStr[1],&OK)-(EProgCounter()+1);
	  if (OK)
	   if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fffl) OR (AdrLong<-0x8000l))) WrError(1370);
	   else
	    BEGIN
	     DAsmCode[0]=0x72000000+(((LongWord)Conditions[z].Code) << 16)+(AdrLong & 0xffff);
	     CodeLen=1;
	    END
	 END
	NextPar=False; return;
       END
     WrXError(1200,HOp); NextPar=False; return;
    END

   if (strncmp(OpPart,"DB",2)==0)
    BEGIN
     strcpy(HOp,OpPart);
     strcpy(OpPart,OpPart+2);
     l=strlen(OpPart);
     if ((l>=1) AND (OpPart[l-1]=='D'))
      BEGIN
       OpPart[l-1]='\0'; DFlag=1l << 21;
       Disp=3;
      END
     else
      BEGIN
       DFlag=0; Disp=1;
      END
     for (z=0; z<ConditionCount; z++)
      if (Memo(Conditions[z].Name))
       BEGIN
	if (ArgCnt!=2) WrError(1110);
	else if (ThisPar) WrError(1950);
	else if (NOT DecodeReg(ArgStr[1],&HReg2)) WrError(1350);
	else if ((HReg2<8) OR (HReg2>15)) WrError(1350);
	else
	 BEGIN
	  HReg2-=8;
	  if (DecodeReg(ArgStr[2],&HReg))
	   BEGIN
	    DAsmCode[0]=0x6c000000
		       +(((LongWord)Conditions[z].Code) << 16)
		       +DFlag
		       +(((LongWord)HReg2) << 22)
		       +HReg;
	    CodeLen=1;
	   END
	  else
	   BEGIN
            AdrLong=EvalAdrExpression(ArgStr[2],&OK)-(EProgCounter()+Disp);
	    if (OK)
	     if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fffl) OR (AdrLong<-0x8000l))) WrError(1370);
	     else
	      BEGIN
	       DAsmCode[0]=0x6e000000
			  +(((LongWord)Conditions[z].Code) << 16)
			  +DFlag
			  +(((LongWord)HReg2) << 22)
			  +(AdrLong & 0xffff);
	       CodeLen=1;
	      END
	   END
	 END
	NextPar=False; return;
       END
     WrXError(1200,HOp); NextPar=False; return;
    END

   if ((strncmp(OpPart,"RETI",4)==0) OR (strncmp(OpPart,"RETS",4)==0))
    BEGIN
     DFlag=(OpPart[3]=='S')?(1l << 23):(0);
     strcpy(HOp,OpPart); strcpy(OpPart,OpPart+4);
     for (z=0; z<ConditionCount; z++)
      if (Memo(Conditions[z].Name))
       BEGIN
	if (ArgCnt!=0) WrError(1110);
	else if (ThisPar) WrError(1950);
	else
	 BEGIN
	  DAsmCode[0]=0x78000000+DFlag+(((LongWord)Conditions[z].Code) << 16);
	  CodeLen=1;
	 END
	NextPar=False; return;
       END
     WrXError(1200,HOp); NextPar=False; return;
    END

   if (strncmp(OpPart,"TRAP",4)==0)
    BEGIN
     strcpy(HOp,OpPart); strcpy(OpPart,OpPart+4);
     for (z=0; z<ConditionCount; z++)
      if (Memo(Conditions[z].Name))
       BEGIN
	if (ArgCnt!=1) WrError(1110);
	else if (ThisPar) WrError(1950);
	else
	 BEGIN
	  HReg=EvalIntExpression(ArgStr[1],UInt4,&OK);
	  if (OK)
	   BEGIN
	    DAsmCode[0]=0x74000000+HReg+(((LongWord)Conditions[z].Code) << 16);
	    CodeLen=1;
	   END
	 END
	NextPar=False; return;
       END
     WrXError(1200,HOp); NextPar=False; return;
    END

   WrXError(1200,OpPart); NextPar=False;
END

	static void InitCode_3203x(void)
BEGIN
   SaveInitProc();
   DPValue=0;
END

	static Boolean IsDef_3203X(void)
BEGIN
   return (strcmp(LabPart,"||")==0);
END

	static void SwitchFrom_3203X(void)
BEGIN
   DeinitFields();
END

	static void SwitchTo_3203X(void)
BEGIN
   TurnWords=False; ConstMode=ConstModeIntel; SetIsOccupied=False;

   PCSymbol="$"; HeaderID=0x76; NOPCode=0x0c800000;
   DivideChars=","; HasAttrs=False;

   ValidSegs=1<<SegCode;
   Grans[SegCode]=4; ListGrans[SegCode]=4; SegInits[SegCode]=0;
   SegLimits[SegCode] = 0xffffffl;

   MakeCode=MakeCode_3203X; IsDef=IsDef_3203X;
   SwitchFrom=SwitchFrom_3203X; InitFields(); NextPar=False;
END

	void code3203x_init(void)
BEGIN
   CPU32030=AddCPU("320C30",SwitchTo_3203X);
   CPU32031=AddCPU("320C31",SwitchTo_3203X);

   SaveInitProc=InitPassProc; InitPassProc=InitCode_3203x;
END