+/* 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