asl/code77230.c

/* code77230.c */
/*****************************************************************************/
/* Makroassembler AS                                                         */
/*                                                                           */
/* Codegenerator NEC uPD77230                                                */
/*                                                                           */
/* Historie: 13. 9.1998 Grundsteinlegung                                     */
/*           14. 9.1998 LDI/Destregs getestet                                */
/*           16. 9.1998 das instruktionelle Kleingemuese begonnen            */
/*           19. 9.1998 restliche CPU-Instruktionen                          */
/*           27. 9.1998 DW-Anweisung                                         */
/*           28. 9.1998 String-Argument fuer DW                              */
/*                      DS                                                   */
/*            2. 1.1999 ChkPC-Anpassung                                      */
/*                                                                           */
/*****************************************************************************/

/*---------------------------------------------------------------------------*/
/* Includes */

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

#include "strutil.h"
#include "nls.h"
#include "endian.h"

#include "asmdef.h"
#include "asmsub.h"
#include "asmpars.h"
#include "asmitree.h"
#include "headids.h"

/*---------------------------------------------------------------------------*/
/* Definitionen */

#define SrcRegCnt 32
#define DestRegCnt 32
#define ALUSrcRegCnt 4

#define JmpOrderCnt 32
#define ALU1OrderCnt 15
#define ALU2OrderCnt 10

#define CaseCnt 17

typedef struct
         {
          LongWord Code;
         } FixedOrder;

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

enum {InstrLDI, InstrBranch,
      InstrALU, InstrMove, 
      InstrM0, InstrM1, InstrDP0, InstrDP1,
      InstrEA, InstrRP, InstrFC, InstrLC,
      InstrBASE0, InstrBASE1, InstrRPC,
      InstrP2, InstrP3, InstrEM, InstrBM, 
      InstrL, InstrRW, InstrWT, InstrNF, InstrWI,
      InstrFIS, InstrFD, InstrSHV, InstrRPS, InstrNAL, InstrCnt};

static LongWord CaseMasks[CaseCnt]=
                {(1l<<InstrLDI),
                 (1l<<InstrBranch)|(1l<<InstrMove),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrM0)|(1l<<InstrM1)|(1l<<InstrDP0)|(1l<<InstrDP1),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrEA)|(1l<<InstrDP0)|(1l<<InstrDP1),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRP)|(1l<<InstrM0)|(1l<<InstrDP0)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRP)|(1l<<InstrM1)|(1l<<InstrDP1)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRP)|(1l<<InstrM0)|(1l<<InstrM1)|(1l<<InstrL)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrBASE0)|(1l<<InstrBASE1)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRPC)|(1l<<InstrL)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrP3)|(1l<<InstrP2)|(1l<<InstrEM)|(1l<<InstrBM)|(1l<<InstrL)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRW)|(1l<<InstrL)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrWT)|(1l<<InstrL)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrNF)|(1l<<InstrWI)|(1l<<InstrL)|(1l<<InstrFC),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrFIS)|(1l<<InstrFD)|(1l<<InstrL),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrSHV),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRPS),
                 (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrNAL)
                };

static CPUVar CPU77230;
static LongWord InstrMask;
static Boolean Error;
static LongWord *InstrComps,*InstrDefs;

static PInstTable InstTable;
static Register *SrcRegs,*ALUSrcRegs,*DestRegs;
static FixedOrder *JmpOrders,*ALU1Orders,*ALU2Orders;

/*---------------------------------------------------------------------------*/
/* Hilfsroutinen */

static int DiscCnt,SplittedArg;
static char *DiscPtr;

	static Boolean SplitArgs(int Count)
BEGIN
   char *p,*p1,*p2;

   SplittedArg=DiscCnt=Count;

   if (Count==0)
    BEGIN
     if (ArgCnt>0)
      BEGIN
       DiscPtr=ArgStr[1]-1;
       SplittedArg=1;
      END
     else DiscPtr=Nil;
     return True;
    END

   if (ArgCnt<Count) 
    BEGIN
     WrError(1110); Error=True; return False;
    END

   for (p=ArgStr[SplittedArg]; isspace(((usint)*p)&0xff); p++);
   p1=QuotPos(p,' ');
   p2=QuotPos(p,'\t');
   if ((p1==Nil) OR ((p2!=Nil) AND (p2<p1))) DiscPtr=p2;
   else DiscPtr=p1;
   if (DiscPtr!=Nil) *(DiscPtr)='\0';

   return True;
END

	static void DiscardArgs(void)
