dect
/
asl
Archived
13
0
Fork 0
Code Issues Releases Activity
This repository has been archived on 2022-02-17. You can view files and clone it, but cannot push or open issues or pull requests.
asl/codepseudo.c

1247 lines
30 KiB
C
Raw Permalink Blame History

/* 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
Reference in New Issue View Git Blame Copy Permalink