diff options
Diffstat (limited to 'codepseudo.c')
| -rw-r--r-- | codepseudo.c | 1246 |
1 files changed, 1246 insertions, 0 deletions
diff --git a/codepseudo.c b/codepseudo.c new file mode 100644 index 0000000..8d474de --- /dev/null +++ b/codepseudo.c @@ -0,0 +1,1246 @@ +/* codepseudo.c */ +/*****************************************************************************/ +/* AS-Portierung */ +/* */ +/* Haeufiger benutzte Pseudo-Befehle */ +/* */ +/* Historie: 23. 5.1996 Grundsteinlegung */ +/* 7. 7.1998 Fix Zugriffe auf CharTransTable wg. signed chars */ +/* 18. 8.1998 BookKeeping-Aufrufe bei SPeicherreservierungen */ +/* */ +/*****************************************************************************/ + +#include "stdinc.h" +#include <string.h> + +#include "nls.h" +#include "bpemu.h" +#include "endian.h" +#include "strutil.h" +#include "chunks.h" +#include "asmdef.h" +#include "asmsub.h" +#include "asmpars.h" +#include "asmallg.h" +#include "asmitree.h" + +#include "codepseudo.h" + + + int FindInst(void *Field, int Size, int Count) +BEGIN + char *cptr,**ptr; + +#ifdef OPT + int l=0,r=Count-1,m,res; + + while (TRUE) + BEGIN + m=(l+r)>>1; cptr=((char *) Field)+(Size*m); + ptr=(char**) cptr; + res=strcmp(*ptr,OpPart); + if (res==0) return m; + else if (l==r) return -1; + else if (res<0) + BEGIN + if (r-l==1) return -1; else l=m; + END + else r=m; + END + +#else + int z,res; + + cptr=(char *) Field; + for (z=0; z<Count; z++) + BEGIN + ptr=(char**) cptr; + res=strcmp(*ptr,OpPart); + if (res==0) return z; + if (res>0) return -1; + cptr+=Size; + END + return -1; +#endif +END + + + Boolean IsIndirect(char *Asc) +BEGIN + int z,Level,l; + + if (((l=strlen(Asc))<=2) OR (Asc[0]!='(') OR (Asc[l-1]!=')')) return False; + + Level=0; + for (z=1; z<=l-2; z++) + BEGIN + if (Asc[z]=='(') Level++; + if (Asc[z]==')') Level--; + if (Level<0) return False; + END + + return True; +END + + +static enum{DSNone,DSConstant,DSSpace} DSFlag; +typedef Boolean (*TLayoutFunc)( +#ifdef __PROTOS__ + char *Asc, Word *Cnt, Boolean Turn +#endif + ); + + static Boolean LayoutByte(char *Asc, Word *Cnt, Boolean Turn) +BEGIN + Boolean Result; + TempResult t; + + Result=False; + + if (strcmp(Asc,"?")==0) + BEGIN + if (DSFlag==DSConstant) WrError(1930); + else + BEGIN + *Cnt=1; Result=True; DSFlag=DSSpace; CodeLen++; + END + return Result; + END + else + BEGIN + if (DSFlag==DSSpace) + BEGIN + WrError(1930); return Result; + END + else DSFlag=DSConstant; + END + + FirstPassUnknown=False; EvalExpression(Asc,&t); + switch (t.Typ) + BEGIN + case TempInt: + if (FirstPassUnknown) t.Contents.Int&=0xff; + if (NOT RangeCheck(t.Contents.Int,Int8)) WrError(1320); + else + BEGIN + BAsmCode[CodeLen++]=t.Contents.Int; *Cnt=1; + Result=True; + END; + break; + case TempFloat: + WrError(1135); + break; + case TempString: + TranslateString(t.Contents.Ascii); + memcpy(BAsmCode+CodeLen,t.Contents.Ascii,strlen(t.Contents.Ascii)); + CodeLen+=(*Cnt=strlen(t.Contents.Ascii)); + Result=True; + break; + case TempNone: + break; + END + + return Result; +END + + + static Boolean LayoutWord(char *Asc, Word *Cnt, Boolean Turn) +BEGIN + Boolean OK,Result; + Word erg; + + *Cnt=2; Result=False; + + if (strcmp(Asc,"?")==0) + BEGIN + if (DSFlag==DSConstant) WrError(1930); + else + BEGIN + Result=True; DSFlag=DSSpace; CodeLen+=2; + END + return Result; + END + else + BEGIN + if (DSFlag==DSSpace) + BEGIN + WrError(1930); return Result; + END + else DSFlag=DSConstant; + END + + if (CodeLen+2>MaxCodeLen) + BEGIN + WrError(1920); return Result; + END + erg=EvalIntExpression(Asc,Int16,&OK); + if (OK) + BEGIN + if (Turn) erg=((erg>>8)&0xff)+((erg&0xff)<<8); + BAsmCode[CodeLen]=erg&0xff; BAsmCode[CodeLen+1]=erg>>8; + CodeLen+=2; + END + return OK; +END + + + static Boolean LayoutDoubleWord(char *Asc, Word *Cnt, Boolean Turn) +BEGIN + TempResult erg; + Boolean Result=False; + + *Cnt=4; + + if (strcmp(Asc,"?")==0) + BEGIN + if (DSFlag==DSConstant) WrError(1930); + else + BEGIN + Result=True; DSFlag=DSSpace; CodeLen+=4; + END + return Result; + END + else + BEGIN + if (DSFlag==DSSpace) + BEGIN + WrError(1930); return Result; + END + else DSFlag=DSConstant; + END + + if (CodeLen+4>MaxCodeLen) + BEGIN + WrError(1920); return Result; + END + + KillBlanks(Asc); EvalExpression(Asc,&erg); + switch (erg.Typ) + BEGIN + case TempNone: return Result; + case TempInt: + if (RangeCheck(erg.Contents.Int,Int32)) + BEGIN + BAsmCode[CodeLen ]=((erg.Contents.Int )&0xff); + BAsmCode[CodeLen+1]=((erg.Contents.Int>> 8)&0xff); + BAsmCode[CodeLen+2]=((erg.Contents.Int>>16)&0xff); + BAsmCode[CodeLen+3]=((erg.Contents.Int>>24)&0xff); + CodeLen+=4; + END + else + BEGIN + WrError(1320); + return Result; + END + break; + case TempFloat: + if (FloatRangeCheck(erg.Contents.Float,Float32)) + BEGIN + Double_2_ieee4(erg.Contents.Float,BAsmCode+CodeLen,False); + CodeLen+=4; + END + else + BEGIN + WrError(1320); + return Result; + END + break; + case TempString: + WrError(1135); + return Result; + END + + if (Turn) DSwap(BAsmCode+CodeLen-4,4); + return True; +END + + + static Boolean LayoutQuadWord(char *Asc, Word *Cnt, Boolean Turn) +BEGIN + Boolean Result; + TempResult erg; +#ifndef HAS64 + int z; +#endif + + Result=False; *Cnt=8; + + if (strcmp(Asc,"?")==0) + BEGIN + if (DSFlag==DSConstant) WrError(1930); + else + BEGIN + Result=True; DSFlag=DSSpace; CodeLen+=8; + END + return Result; + END + else + BEGIN + if (DSFlag==DSSpace) + BEGIN + WrError(1930); return Result; + END + else DSFlag=DSConstant; + END + + if (CodeLen+8>MaxCodeLen) + BEGIN + WrError(1920); return Result; + END + + KillBlanks(Asc); EvalExpression(Asc,&erg); + switch(erg.Typ) + BEGIN + case TempNone: + return Result; + case TempInt: + memcpy(BAsmCode+CodeLen,&(erg.Contents.Int),sizeof(LargeInt)); +#ifdef HAS64 + if (BigEndian) QSwap(BAsmCode+CodeLen,8); +#else + if (BigEndian) DSwap(BAsmCode+CodeLen,4); + for (z=4; z<8; BAsmCode[CodeLen+(z++)]=(BAsmCode[CodeLen+3]>=0x80)?0xff:0x00); +#endif + CodeLen+=8; + break; + case TempFloat: + Double_2_ieee8(erg.Contents.Float,BAsmCode+CodeLen,False); + CodeLen+=8; + break; + case TempString: + WrError(1135); + return Result; + END + + if (Turn) QSwap(BAsmCode+CodeLen-8,8); + return True; +END + + + static Boolean LayoutTenBytes(char *Asc, Word *Cnt, Boolean Turn) +BEGIN + Boolean OK,Result; + Double erg; + int z; + Byte Exg; + + Result=False; *Cnt=10; + + if (strcmp(Asc,"?")==0) + BEGIN + if (DSFlag==DSConstant) WrError(1930); + else + BEGIN + Result=True; DSFlag=DSSpace; CodeLen+=10; + END + return Result; + END + else + BEGIN + if (DSFlag==DSSpace) + BEGIN + WrError(1930); return Result; + END + else DSFlag=DSConstant; + END + + if (CodeLen+10>MaxCodeLen) + BEGIN + WrError(1920); return Result; + END + erg=EvalFloatExpression(Asc,Float64,&OK); + if (OK) + BEGIN + Double_2_ieee10(erg,BAsmCode+CodeLen,False); + CodeLen+=10; + if (Turn) + for (z=0; z<5; z++) + BEGIN + Exg=BAsmCode[CodeLen-10+z]; + BAsmCode[CodeLen-10+z]=BAsmCode[CodeLen-1-z]; + BAsmCode[CodeLen-1-z]=Exg; + END + END + return OK; +END + + + static Boolean DecodeIntelPseudo_ValidSymChar(char ch) +BEGIN + return (((ch>='A') AND (ch<='Z')) OR ((ch>='0') AND (ch<='9')) OR (ch=='_') OR (ch=='.')); +END + + static Boolean DecodeIntelPseudo_LayoutMult(char *Asc_O, Word *Cnt, + TLayoutFunc LayoutFunc, + Boolean Turn) +BEGIN + int z,Depth,Fnd,ALen; + String Asc,Part; + Word SumCnt,ECnt,SInd; + LongInt Rep; + Boolean OK,Hyp; + + strmaxcpy(Asc,Asc_O,255); + + /* nach DUP suchen */ + + Depth=0; Fnd=0; ALen=strlen(Asc); + for (z=0; z<ALen-2; z++) + BEGIN + if (Asc[z]=='(') Depth++; + else if (Asc[z]==')') Depth--; + else if (Depth==0) + if ( ((z==0) OR (NOT DecodeIntelPseudo_ValidSymChar(Asc[z-1]))) + AND (NOT DecodeIntelPseudo_ValidSymChar(Asc[z+3])) + AND (strncasecmp(Asc+z,"DUP",3)==0)) Fnd=z; + END + + /* DUP gefunden: */ + + if (Fnd!=0) + BEGIN + /* Anzahl ausrechnen */ + + FirstPassUnknown=False; + Asc[Fnd]='\0'; Rep=EvalIntExpression(Asc,Int32,&OK); Asc[Fnd]='D'; + if (FirstPassUnknown) + BEGIN + WrError(1820); return False; + END + if (NOT OK) return False; + + /* Nullargument vergessen, bei negativem warnen */ + + if (Rep<0) WrError(270); + if (Rep<=0) return True; + + /* Einzelteile bilden & evaluieren */ + + strcpy(Asc,Asc+Fnd+3); KillPrefBlanks(Asc); SumCnt=0; + if ((strlen(Asc)>=2) AND (*Asc=='(') AND (Asc[strlen(Asc)-1]==')')) + BEGIN + strcpy(Asc,Asc+1); Asc[strlen(Asc)-1]='\0'; + END + do + BEGIN + Fnd=0; z=0; Hyp=False; Depth=0; + do + BEGIN + if (Asc[z]=='\'') Hyp=NOT Hyp; + else if (NOT Hyp) + BEGIN + if (Asc[z]=='(') Depth++; + else if (Asc[z]==')') Depth--; + else if ((Depth==0) AND (Asc[z]==',')) Fnd=z; + END + z++; + END + while ((z<strlen(Asc)) AND (Fnd==0)); + if (Fnd==0) + BEGIN + strmaxcpy(Part,Asc,255); *Asc='\0'; + END + else + BEGIN + Asc[Fnd]='\0'; strmaxcpy(Part,Asc,255); + strcpy(Asc,Asc+Fnd+1); + END + if (NOT DecodeIntelPseudo_LayoutMult(Part,&ECnt,LayoutFunc,Turn)) + return False; + SumCnt+=ECnt; + END + while (*Asc!='\0'); + + /* Ergebnis vervielfachen */ + + if (DSFlag==DSConstant) + BEGIN + SInd=CodeLen-SumCnt; + if (CodeLen+SumCnt*(Rep-1)>MaxCodeLen) + BEGIN + WrError(1920); return False; + END + for (z=1; z<=Rep-1; z++) + BEGIN + if (CodeLen+SumCnt>MaxCodeLen) return False; + memcpy(BAsmCode+CodeLen,BAsmCode+SInd,SumCnt); + CodeLen+=SumCnt; + END + END + else CodeLen+=SumCnt*(Rep-1); + *Cnt=SumCnt*Rep; return True; + END + + /* kein DUP: einfacher Ausdruck */ + + else return LayoutFunc(Asc,Cnt,Turn); +END + + Boolean DecodeIntelPseudo(Boolean Turn) +BEGIN + Word Dummy; + int z; + TLayoutFunc LayoutFunc=Nil; + Boolean OK; + LongInt HVal; + char Ident; + + if ((strlen(OpPart)!=2) OR (*OpPart!='D')) return False; + Ident=OpPart[1]; + + if ((Ident=='B') OR (Ident=='W') OR (Ident=='D') OR (Ident=='Q') OR (Ident=='T')) + BEGIN + DSFlag=DSNone; + switch (Ident) + BEGIN + case 'B': + LayoutFunc=LayoutByte; + if (*LabPart!='\0') SetSymbolSize(LabPart,0); + break; + case 'W': + LayoutFunc=LayoutWord; + if (*LabPart!='\0') SetSymbolSize(LabPart,1); + break; + case 'D': + LayoutFunc=LayoutDoubleWord; + if (*LabPart!='\0') SetSymbolSize(LabPart,2); + break; + case 'Q': + LayoutFunc=LayoutQuadWord; + if (*LabPart!='\0') SetSymbolSize(LabPart,3); + break; + case 'T': + LayoutFunc=LayoutTenBytes; + if (*LabPart!='\0') SetSymbolSize(LabPart,4); + break; + END + z=1; + do + BEGIN + OK=DecodeIntelPseudo_LayoutMult(ArgStr[z],&Dummy,LayoutFunc,Turn); + if (NOT OK) CodeLen=0; + z++; + END + while ((OK) AND (z<=ArgCnt)); + DontPrint=(DSFlag==DSSpace); + if (DontPrint) BookKeeping(); + if (OK) ActListGran=1; + return True; + END + + if (Ident=='S') + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + FirstPassUnknown=False; + HVal=EvalIntExpression(ArgStr[1],Int32,&OK); + if (FirstPassUnknown) WrError(1820); + else if (OK) + BEGIN + DontPrint=True; CodeLen=HVal; + BookKeeping(); + END + END + return True; + END + + return False; +END + +/*--------------------------------------------------------------------------*/ + +static Boolean M16Turn=False; + + static Boolean CutRep(char *Asc, LongInt *Erg) +BEGIN + char *p; + Boolean OK; + + if (*Asc!='[') + BEGIN + *Erg=1; return True; + END + else + BEGIN + strcpy(Asc,Asc+1); p=QuotPos(Asc,']'); + if (p==Nil) + BEGIN + WrError(1300); return False; + END + else + BEGIN + *p='\0'; + *Erg=EvalIntExpression(Asc,Int32,&OK); + strcpy(Asc,p+1); return OK; + END + END +END + + static void DecodeBYT(Word Index) +BEGIN + int z; + Boolean OK; + TempResult t; + LongInt Rep,z2; + + if (ArgCnt==0) WrError(1110); + else + BEGIN + z=1; OK=True; + do + BEGIN + KillBlanks(ArgStr[z]); + OK=CutRep(ArgStr[z],&Rep); + if (OK) + BEGIN + EvalExpression(ArgStr[z],&t); + switch (t.Typ) + BEGIN + case TempInt: + if (NOT RangeCheck(t.Contents.Int,Int8)) + BEGIN + WrError(1320); OK=False; + END + else if (CodeLen+Rep>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + memset(BAsmCode+CodeLen,t.Contents.Int,Rep); + CodeLen+=Rep; + END + break; + case TempFloat: + WrError(1135); OK=False; + break; + case TempString: + TranslateString(t.Contents.Ascii); + if (CodeLen+Rep*strlen(t.Contents.Ascii)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else for (z2=0; z2<Rep; z2++) + BEGIN + memcpy(BAsmCode+CodeLen,t.Contents.Ascii,strlen(t.Contents.Ascii)); + CodeLen+=strlen(t.Contents.Ascii); + END + break; + default: + OK=False; + break; + END + END + z++; + END + while ((z<=ArgCnt) AND (OK)); + if (NOT OK) CodeLen=0; + END +END + + static void DecodeADR(Word Index) +BEGIN + int z; + Word HVal16; + Boolean OK; + LongInt Rep,z2; + + if (ArgCnt==0) WrError(1110); + else + BEGIN + z=1; OK=True; + do + BEGIN + OK=CutRep(ArgStr[z],&Rep); + if (OK) + if (CodeLen+(Rep<<1)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + HVal16=EvalIntExpression(ArgStr[z],Int16,&OK); + if (OK) + for (z2=0; z2<Rep; z2++) + BEGIN + if (M16Turn) + BEGIN + BAsmCode[CodeLen++]=Hi(HVal16); + BAsmCode[CodeLen++]=Lo(HVal16); + END + else + BEGIN + BAsmCode[CodeLen++]=Lo(HVal16); + BAsmCode[CodeLen++]=Hi(HVal16); + END + END + END + z++; + END + while ((z<=ArgCnt) AND (OK)); + if (NOT OK) CodeLen=0; + END +END + + static void DecodeFCC(Word Index) +BEGIN + String SVal; + Boolean OK; + int z; + LongInt Rep,z2; + + if (ArgCnt==0) WrError(1110); + else + BEGIN + z=1; OK=True; + do + BEGIN + OK=CutRep(ArgStr[z],&Rep); + if (OK) + BEGIN + EvalStringExpression(ArgStr[z],&OK,SVal); + if (OK) + if (CodeLen+Rep*strlen(SVal)>=MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + TranslateString(SVal); + for (z2=0; z2<Rep; z2++) + BEGIN + memcpy(BAsmCode+CodeLen,SVal,strlen(SVal)); + CodeLen+=strlen(SVal); + END + END + END + z++; + END + while ((z<=ArgCnt) AND (OK)); + if (NOT OK) CodeLen=0; + END +END + + static void DecodeDFS(Word Index) +BEGIN + Word HVal16; + Boolean OK; + + if (ArgCnt!=1) WrError(1110); + else + BEGIN + FirstPassUnknown=False; + HVal16=EvalIntExpression(ArgStr[1],Int16,&OK); + if (FirstPassUnknown) WrError(1820); + else if (OK) + BEGIN + DontPrint=True; CodeLen=HVal16; + BookKeeping(); + END + END +END + + Boolean DecodeMotoPseudo(Boolean Turn) +BEGIN + static PInstTable InstTable=Nil; + + if (InstTable==Nil) + BEGIN + InstTable=CreateInstTable(17); + AddInstTable(InstTable,"BYT",0,DecodeBYT); + AddInstTable(InstTable,"FCB",0,DecodeBYT); + AddInstTable(InstTable,"ADR",0,DecodeADR); + AddInstTable(InstTable,"FDB",0,DecodeADR); + AddInstTable(InstTable,"FCC",0,DecodeFCC); + AddInstTable(InstTable,"DFS",0,DecodeDFS); + AddInstTable(InstTable,"RMB",0,DecodeDFS); + END + + M16Turn=Turn; + return LookupInstTable(InstTable,OpPart); +END + + static void DigIns(char Ch, Byte Pos, Word *w) +BEGIN + Byte wpos=Pos>>2,bpos=(Pos&3)*4; + Word dig=Ch-'0'; + + w[wpos]|=(dig<<bpos); +END + + void ConvertDec(Double F, Word *w) +BEGIN + char s[30],Man[30],Exp[30]; + char *h; + LongInt z; + Byte epos; + + sprintf(s,"%0.16e",F); h=strchr(s,'e'); + if (h==Nil) + BEGIN + strcpy(Man,s); strcpy(Exp,"+0000"); + END + else + BEGIN + *h='\0'; + strcpy(Man,s); strcpy(Exp,h+1); + END + memset(w,0,12); + if (*Man=='-') + BEGIN + w[5]|=0x8000; strcpy(Man,Man+1); + END + else if (*Man=='+') strcpy(Man,Man+1); + if (*Exp=='-') + BEGIN + w[5]|=0x4000; strcpy(Exp,Exp+1); + END + else if (*Exp=='+') strcpy(Exp,Exp+1); + DigIns(*Man,16,w); strcpy(Man,Man+2); + if (strlen(Man)>16) Man[16]='\0'; + for (z=0; z<strlen(Man); z++) DigIns(Man[z],15-z,w); + if (strlen(Exp)>4) strcpy(Exp,Exp+strlen(Exp)-4); + for (z=strlen(Exp)-1; z>=0; z--) + BEGIN + epos=strlen(Exp)-1-z; + if (epos==3) DigIns(Exp[z],19,w); else DigIns(Exp[z],epos+20,w); + END +END + + + static void EnterByte(Byte b) +BEGIN + if (((CodeLen&1)==1) AND (NOT BigEndian) AND (ListGran()!=1)) + BEGIN + BAsmCode[CodeLen]=BAsmCode[CodeLen-1]; + BAsmCode[CodeLen-1]=b; + END + else + BEGIN + BAsmCode[CodeLen]=b; + END + CodeLen++; +END + + void AddMoto16PseudoONOFF(void) +BEGIN + AddONOFF("PADDING",&DoPadding,DoPaddingName,False); +END + + Boolean DecodeMoto16Pseudo(ShortInt OpSize, Boolean Turn) +BEGIN + Byte z; + Word TurnField[8]; + char *zp; + LongInt z2; + LongInt WSize,Rep=0; + LongInt NewPC,HVal,WLen; +#ifdef HAS64 + QuadInt QVal; +#endif + Integer HVal16; + Double DVal; + TempResult t; + Boolean OK,ValOK; + + if (OpSize<0) OpSize=1; + + if (*OpPart!='D') return False; + + if (Memo("DC")) + BEGIN + if (ArgCnt==0) WrError(1110); + else + BEGIN + OK=True; z=1; WLen=0; + do + BEGIN + FirstPassUnknown=False; + OK=CutRep(ArgStr[z],&Rep); + if (OK) + if (FirstPassUnknown) WrError(1820); + else + BEGIN + switch (OpSize) + BEGIN + case 0: + FirstPassUnknown=False; + EvalExpression(ArgStr[z],&t); + if ((FirstPassUnknown) AND (t.Typ==TempInt)) t.Contents.Int&=0xff; + switch (t.Typ) + BEGIN + case TempInt: + if (NOT RangeCheck(t.Contents.Int,Int8)) + BEGIN + WrError(1320); OK=False; + END + else if (CodeLen+Rep>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else for (z2=0; z2<Rep; z2++) EnterByte(t.Contents.Int); + break; + case TempFloat: + WrError(1135); OK=False; + break; + case TempString: + if (CodeLen+Rep*strlen(t.Contents.Ascii)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + for (z2=0; z2<Rep; z2++) + for (zp=t.Contents.Ascii; *zp!='\0'; EnterByte(CharTransTable[((usint) *(zp++))&0xff])); + break; + default: OK=False; + END + break; + case 1: + HVal16=EvalIntExpression(ArgStr[z],Int16,&OK); + if (OK) + if (CodeLen+(Rep<<1)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + if (ListGran()==1) + for (z2=0; z2<Rep; z2++) + BEGIN + BAsmCode[(WLen<<1) ]=Hi(HVal16); + BAsmCode[(WLen<<1)+1]=Lo(HVal16); + WLen++; + END + else + for (z2=0; z2<Rep; z2++) WAsmCode[WLen++]=HVal16; + CodeLen+=Rep<<1; + END + break; + case 2: + HVal=EvalIntExpression(ArgStr[z],Int32,&OK); + if (OK) + if (CodeLen+(Rep<<2)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + if (ListGran()==1) + for (z2=0; z2<Rep; z2++) + BEGIN + BAsmCode[(WLen<<1) ]=(HVal >> 24) & 0xff; + BAsmCode[(WLen<<1)+1]=(HVal >> 16) & 0xff; + BAsmCode[(WLen<<1)+2]=(HVal >> 8) & 0xff; + BAsmCode[(WLen<<1)+3]=(HVal ) & 0xff; + WLen+=2; + END + else + for (z2=0; z2<Rep; z2++) + BEGIN + WAsmCode[WLen++]=HVal >> 16; + WAsmCode[WLen++]=HVal & 0xffff; + END + CodeLen+=Rep<<2; + END + break; +#ifdef HAS64 + case 3: + QVal=EvalIntExpression(ArgStr[z],Int64,&OK); + if (OK) + if (CodeLen+(Rep<<3)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + if (ListGran()==1) + for (z2=0; z2<Rep; z2++) + BEGIN + BAsmCode[(WLen<<1) ]=(QVal >> 56) & 0xff; + BAsmCode[(WLen<<1)+1]=(QVal >> 48) & 0xff; + BAsmCode[(WLen<<1)+2]=(QVal >> 40) & 0xff; + BAsmCode[(WLen<<1)+3]=(QVal >> 32) & 0xff; + BAsmCode[(WLen<<1)+4]=(QVal >> 24) & 0xff; + BAsmCode[(WLen<<1)+5]=(QVal >> 16) & 0xff; + BAsmCode[(WLen<<1)+6]=(QVal >> 8) & 0xff; + BAsmCode[(WLen<<1)+7]=(QVal ) & 0xff; + WLen+=4; + END + else + for (z2=0; z2<Rep; z2++) + BEGIN + WAsmCode[WLen++]=(QVal >> 48) & 0xffff; + WAsmCode[WLen++]=(QVal >> 32) & 0xffff; + WAsmCode[WLen++]=(QVal >> 16) & 0xffff; + WAsmCode[WLen++]=QVal & 0xffff; + END + CodeLen+=Rep<<3; + END + break; +#endif + case 4: + DVal=EvalFloatExpression(ArgStr[z],Float32,&OK); + if (OK) + if (CodeLen+(Rep<<2)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + Double_2_ieee4(DVal,(Byte *) TurnField,BigEndian); + if (BigEndian) DWSwap((void*) TurnField,4); + if (ListGran()==1) + for (z2=0; z2<Rep; z2++) + BEGIN + BAsmCode[(WLen<<1) ]=Hi(TurnField[1]); + BAsmCode[(WLen<<1)+1]=Lo(TurnField[1]); + BAsmCode[(WLen<<1)+2]=Hi(TurnField[0]); + BAsmCode[(WLen<<1)+3]=Lo(TurnField[0]); + WLen+=2; + END + else + for (z2=0; z2<Rep; z2++) + BEGIN + WAsmCode[WLen++]=TurnField[1]; + WAsmCode[WLen++]=TurnField[0]; + END + CodeLen+=Rep<<2; + END + break; + case 5: + DVal=EvalFloatExpression(ArgStr[z],Float64,&OK); + if (OK) + if (CodeLen+(Rep<<3)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + Double_2_ieee8(DVal,(Byte *) TurnField,BigEndian); + if (BigEndian) QWSwap((void *) TurnField,8); + if (ListGran()==1) + for (z2=0; z2<Rep; z2++) + BEGIN + BAsmCode[(WLen<<1) ]=Hi(TurnField[3]); + BAsmCode[(WLen<<1)+1]=Lo(TurnField[3]); + BAsmCode[(WLen<<1)+2]=Hi(TurnField[2]); + BAsmCode[(WLen<<1)+3]=Lo(TurnField[2]); + BAsmCode[(WLen<<1)+4]=Hi(TurnField[1]); + BAsmCode[(WLen<<1)+5]=Lo(TurnField[1]); + BAsmCode[(WLen<<1)+6]=Hi(TurnField[0]); + BAsmCode[(WLen<<1)+7]=Lo(TurnField[0]); + WLen+=4; + END + else + for (z2=0; z2<Rep; z2++) + BEGIN + WAsmCode[WLen++]=TurnField[3]; + WAsmCode[WLen++]=TurnField[2]; + WAsmCode[WLen++]=TurnField[1]; + WAsmCode[WLen++]=TurnField[0]; + END + CodeLen+=Rep<<3; + END + break; + case 6: + DVal=EvalFloatExpression(ArgStr[z],Float64,&OK); + if (OK) + if (CodeLen+(Rep*12)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + Double_2_ieee10(DVal,(Byte *) TurnField,False); + if (BigEndian) WSwap((void *) TurnField,10); + if (ListGran()==1) + for (z2=0; z2<Rep; z2++) + BEGIN + BAsmCode[(WLen<<1) ]=Hi(TurnField[4]); + BAsmCode[(WLen<<1)+ 1]=Lo(TurnField[4]); + BAsmCode[(WLen<<1)+ 2]=0; + BAsmCode[(WLen<<1)+ 3]=0; + BAsmCode[(WLen<<1)+ 4]=Hi(TurnField[3]); + BAsmCode[(WLen<<1)+ 5]=Lo(TurnField[3]); + BAsmCode[(WLen<<1)+ 6]=Hi(TurnField[2]); + BAsmCode[(WLen<<1)+ 7]=Lo(TurnField[2]); + BAsmCode[(WLen<<1)+ 8]=Hi(TurnField[1]); + BAsmCode[(WLen<<1)+ 9]=Lo(TurnField[1]); + BAsmCode[(WLen<<1)+10]=Hi(TurnField[0]); + BAsmCode[(WLen<<1)+11]=Lo(TurnField[0]); + WLen+=6; + END + else + for (z2=0; z2<Rep; z2++) + BEGIN + WAsmCode[WLen++]=TurnField[4]; + WAsmCode[WLen++]=0; + WAsmCode[WLen++]=TurnField[3]; + WAsmCode[WLen++]=TurnField[2]; + WAsmCode[WLen++]=TurnField[1]; + WAsmCode[WLen++]=TurnField[0]; + END + CodeLen+=Rep*12; + END + break; + case 7: + DVal=EvalFloatExpression(ArgStr[z],Float64,&OK); + if (OK) + if (CodeLen+(Rep*12)>MaxCodeLen) + BEGIN + WrError(1920); OK=False; + END + else + BEGIN + ConvertDec(DVal,TurnField); + if (ListGran()==1) + for (z2=0; z2<Rep; z2++) + BEGIN + BAsmCode[(WLen<<1) ]=Hi(TurnField[5]); + BAsmCode[(WLen<<1)+ 1]=Lo(TurnField[5]); + BAsmCode[(WLen<<1)+ 2]=Hi(TurnField[4]); + BAsmCode[(WLen<<1)+ 3]=Lo(TurnField[4]); + BAsmCode[(WLen<<1)+ 4]=Hi(TurnField[3]); + BAsmCode[(WLen<<1)+ 5]=Lo(TurnField[3]); + BAsmCode[(WLen<<1)+ 6]=Hi(TurnField[2]); + BAsmCode[(WLen<<1)+ 7]=Lo(TurnField[2]); + BAsmCode[(WLen<<1)+ 8]=Hi(TurnField[1]); + BAsmCode[(WLen<<1)+ 9]=Lo(TurnField[1]); + BAsmCode[(WLen<<1)+10]=Hi(TurnField[0]); + BAsmCode[(WLen<<1)+11]=Lo(TurnField[0]); + WLen+=6; + END + else + for (z2=0; z2<Rep; z2++) + BEGIN + WAsmCode[WLen++]=TurnField[5]; + WAsmCode[WLen++]=TurnField[4]; + WAsmCode[WLen++]=TurnField[3]; + WAsmCode[WLen++]=TurnField[2]; + WAsmCode[WLen++]=TurnField[1]; + WAsmCode[WLen++]=TurnField[0]; + END + CodeLen+=Rep*12; + END + break; + END + END + z++; + END + while ((z<=ArgCnt) AND (OK)); + if (NOT OK) CodeLen=0; + if ((DoPadding) AND ((CodeLen&1)==1)) EnterByte(0); + END + return True; + END + + if (Memo("DS")) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + FirstPassUnknown=False; + HVal=EvalIntExpression(ArgStr[1],Int32,&ValOK); + if (FirstPassUnknown) WrError(1820); + if ((ValOK) AND (NOT FirstPassUnknown)) + BEGIN + DontPrint=True; + switch (OpSize) + BEGIN + case 0: WSize=1; if (((HVal&1)==1) AND (DoPadding)) HVal++; break; + case 1: WSize=2; break; + case 2: + case 4: WSize=4; break; + case 3: + case 5: WSize=8; break; + case 6: + case 7: WSize=12; break; + default: WSize=0; + END + if (HVal==0) + BEGIN + NewPC=ProgCounter()+WSize-1; + NewPC=NewPC-(NewPC % WSize); + CodeLen=NewPC-ProgCounter(); + if (CodeLen==0) DontPrint=False; + END + else CodeLen=HVal*WSize; + if (DontPrint) BookKeeping(); + END + END + return True; + END + + return False; +END + + + void CodeEquate(ShortInt DestSeg, LargeInt Min, LargeInt Max) +BEGIN + Boolean OK; + TempResult t; + LargeInt Erg; + + FirstPassUnknown=False; + if (ArgCnt!=1) WrError(1110); + else + BEGIN + Erg=EvalIntExpression(ArgStr[1],Int32,&OK); + if ((OK) AND (NOT FirstPassUnknown)) + if (Min>Erg) WrError(1315); + else if (Erg>Max) WrError(1320); + else + BEGIN + PushLocHandle(-1); + EnterIntSymbol(LabPart,Erg,DestSeg,False); + PopLocHandle(); + if (MakeUseList) + if (AddChunk(SegChunks+DestSeg,Erg,1,False)) WrError(90); + t.Typ=TempInt; t.Contents.Int=Erg; SetListLineVal(&t); + END + END +END + + void CodeASSUME(ASSUMERec *Def, Integer Cnt) +BEGIN + int z1,z2; + Boolean OK; + LongInt HVal; + String RegPart,ValPart; + + if (ArgCnt==0) WrError(1110); + else + BEGIN + z1=1; OK=True; + while ((z1<=ArgCnt) AND (OK)) + BEGIN + SplitString(ArgStr[z1],RegPart,ValPart,QuotPos(ArgStr[z1],':')); + z2=0; NLS_UpString(RegPart); + while ((z2<Cnt) AND (strcmp(Def[z2].Name,RegPart)!=0)) z2++; + OK=(z2<Cnt); + if (NOT OK) WrXError(1980,RegPart); + else + if (strcmp(ValPart,"NOTHING")==0) + if (Def[z2].NothingVal==-1) WrError(1350); + else *Def[z2].Dest=Def[z2].NothingVal; + else + BEGIN + FirstPassUnknown=False; + HVal=EvalIntExpression(ValPart,Int32,&OK); + if (OK) + if (FirstPassUnknown) + BEGIN + WrError(1820); OK=False; + END + else if (ChkRange(HVal,Def[z2].Min,Def[z2].Max)) *Def[z2].Dest=HVal; + END + z1++; + END + END +END + + void codepseudo_init(void) +BEGIN +END + |