BEGIN
   char *p,*p2;
   int z;
   Boolean Eaten;

   if (DiscPtr!=Nil)
    BEGIN
     for (p=DiscPtr+1; isspace(((usint)*p)&0xff); p++)
      if (*p=='\0') break;
     for (p2=p; NOT isspace(((usint)*p2)&0xff); p2++)
      if (*p2=='\0') break;
     Eaten=(*p2=='\0'); *p2='\0';
     strcpy(OpPart,p); NLS_UpString(OpPart);
     if (Eaten)
      BEGIN
       for (z=1; z<ArgCnt; z++)
        strcpy(ArgStr[z],ArgStr[z+1]);
       ArgCnt--;
      END
     else
      BEGIN
       if (p2!=Nil)
        for (p2++; isspace(((usint)*p2)&0xff); p2++);
       strcpy(ArgStr[SplittedArg],p2);
      END
    END
   else *OpPart='\0';
   if (DiscCnt>0)
    BEGIN
     for (z=0; z<=ArgCnt-DiscCnt; z++)
      strcpy(ArgStr[z+1],ArgStr[z+DiscCnt]);
     ArgCnt-=DiscCnt-1;
    END
END

	static void AddComp(int Index, LongWord Value)
BEGIN
   if ((InstrMask&(1l<<Index))!=0)
    BEGIN
     WrError(1355); Error=True;
    END
   else
    BEGIN
     InstrMask|=(1l<<Index); InstrComps[Index]=Value;
    END;
END

	static Boolean DecodeReg(char *Asc, LongWord *Erg, Register *Regs, int Cnt)
BEGIN
   int z;

   for (z=0; z<Cnt; z++)
    if (strcasecmp(Asc,Regs[z].Name)==0)
     BEGIN
      *Erg=Regs[z].Code; return True;
     END
   return False;
END

/*---------------------------------------------------------------------------*/
/* Dekoder fuer Routinen */

	static void DecodeJmp(Word Index)
BEGIN
   FixedOrder *Op=JmpOrders+Index;
   int acnt=(Memo("RET")) ? 0 : 1;
   LongWord Adr;

   if (NOT SplitArgs(acnt)) return;
   if (acnt==0)
    BEGIN
     Adr=0; Error=True;
    END
   else Adr=EvalIntExpression(ArgStr[1],UInt13,&Error);
   Error=NOT Error;
   if (NOT Error) AddComp(InstrBranch,Op->Code+(Adr << 5));
   DiscardArgs();
END

	static void DecodeMOV(Word Index)
BEGIN
   LongWord DReg,SReg;

   if (NOT SplitArgs(2)) return;
   if (NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt))
    BEGIN
     WrXError(1445,ArgStr[1]); Error=True;
    END
   else if (NOT DecodeReg(ArgStr[2],&SReg,SrcRegs,SrcRegCnt))
    BEGIN
     WrXError(1445,ArgStr[2]); Error=True;
    END
   else AddComp(InstrMove,(SReg<<5)+DReg);
   DiscardArgs();
END

	static void DecodeLDI(Word Index)
BEGIN
   LongWord DReg,Src=0;

   if (NOT SplitArgs(2)) return;
   if (NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt))
    BEGIN
     WrXError(1445,ArgStr[1]); Error=True;
    END
   else Src=EvalIntExpression(ArgStr[2],Int24,&Error);
   Error=NOT Error;
   if (NOT Error) AddComp(InstrLDI,(Src<<5)+DReg);
   DiscardArgs();
END

	static void DecodeNOP(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrALU,0);
   DiscardArgs();
END

	static void DecodeALU1(Word Index)
BEGIN
   FixedOrder *Op=ALU1Orders+Index;
   LongWord DReg;

   if (NOT SplitArgs(1)) return;
   if ((NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt))
    OR (DReg<16) OR (DReg>23))
    BEGIN
     WrXError(1445,ArgStr[1]); Error=True;
    END
   else AddComp(InstrALU,(Op->Code<<17)+(DReg&7));
   DiscardArgs();
END

	static void DecodeALU2(Word Index)             
BEGIN                                                  
   FixedOrder *Op=ALU2Orders+Index;                    
   LongWord DReg,SReg;                                      
                                                       
   if (NOT SplitArgs(2)) return;                       
   if ((NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt))
    OR (DReg<16) OR (DReg>23))                         
    BEGIN                                              
     WrXError(1445,ArgStr[1]); Error=True;             
    END                                                
   else if (NOT DecodeReg(ArgStr[2],&SReg,ALUSrcRegs,ALUSrcRegCnt))
    BEGIN                                              
     WrXError(1445,ArgStr[2]); Error=True;             
    END
   else AddComp(InstrALU,(Op->Code<<17)+(SReg<<3)+(DReg&7));
   DiscardArgs();                                      
END

	static void DecodeM0(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrM0,Index);
   DiscardArgs();
END

	static void DecodeM1(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrM1,Index);
   DiscardArgs();
END

	static void DecodeDP0(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrDP0,Index);
   DiscardArgs();
END  

	static void DecodeDP1(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrDP1,Index);
   DiscardArgs();
END

	static void DecodeEA(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrEA,Index);
   DiscardArgs();
END

        static void DecodeFC(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrFC,Index);
   DiscardArgs();
END

	static void DecodeRP(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrRP,Index);
   DiscardArgs();
END

        static void DecodeL(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrL,Index);
   DiscardArgs();
END

	static void DecodeBASE(Word Index)
BEGIN
   LongWord Value;

   if (NOT SplitArgs(1)) return;
   Value=EvalIntExpression(ArgStr[1],UInt3,&Error); Error=NOT Error;
   if (NOT Error) AddComp(Index,Value);
   DiscardArgs();
END

	static void DecodeRPC(Word Index)
BEGIN
   LongWord Value;

   if (NOT SplitArgs(1)) return;
   FirstPassUnknown=False;
   Value=EvalIntExpression(ArgStr[1],UInt4,&Error);
   if (FirstPassUnknown) Value&=7;
   if (Value>9) Error=True; else Error=NOT Error;
   if (NOT Error) AddComp(InstrRPC,Value);
   DiscardArgs();
END

        static void DecodeP2(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrP2,Index);
   DiscardArgs();
END

        static void DecodeP3(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;
   AddComp(InstrP3,Index);
   DiscardArgs();
END

	static void DecodeBM(Word Index)
BEGIN
   /* Wenn EM-Feld schon da war, muss es EI gewesen sein */

   if (NOT SplitArgs(0)) return;
   if ((InstrMask&(1<<InstrEM))!=0)
    BEGIN
     Error=(InstrComps[InstrEM]==0);
     if (Error) WrError(1355);
     else AddComp(InstrBM,Index);
    END
   else AddComp(InstrBM,Index);
   DiscardArgs();
END

	static void DecodeEM(Word Index)
BEGIN
   /* Wenn BM-Feld schon da war, muss es EI sein */

   if (NOT SplitArgs(0)) return;
   if ((InstrMask&(1<<InstrBM))!=0)
    BEGIN
     Error=(Index==0);
     if (Error) WrError(1355);
     else AddComp(InstrEM,Index);
    END
   else
    BEGIN
     AddComp(InstrEM,Index);
     if (Index==0) InstrComps[InstrBM]=3;
    END
   DiscardArgs();
END

	static void DecodeRW(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return;   
   AddComp(InstrRW,Index);
   DiscardArgs();
END

	static void DecodeWT(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return; 
   AddComp(InstrWT,Index);
   DiscardArgs();
END

	static void DecodeNF(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return; 
   AddComp(InstrNF,Index);
   DiscardArgs();
END

	static void DecodeWI(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return; 
   AddComp(InstrWI,Index);
   DiscardArgs();
END

	static void DecodeFIS(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return; 
   AddComp(InstrFIS,Index);
   DiscardArgs();
END

	static void DecodeFD(Word Index)
BEGIN
   if (NOT SplitArgs(0)) return; 
   AddComp(InstrFD,Index);
   DiscardArgs();
END

	static void DecodeSHV(Word Index)
BEGIN
   LongWord Value;

   if (NOT SplitArgs(1)) return;
   FirstPassUnknown=False;
   Value=EvalIntExpression(ArgStr[1],UInt6,&Error);
   if (FirstPassUnknown) Value&=31;
   if (Value>46) Error=True; else Error=NOT Error;
   if (NOT Error) AddComp(InstrSHV,(Index<<6)+Value);     
   DiscardArgs();
END

	static void DecodeRPS(Word Index)
BEGIN
   LongWord Value;
   
   if (NOT SplitArgs(1)) return;
   Value=EvalIntExpression(ArgStr[1],UInt9,&Error);
   Error=NOT Error;
   if (NOT Error) AddComp(InstrRPS,Value);
   DiscardArgs();
END

	static void DecodeNAL(Word Index)
BEGIN
   LongWord Value;
 
   if (NOT SplitArgs(1)) return;
   FirstPassUnknown=False;
   Value=EvalIntExpression(ArgStr[1],UInt13,&Error);
   if (FirstPassUnknown) Value=(Value&0x1ff)|(EProgCounter()&0x1e00);
   Error=NOT Error;
   if (NOT Error)
    if ((NOT SymbolQuestionable) AND ((Value^EProgCounter())&0x1e00)) WrError(1910);
    else AddComp(InstrNAL,Value&0x1ff);
   DiscardArgs();  
END

	static Boolean DecodePseudo(void)
BEGIN
   int z;
   Boolean OK;
   TempResult t;
   LongWord temp;
   LongInt sign,mant,expo,Size;
   char *cp;

   if (Memo("DW"))
    BEGIN
     if (ArgCnt<1) WrError(1110);
     else
      BEGIN
       z=1; OK=True;
       while ((OK) AND (z<=ArgCnt))
        BEGIN
         FirstPassUnknown=FALSE;
         EvalExpression(ArgStr[z],&t);
         switch(t.Typ)
          BEGIN
           case TempInt:
            if (NOT RangeCheck(t.Contents.Int,Int32))
             BEGIN
              WrError(1320); OK=False; break;
             END
            DAsmCode[CodeLen++]=t.Contents.Int;
            break;
           case TempFloat:
            if (NOT FloatRangeCheck(t.Contents.Float,Float32))
             BEGIN
              WrError(1320); OK=False; break;
             END
            Double_2_ieee4(t.Contents.Float,(Byte*) &temp,BigEndian);
            sign=(temp>>31)&1;
            expo=(temp>>23)&255;
            mant=temp&0x7fffff;
            if ((mant==0) AND (expo==0))
             DAsmCode[CodeLen++]=0x80000000;
            else
             BEGIN
              if (expo>0)
               BEGIN
                mant|=0x800000;
                expo-=127;
               END
              else expo-=126;
              if (mant>=0x800000)
               BEGIN
                mant=mant>>1; expo+=1;
               END
              if (sign==1) mant=((mant^0xffffff)+1);
              DAsmCode[CodeLen++]=((expo&0xff)<<24)|(mant&0xffffff);
             END
            break;
           case TempString:
            for (z=0,cp=t.Contents.Ascii; *cp!='\0'; cp++,z++)
             BEGIN
              DAsmCode[CodeLen]=(DAsmCode[CodeLen]<<8)+CharTransTable[((usint)*cp)&0xff];
              if ((z&3)==3) CodeLen++;
             END
            if ((z&3)!=0) DAsmCode[CodeLen++]=(DAsmCode[CodeLen])<<((4-(z&3))<<3);
            break;
           default:
            OK=False;
          END
         z++;
        END
       if (NOT OK) CodeLen=0;
      END
     return True;
    END

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

   return FALSE;
END

/*---------------------------------------------------------------------------*/
/* Codetabellenverwaltung */

static int InstrZ;

	static void AddJmp(char *NName, LongWord NCode)
BEGIN
   if (InstrZ>=JmpOrderCnt) exit(255);
   JmpOrders[InstrZ].Code=NCode;
   AddInstTable(InstTable,NName,InstrZ++,DecodeJmp);
END

	static void AddALU1(char *NName, LongWord NCode)
BEGIN
   if (InstrZ>=ALU1OrderCnt) exit(255);
   ALU1Orders[InstrZ].Code=NCode;
   AddInstTable(InstTable,NName,InstrZ++,DecodeALU1);
END

	static void AddALU2(char *NName, LongWord NCode)
BEGIN
   if (InstrZ>=ALU2OrderCnt) exit(255);
   ALU2Orders[InstrZ].Code=NCode;
   AddInstTable(InstTable,NName,InstrZ++,DecodeALU2);
END

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

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

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

	static void InitFields(void)
BEGIN
   InstTable=CreateInstTable(201);

   AddInstTable(InstTable,"MOV",0,DecodeMOV);
   AddInstTable(InstTable,"LDI",0,DecodeLDI);
   AddInstTable(InstTable,"NOP",0,DecodeNOP);

   AddInstTable(InstTable,"SPCBP0",1,DecodeM0);
   AddInstTable(InstTable,"SPCIX0",2,DecodeM0);
   AddInstTable(InstTable,"SPCBI0",3,DecodeM0);

   AddInstTable(InstTable,"SPCBP1",1,DecodeM1);
   AddInstTable(InstTable,"SPCIX1",2,DecodeM1);
   AddInstTable(InstTable,"SPCBI1",3,DecodeM1);

   AddInstTable(InstTable,"INCBP0",1,DecodeDP0);
   AddInstTable(InstTable,"DECBP0",2,DecodeDP0);
   AddInstTable(InstTable,"CLRBP0",3,DecodeDP0);
   AddInstTable(InstTable,"STIX0" ,4,DecodeDP0);
   AddInstTable(InstTable,"INCIX0",5,DecodeDP0);
   AddInstTable(InstTable,"DECIX0",6,DecodeDP0);
   AddInstTable(InstTable,"CLRIX0",7,DecodeDP0);

   AddInstTable(InstTable,"INCBP1",1,DecodeDP1);
   AddInstTable(InstTable,"DECBP1",2,DecodeDP1);
   AddInstTable(InstTable,"CLRBP1",3,DecodeDP1);
   AddInstTable(InstTable,"STIX1" ,4,DecodeDP1);
   AddInstTable(InstTable,"INCIX1",5,DecodeDP1);
   AddInstTable(InstTable,"DECIX1",6,DecodeDP1);
   AddInstTable(InstTable,"CLRIX1",7,DecodeDP1);

   AddInstTable(InstTable,"INCAR" ,1,DecodeEA);
   AddInstTable(InstTable,"DECAR" ,2,DecodeEA);

   AddInstTable(InstTable,"XCHPSW",1,DecodeFC);

   AddInstTable(InstTable,"INCRP" ,1,DecodeRP);
   AddInstTable(InstTable,"DECRP" ,2,DecodeRP);
   AddInstTable(InstTable,"INCBRP",3,DecodeRP);

   AddInstTable(InstTable,"DECLC" ,1,DecodeL);

   AddInstTable(InstTable,"MCNBP0",InstrBASE0,DecodeBASE);
   AddInstTable(InstTable,"MCNBP1",InstrBASE1,DecodeBASE);

   AddInstTable(InstTable,"BITRP" ,0,DecodeRPC);

   AddInstTable(InstTable,"CLRP2" ,0,DecodeP2);
   AddInstTable(InstTable,"SETP2" ,1,DecodeP2);

   AddInstTable(InstTable,"CLRP3" ,0,DecodeP3);
   AddInstTable(InstTable,"SETP3" ,1,DecodeP3);

   AddInstTable(InstTable,"DI"    ,0,DecodeEM);
   AddInstTable(InstTable,"EI"    ,1,DecodeEM);
   AddInstTable(InstTable,"CLRBM" ,1,DecodeBM);
   AddInstTable(InstTable,"SETBM" ,2,DecodeBM);

   AddInstTable(InstTable,"RD"    ,1,DecodeRW);
   AddInstTable(InstTable,"WR"    ,2,DecodeRW);

   AddInstTable(InstTable,"WRBORD",1,DecodeWT);
   AddInstTable(InstTable,"WRBL24",2,DecodeWT);
   AddInstTable(InstTable,"WRBL23",3,DecodeWT);
   AddInstTable(InstTable,"WRBEL8",4,DecodeWT);
   AddInstTable(InstTable,"WRBL8E",5,DecodeWT);
   AddInstTable(InstTable,"WRBXCH",6,DecodeWT);
   AddInstTable(InstTable,"WRBBRV",7,DecodeWT);

   AddInstTable(InstTable,"TRNORM",2,DecodeNF);
   AddInstTable(InstTable,"RDNORM",4,DecodeNF);
   AddInstTable(InstTable,"FLTFIX",6,DecodeNF);
   AddInstTable(InstTable,"FIXMA" ,7,DecodeNF);

   AddInstTable(InstTable,"BWRL24",1,DecodeWI);
   AddInstTable(InstTable,"BWRORD",2,DecodeWI);

   AddInstTable(InstTable,"SPCPSW0",1,DecodeFIS);
   AddInstTable(InstTable,"SPCPSW1",2,DecodeFIS);
   AddInstTable(InstTable,"CLRPSW0",4,DecodeFIS);
   AddInstTable(InstTable,"CLRPSW1",5,DecodeFIS);
   AddInstTable(InstTable,"CLRPSW" ,6,DecodeFIS);

   AddInstTable(InstTable,"SPIE",1,DecodeFD);
   AddInstTable(InstTable,"IESP",2,DecodeFD); 

   AddInstTable(InstTable,"SETSVL",0,DecodeSHV);
   AddInstTable(InstTable,"SETSVR",1,DecodeSHV);

   AddInstTable(InstTable,"SPCRA",0,DecodeRPS);
   AddInstTable(InstTable,"JBLK" ,0,DecodeNAL);

   JmpOrders=(FixedOrder*) malloc(sizeof(FixedOrder)*JmpOrderCnt); InstrZ=0;
   AddJmp("JMP"   ,0x00); AddJmp("CALL"  ,0x01); AddJmp("RET"   ,0x02);
   AddJmp("JNZRP" ,0x03); AddJmp("JZ0"   ,0x04); AddJmp("JNZ0"  ,0x05);
   AddJmp("JZ1"   ,0x06); AddJmp("JNZ1"  ,0x07); AddJmp("JC0"   ,0x08);
   AddJmp("JNC0"  ,0x09); AddJmp("JC1"   ,0x0a); AddJmp("JNC1"  ,0x0b);
   AddJmp("JS0"   ,0x0c); AddJmp("JNS0"  ,0x0d); AddJmp("JS1"   ,0x0e);
   AddJmp("JNS1"  ,0x0f); AddJmp("JV0"   ,0x10); AddJmp("JNV0"  ,0x11);
   AddJmp("JV1"   ,0x12); AddJmp("JNV1"  ,0x13); AddJmp("JEV0"  ,0x14);
   AddJmp("JEV1"  ,0x15); AddJmp("JNFSI" ,0x16); AddJmp("JNESO" ,0x17);
   AddJmp("JIP0"  ,0x18); AddJmp("JIP1"  ,0x19); AddJmp("JNZIX0",0x1a);
   AddJmp("JNZIX1",0x1b); AddJmp("JNZBP0",0x1c); AddJmp("JNZBP1",0x1d);
   AddJmp("JRDY"  ,0x1e); AddJmp("JRQM"  ,0x1f);

   ALU1Orders=(FixedOrder*) malloc(sizeof(FixedOrder)*ALU1OrderCnt); InstrZ=0;
   AddALU1("INC"  ,0x01); AddALU1("DEC"  ,0x02); AddALU1("ABS"  ,0x03);
   AddALU1("NOT"  ,0x04); AddALU1("NEG"  ,0x05); AddALU1("SHLC" ,0x06);
   AddALU1("SHRC" ,0x07); AddALU1("ROL"  ,0x08); AddALU1("ROR"  ,0x09);
   AddALU1("SHLM" ,0x0a); AddALU1("SHRM" ,0x0b); AddALU1("SHRAM",0x0c);
   AddALU1("CLR"  ,0x0d); AddALU1("NORM" ,0x0e); AddALU1("CVT"  ,0x0f);

   ALU2Orders=(FixedOrder*) malloc(sizeof(FixedOrder)*ALU2OrderCnt); InstrZ=0;
   AddALU2("ADD"  ,0x10); AddALU2("SUB"  ,0x11); AddALU2("ADDC" ,0x12);
   AddALU2("SUBC" ,0x13); AddALU2("CMP"  ,0x14); AddALU2("AND"  ,0x15);
   AddALU2("OR"   ,0x16); AddALU2("XOR"  ,0x17); AddALU2("ADDF" ,0x18);
   AddALU2("SUBF" ,0x19);

   SrcRegs=(Register*) malloc(sizeof(Register)*SrcRegCnt); InstrZ=0;
   AddSrcReg("NON" ,0x00); AddSrcReg("RP"  ,0x01); AddSrcReg("PSW0" ,0x02);
   AddSrcReg("PSW1",0x03); AddSrcReg("SVR" ,0x04); AddSrcReg("SR"   ,0x05);
   AddSrcReg("LC"  ,0x06); AddSrcReg("STX" ,0x07); AddSrcReg("M"    ,0x08);
   AddSrcReg("ML"  ,0x09); AddSrcReg("ROM" ,0x0a); AddSrcReg("TR"   ,0x0b);
   AddSrcReg("AR"  ,0x0c); AddSrcReg("SI"  ,0x0d); AddSrcReg("DR"   ,0x0e);
   AddSrcReg("DRS" ,0x0f); AddSrcReg("WR0" ,0x10); AddSrcReg("WR1"  ,0x11);
   AddSrcReg("WR2" ,0x12); AddSrcReg("WR3" ,0x13); AddSrcReg("WR4"  ,0x14);
   AddSrcReg("WR5" ,0x15); AddSrcReg("WR6" ,0x16); AddSrcReg("WR7"  ,0x17);
   AddSrcReg("RAM0",0x18); AddSrcReg("RAM1",0x19); AddSrcReg("BP0"  ,0x1a);
   AddSrcReg("BP1" ,0x1b); AddSrcReg("IX0" ,0x1c); AddSrcReg("IX1"  ,0x1d);
   AddSrcReg("K"   ,0x1e); AddSrcReg("L"   ,0x1f);

   ALUSrcRegs=(Register*) malloc(sizeof(Register)*ALUSrcRegCnt); InstrZ=0;
   AddALUSrcReg("IB"  ,0x00); AddALUSrcReg("M"   ,0x01);
   AddALUSrcReg("RAM0",0x02); AddALUSrcReg("RAM1",0x03);

   DestRegs=(Register*) malloc(sizeof(Register)*DestRegCnt); InstrZ=0;
   AddDestReg("NON" ,0x00); AddDestReg("RP"  ,0x01); AddDestReg("PSW0" ,0x02);
   AddDestReg("PSW1",0x03); AddDestReg("SVR" ,0x04); AddDestReg("SR"   ,0x05);
   AddDestReg("LC"  ,0x06); AddDestReg("STK" ,0x07); AddDestReg("LKR0" ,0x08);
   AddDestReg("KLR1",0x09); AddDestReg("TRE" ,0x0a); AddDestReg("TR"   ,0x0b);
   AddDestReg("AR"  ,0x0c); AddDestReg("SO"  ,0x0d); AddDestReg("DR"   ,0x0e);
   AddDestReg("DRS" ,0x0f); AddDestReg("WR0" ,0x10); AddDestReg("WR1"  ,0x11);
   AddDestReg("WR2" ,0x12); AddDestReg("WR3" ,0x13); AddDestReg("WR4"  ,0x14);
   AddDestReg("WR5" ,0x15); AddDestReg("WR6" ,0x16); AddDestReg("WR7"  ,0x17);
   AddDestReg("RAM0",0x18); AddDestReg("RAM1",0x19); AddDestReg("BP0"  ,0x1a);
   AddDestReg("BP1" ,0x1b); AddDestReg("IX0" ,0x1c); AddDestReg("IX1"  ,0x1d);
   AddDestReg("K"   ,0x1e); AddDestReg("L"   ,0x1f);

   InstrComps=(LongWord*) malloc(sizeof(LongWord)*InstrCnt);
   InstrDefs=(LongWord*) malloc(sizeof(LongWord)*InstrCnt);
   for (InstrZ=0; InstrZ<InstrCnt; InstrDefs[InstrZ++]=0xffffffff);
   InstrDefs[InstrALU]=0;
   InstrDefs[InstrMove]=0;
   InstrDefs[InstrBM]=0;
   InstrDefs[InstrEM]=0;
   InstrDefs[InstrDP0]=0;
   InstrDefs[InstrDP1]=0;
   InstrDefs[InstrEA]=0;
   InstrDefs[InstrFC]=0;
   InstrDefs[InstrFD]=0;
   InstrDefs[InstrFIS]=0;
   InstrDefs[InstrL]=0;
   InstrDefs[InstrM0]=0; 
   InstrDefs[InstrM1]=0;
   InstrDefs[InstrNF]=0;
   InstrDefs[InstrRP]=0;
   InstrDefs[InstrRW]=0;
   InstrDefs[InstrWI]=0;
   InstrDefs[InstrWT]=0;
END

	static void DeinitFields(void)
BEGIN
   DestroyInstTable(InstTable);

   free(SrcRegs); free(ALUSrcRegs); free(DestRegs);

   free(JmpOrders); free(ALU1Orders); free(ALU2Orders);

   free(InstrComps); free(InstrDefs);
END

/*---------------------------------------------------------------------------*/
/* Callbacks */

	static void MakeCode_77230(void)
BEGIN
   int z,z2;
   LongWord Diff;

   /* Nullanweisung */

   if ((Memo("")) AND (*AttrPart=='\0') AND (ArgCnt==0)) return;

   /* Pseudoanweisungen */

   if (DecodePseudo()) return;

   /* solange dekodieren, bis keine Operanden mehr da oder Fehler */

   Error=False; InstrMask=0;
   memset(InstrComps,0,sizeof(LongWord)*InstrCnt);
   do
    BEGIN
     if (NOT LookupInstTable(InstTable,OpPart))
      BEGIN
       WrXError(1200,OpPart); Error=True;
      END
    END
   while ((NOT Error) AND (*OpPart!='\0'));

   /* passende Verknuepfung suchen */

   if (NOT Error)
    BEGIN
     for (z=0; z<CaseCnt; z++)
      BEGIN
       /* Bits ermitteln, die nur in einer Maske vorhanden sind */

       Diff=InstrMask^CaseMasks[z];

       /* Fall nur m<>glich, wenn Bits im aktuellen Fall gesetzt sind, die
          der Fall nicht hat */

       if ((Diff&InstrMask)==0)
        BEGIN
         /* ist irgendein Feld unbenutzt, fuer das wir keinen Default haben? */

         for (z2=0; z2<InstrCnt; z2++)
          if (((Diff&(1l<<z2))!=0) AND (InstrDefs[z2]==-1)) break;
         if (z2==InstrCnt) break;
        END
      END

     switch (z)
      BEGIN
       case 0: /* nur LDI */
        DAsmCode[0]=0xe0000000+InstrComps[InstrLDI];
        CodeLen=1;
        break;
       case 1: /* JMP+MOV */
        DAsmCode[0]=0xd0000000+(InstrComps[InstrBranch]<<10)
                              +InstrComps[InstrMove];
        CodeLen=1;
        break;
       case 2: /* ALU+MOV+M0+M1+DP0+DP1 */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrDP1]<<15)+(InstrComps[InstrDP0]<<18)
                   +(InstrComps[InstrM1]<<21)+(InstrComps[InstrM0]<<23);
        CodeLen=1;
        break;
       case 3: /* ALU+MOV+EA+DP0+DP1 */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrDP1]<<15)+(InstrComps[InstrDP0]<<18)
                   +(InstrComps[InstrEA]<<21)+0x02000000;
        CodeLen=1;
        break;
       case 4: /* ALU+MOV+RP+M0+DP0+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrRP]<<21)+(InstrComps[InstrFC]<<15)
                   +(InstrComps[InstrM0]<<19)+(InstrComps[InstrDP0]<<16)
                   +0x02800000;
        CodeLen=1;
        break;
       case 5: /* ALU+MOV+RP+M1+DP1+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrRP]<<21)+(InstrComps[InstrFC]<<15)
                   +(InstrComps[InstrM1]<<19)+(InstrComps[InstrDP1]<<16)
                   +0x03000000;
        CodeLen=1;
        break;
       case 6: /* ALU+MOV+RP+M0+M1+L+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrRP]<<21)+(InstrComps[InstrL]<<16)
                   +(InstrComps[InstrM0]<<19)+(InstrComps[InstrM1]<<17)
                   +(InstrComps[InstrFC]<<15)+0x03800000;
        CodeLen=1;
        break;
       case 7: /* ALU+MOV+BASE0+BASE1+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrBASE0]<<19)+(InstrComps[InstrBASE1]<<16)
                   +(InstrComps[InstrFC]<<15)+0x04000000;
        CodeLen=1;
        break;
       case 8: /* ALU+MOV+RPC+L+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrRPC]<<18)+(InstrComps[InstrL]<<16)
                   +(InstrComps[InstrFC]<<15)+0x04400000;
        CodeLen=1;
        break;
       case 9: /* ALU+MOV+P2+P3+EM+BM+L+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrP2]<<20)+(InstrComps[InstrP3]<<21)
                   +(InstrComps[InstrEM]<<19)+(InstrComps[InstrBM]<<17)
                   +(InstrComps[InstrL]<<16)+(InstrComps[InstrFC]<<15)
                   +0x04800000;
        CodeLen=1;
        break;
       case 10: /* ALU+MOV+RW+L+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrRW]<<20)+(InstrComps[InstrL]<<16)
                   +(InstrComps[InstrFC]<<15)+0x04c00000;
        CodeLen=1;
        break;
       case 11: /* ALU+MOV+WT+L+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrWT]<<19)+(InstrComps[InstrL]<<16)
                   +(InstrComps[InstrFC]<<15)+0x05000000;
        CodeLen=1;
        break;
       case 12: /* ALU+MOV+NF+WI+L+FC */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrNF]<<19)+(InstrComps[InstrWI]<<17)
                   +(InstrComps[InstrL]<<16)+(InstrComps[InstrFC]<<15)
                   +0x05400000;
        CodeLen=1;
        break;
       case 13: /* ALU+MOV+FIS+FD+L */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrFIS]<<19)+(InstrComps[InstrFD]<<17)
                   +(InstrComps[InstrL]<<16)+0x05800000;
        CodeLen=1;
        break;
       case 14: /* ALU+MOV+SHV */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrSHV]<<15)+0x05c00000;
        CodeLen=1;
        break;
       case 15: /* ALU+MOV+RPS */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrRPS]<<15)+0x06000000;
        CodeLen=1;
        break;
       case 16: /* ALU+MOV+NAL */
        DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove]
                   +(InstrComps[InstrNAL]<<15)+0x07000000;
        CodeLen=1;
        break;
       default:
        WrError(1355);
      END
    END
END

	static Boolean IsDef_77230(void)
BEGIN
   return False;
END

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

	static void SwitchTo_77230(void)
BEGIN
   PFamilyDescr FoundDescr;

   FoundDescr=FindFamilyByName("77230");

   TurnWords=False; ConstMode=ConstModeIntel; SetIsOccupied=False;
   PCSymbol="$"; HeaderID=FoundDescr->Id; NOPCode=0x00000000;
   DivideChars=","; HasAttrs=False;

   ValidSegs=(1<<SegCode)|(1<<SegXData)|(1<<SegYData)|(1<<SegRData);
   Grans[SegCode ]=4; ListGrans[SegCode ]=4; SegInits[SegCode ]=0;
   SegLimits[SegCode ] = 0x1fff;
   Grans[SegXData]=4; ListGrans[SegXData]=4; SegInits[SegXData]=0;
   SegLimits[SegXData] = 0x1ff;
   Grans[SegYData]=4; ListGrans[SegYData]=4; SegInits[SegYData]=0;
   SegLimits[SegYData] = 0x1ff;  
   Grans[SegRData]=4; ListGrans[SegRData]=4; SegInits[SegRData]=0;
   SegLimits[SegRData] = 0x3ff;  

   MakeCode=MakeCode_77230; IsDef=IsDef_77230;
   SwitchFrom=SwitchFrom_77230;

   InitFields();
END

/*---------------------------------------------------------------------------*/
/* Initialisierung */

	void code77230_init(void)
BEGIN  
   CPU77230=AddCPU("77230",SwitchTo_77230);
END