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/asmsub.c

1527 lines
41 KiB
C
Raw Permalink Blame History

/* asmsub.c */
/*****************************************************************************/
/* AS-Portierung */
/* */
/* Unterfunktionen, vermischtes */
/* */
/* Historie: 4. 5.1996 Grundsteinlegung */
/* 13. 8.1997 KillBlanks-Funktionen nach stringutil.c geschoben */
/* 26. 6.1998 Fehlermeldung Codepage nicht gefunden */
/* 7. 7.1998 Fix Zugriffe auf CharTransTable wg. signed chars */
/* 17. 8.1998 Unterfunktion zur Buchhaltung Adressbereiche */
/* 1. 9.1998 FloatString behandelte Sonderwerte nicht korrekt */
/* 13. 9.1998 Prozessorliste macht Zeilenvorschub nach 6 Namen */
/* 14.10.1998 Fehlerzeilen mit > > > */
/* 30. 1.1999 Formatstrings maschinenunabhaengig gemacht */
/* 18. 4.1999 Ausgabeliste Sharefiles */
/* 13. 7.1999 Fehlermeldungen relokatible Symbole */
/* 13. 9.1999 I/O-Fehler 25 ignorieren */
/* 5.11.1999 ExtendErrors ist jetzt ShortInt */
/* */
/*****************************************************************************/
#include "stdinc.h"
#include <string.h>
#include <ctype.h>
#include "version.h"
#include "endian.h"
#include "stdhandl.h"
#include "nls.h"
#include "nlmessages.h"
#include "as.rsc"
#include "strutil.h"
#include "stringlists.h"
#include "chunks.h"
#include "ioerrs.h"
#include "asmdef.h"
#include "asmpars.h"
#include "asmdebug.h"
#include "as.h"
#include "asmsub.h"
#ifdef __TURBOC__
#ifdef __DPMI16__
#define STKSIZE 40960
#else
#define STKSIZE 49152
#endif
#endif
Word ErrorCount,WarnCount;
static StringList CopyrightList, OutList, ShareOutList;
static LongWord StartStack,MinStack,LowStack;
/****************************************************************************/
/* Modulinitialisierung */
void AsmSubInit(void)
BEGIN
PageLength=60; PageWidth=0;
ErrorCount=0; WarnCount=0;
END
/****************************************************************************/
/* neuen Prozessor definieren */
CPUVar AddCPU(char *NewName, TSwitchProc Switcher)
BEGIN
PCPUDef Lauf,Neu;
char *p;
Neu=(PCPUDef) malloc(sizeof(TCPUDef));
Neu->Name=strdup(NewName);
/* kein UpString, weil noch nicht initialisiert ! */
for (p=Neu->Name; *p!='\0'; p++) *p=toupper(*p);
Neu->SwitchProc=Switcher;
Neu->Next=Nil;
Neu->Number=Neu->Orig=CPUCnt;
Lauf=FirstCPUDef;
if (Lauf==Nil) FirstCPUDef=Neu;
else
BEGIN
while (Lauf->Next!=Nil) Lauf=Lauf->Next;
Lauf->Next=Neu;
END
return CPUCnt++;
END
Boolean AddCPUAlias(char *OrigName, char *AliasName)
BEGIN
PCPUDef Lauf=FirstCPUDef,Neu;
while ((Lauf!=Nil) AND (strcmp(Lauf->Name,OrigName)!=0)) Lauf=Lauf->Next;
if (Lauf==Nil) return False;
else
BEGIN
Neu=(PCPUDef) malloc(sizeof(TCPUDef));
Neu->Next=Nil;
Neu->Name=strdup(AliasName);
Neu->Number=CPUCnt++;
Neu->Orig=Lauf->Orig;
Neu->SwitchProc=Lauf->SwitchProc;
while (Lauf->Next!=Nil) Lauf=Lauf->Next;
Lauf->Next=Neu;
return True;
END
END
void PrintCPUList(TSwitchProc NxtProc)
BEGIN
PCPUDef Lauf;
TSwitchProc Proc;
int cnt;
Lauf=FirstCPUDef; Proc=NullProc; cnt=0;
while (Lauf!=Nil)
BEGIN
if (Lauf->Number==Lauf->Orig)
BEGIN
if ((Lauf->SwitchProc!=Proc) OR (cnt==7))
BEGIN
Proc=Lauf->SwitchProc; printf("\n"); NxtProc(); cnt=0;
END
printf("%-10s",Lauf->Name); cnt++;
END
Lauf=Lauf->Next;
END
printf("\n"); NxtProc();
END
void ClearCPUList(void)
BEGIN
PCPUDef Save;
while (FirstCPUDef!=Nil)
BEGIN
Save=FirstCPUDef; FirstCPUDef=Save->Next;
free(Save->Name); free(Save);
END
END
/****************************************************************************/
/* Copyrightlistenverwaltung */
void AddCopyright(char *NewLine)
BEGIN
AddStringListLast(&CopyrightList,NewLine);
END
void WriteCopyrights(TSwitchProc NxtProc)
BEGIN
StringRecPtr Lauf;
if (NOT StringListEmpty(CopyrightList))
BEGIN
printf("%s\n",GetStringListFirst(CopyrightList,&Lauf)); NxtProc();
while (Lauf!=Nil)
BEGIN
printf("%s\n",GetStringListNext(&Lauf)); NxtProc();
END
END
END
/*--------------------------------------------------------------------------*/
/* ermittelt das erste/letzte Auftauchen eines Zeichens ausserhalb */
/* "geschuetzten" Bereichen */
#if 0
char *QuotPos(char *s, char Zeichen)
BEGIN
register int Cnt=0;
register char *i;
register char ch,Cmp2,Cmp3;
for (i=s; (ch=*i)!='\0'; i++)
if (Cnt==0)
BEGIN
if (ch==Zeichen) return i;
else switch (ch)
BEGIN
case '"':
case '\'': Cmp2='\0'; Cmp3=ch; Cnt=1; break;
case '(': Cmp2='('; Cmp3=')'; Cnt=1; break;
case '[': Cmp2='['; Cmp3=']'; Cnt=1; break;
END
END
else
BEGIN
if (ch==Cmp2) Cnt++;
else if (ch==Cmp3) Cnt--;
END
return Nil;
END
#else
char *QuotPos(char *s, char Zeichen)
BEGIN
register ShortInt Brack=0,AngBrack=0;
register char *i;
register LongWord Flag=0;
static Boolean First=True,Imp[256],Save;
if (First)
BEGIN
memset(Imp,False,256);
Imp['"']=Imp['\'']=Imp['(']=Imp[')']=Imp['[']=Imp[']']=True;
First=False;
END
Save=Imp[(unsigned char)Zeichen]; Imp[(unsigned char)Zeichen]=True;
for (i=s; *i!='\0'; i++)
if (Imp[(unsigned char)*i])
BEGIN
if (*i==Zeichen)
BEGIN
if ((AngBrack|Brack|Flag)==0)
{ Imp[(unsigned char)Zeichen]=Save; return i;}
END
else switch(*i)
BEGIN
case '"': if (((Brack|AngBrack)==0) AND ((Flag&2)==0)) Flag^=1; break;
case '\'':if (((Brack|AngBrack)==0) AND ((Flag&1)==0)) Flag^=2; break;
case '(': if ((AngBrack|Flag)==0) Brack++; break;
case ')': if ((AngBrack|Flag)==0) Brack--; break;
case '[': if ((Brack|Flag)==0) AngBrack++; break;
case ']': if ((Brack|Flag)==0) AngBrack--; break;
END
END
Imp[(unsigned char)Zeichen]=Save; return Nil;
END
#endif
char *RQuotPos(char *s, char Zeichen)
BEGIN
ShortInt Brack=0,AngBrack=0;
char *i;
Boolean Quot=False,Paren=False;
for (i=s+strlen(s)-1; i>=s; i--)
if (*i==Zeichen)
BEGIN
if ((AngBrack==0) AND (Brack==0) AND (NOT Paren) AND (NOT Quot)) return i;
END
else switch (*i)
BEGIN
case '"': if ((Brack==0) AND (AngBrack==0) AND (NOT Quot)) Paren=NOT Paren; break;
case '\'':if ((Brack==0) AND (AngBrack==0) AND (NOT Paren)) Quot=NOT Quot; break;
case ')': if ((AngBrack==0) AND (NOT Paren) AND (NOT Quot)) Brack++; break;
case '(': if ((AngBrack==0) AND (NOT Paren) AND (NOT Quot)) Brack--; break;
case ']': if ((Brack==0) AND (NOT Paren) AND (NOT Quot)) AngBrack++; break;
case '[': if ((Brack==0) AND (NOT Paren) AND (NOT Quot)) AngBrack--; break;
END
return Nil;
END
/*--------------------------------------------------------------------------*/
/* ermittelt das erste Leerzeichen in einem String */
char *FirstBlank(char *s)
BEGIN
char *h,*Min=Nil;
h=strchr(s,' ');
if (h!=Nil) if ((Min==Nil) OR (h<Min)) Min=h;
h=strchr(s,Char_HT);
if (h!=Nil) if ((Min==Nil) OR (h<Min)) Min=h;
return Min;
END
/*--------------------------------------------------------------------------*/
/* einen String in zwei Teile zerlegen */
void SplitString(char *Source, char *Left, char *Right, char *Trenner)
BEGIN
char Save;
LongInt slen=strlen(Source);
if ((Trenner==Nil) OR (Trenner>=Source+slen))
Trenner=Source+slen;
Save=(*Trenner); *Trenner='\0';
strcpy(Left,Source); *Trenner=Save;
if (Trenner>=Source+slen) *Right='\0';
else strcpy(Right,Trenner+1);
END
/*--------------------------------------------------------------------------*/
/* verbesserte Grossbuchstabenfunktion */
/* einen String in Grossbuchstaben umwandeln. Dabei Stringkonstanten in Ruhe */
/* lassen */
void UpString(char *s)
BEGIN
char *z;
int hypquot=0;
for (z=s; *z!='\0'; z++)
BEGIN
if ((*z=='\'') AND ((hypquot&2)==0)) hypquot^=1;
else if ((*z=='"') AND ((hypquot&1)==0)) hypquot^=2;
else if (hypquot==0) *z=UpCaseTable[(int)*z];
END
END
/****************************************************************************/
void TranslateString(char *s)
BEGIN
char *z;
for (z=s; *z!='\0'; z++) *z=CharTransTable[((usint)(*z))&0xff];
END
ShortInt StrCmp(char *s1, char *s2, LongInt Hand1, LongInt Hand2)
BEGIN
int tmp;
tmp=(*s1)-(*s2);
if (tmp==0) tmp=strcmp(s1,s2);
if (tmp==0) tmp=Hand1-Hand2;
if (tmp<0) return -1;
if (tmp>0) return 1;
return 0;
END
/****************************************************************************/
/* an einen Dateinamen eine Endung anhaengen */
void AddSuffix(char *s, char *Suff)
BEGIN
char *p,*z,*Part;
p=Nil;
for (z=s; *z!='\0'; z++) if (*z=='\\') p=z;
Part=(p!=Nil)?(p):(s);
if (strchr(Part,'.')==Nil) strmaxcat(s,Suff,255);
END
/*--------------------------------------------------------------------------*/
/* von einem Dateinamen die Endung loeschen */
void KillSuffix(char *s)
BEGIN
char *p,*z,*Part;
p=Nil;
for (z=s; *z!='\0'; z++) if (*z=='\\') p=z;
Part=(p!=Nil)?(p):(s); Part=strchr(Part,'.');
if (Part!=Nil) *Part='\0';
END
/*--------------------------------------------------------------------------*/
/* Pfadanteil (Laufwerk+Verzeichnis) von einem Dateinamen abspalten */
char *PathPart(char *Name)
BEGIN
static String s;
char *p;
strmaxcpy(s,Name,255);
p=strrchr(Name,PATHSEP);
#ifdef DRSEP
if (p==Nil) p=strrchr(Name,DRSEP);
#endif
if (p==Nil) *s='\0'; else s[1]='\0';
return s;
END
/*--------------------------------------------------------------------------*/
/* Namensanteil von einem Dateinamen abspalten */
char *NamePart(char *Name)
BEGIN
char *p=strrchr(Name,PATHSEP);
#ifdef DRSEP
if (p==Nil) p=strrchr(Name,DRSEP);
#endif
return (p==Nil)?(Name):(p+1);
END
/****************************************************************************/
/* eine Gleitkommazahl in einen String umwandeln */
char *FloatString(Double f)
BEGIN
#define MaxLen 18
static String s;
char *p,*d;
sint n,ExpVal,nzeroes;
Boolean WithE,OK;
/* 1. mit Maximallaenge wandeln, fuehrendes Vorzeichen weg */
sprintf(s,"%27.15e",f);
for (p=s; (*p==' ') OR (*p=='+'); p++);
if (p!=s) strcpy(s,p);
/* 2. Exponenten soweit als moeglich kuerzen, evtl. ganz streichen */
p=strchr(s,'e');
if (p==Nil) return s;
switch (*(++p))
BEGIN
case '+': strcpy(p,p+1); break;
case '-': p++; break;
END
while (*p=='0') strcpy(p,p+1);
WithE=(*p!='\0');
if (NOT WithE) s[strlen(s)-1]='\0';
/* 3. Nullen am Ende der Mantisse entfernen, Komma bleibt noch */
if (WithE) p=strchr(s,'e'); else p=s+strlen(s); p--;
while (*p=='0')
BEGIN
strcpy(p,p+1); p--;
END
/* 4. auf die gewuenschte Maximalstellenzahl begrenzen */
if (WithE) p=strchr(s,'e'); else p=s+strlen(s);
d=strchr(s,'.');
n=p-d-1;
/* 5. Maximallaenge ueberschritten ? */
if (strlen(s)>MaxLen) strcpy(d+(n-(strlen(s)-MaxLen)),d+n);
/* 6. Exponentenwert berechnen */
if (WithE)
BEGIN
p=strchr(s,'e');
ExpVal=ConstLongInt(p+1,&OK);
END
else
BEGIN
p=s+strlen(s);
ExpVal=0;
END
/* 7. soviel Platz, dass wir den Exponenten weglassen und evtl. Nullen
anhaengen koennen ? */
if (ExpVal>0)
BEGIN
nzeroes=ExpVal-(p-strchr(s,'.')-1); /* = Zahl von Nullen, die anzuhaengen waere */
/* 7a. nur Kommaverschiebung erforderlich. Exponenten loeschen und
evtl. auch Komma */
if (nzeroes<=0)
BEGIN
*p='\0';
d=strchr(s,'.'); strcpy(d,d+1);
if (nzeroes!=0)
BEGIN
memmove(s+strlen(s)+nzeroes+1,s+strlen(s)+nzeroes,-nzeroes);
s[strlen(s)-1+nzeroes]='.';
END
END
/* 7b. Es muessen Nullen angehaengt werden. Schauen, ob nach Loeschen von
Punkt und E-Teil genuegend Platz ist */
else
BEGIN
n=strlen(p)+1+(MaxLen-strlen(s)); /* = Anzahl freizubekommender Zeichen+Gutschrift */
if (n>=nzeroes)
BEGIN
*p='\0'; d=strchr(s,'.'); strcpy(d,d+1);
d=s+strlen(s);
for (n=0; n<nzeroes; n++) *(d++)='0'; *d='\0';
END
END
END
/* 8. soviel Platz, dass Exponent wegkann und die Zahl mit vielen Nullen
vorne geschrieben werden kann ? */
else if (ExpVal<0)
BEGIN
n=(-ExpVal)-(strlen(p)); /* = Verlaengerung nach Operation */
if (strlen(s)+n<=MaxLen)
BEGIN
*p='\0'; d=strchr(s,'.'); strcpy(d,d+1);
if (s[0]=='-') d=s+1; else d=s;
memmove(d-ExpVal+1,d,strlen(s)+1);
*(d++)='0'; *(d++)='.';
for (n=0; n<-ExpVal-1; n++) *(d++)='0';
END
END
/* 9. Ueberfluessiges Komma entfernen */
if (WithE)
BEGIN
p=strchr(s,'e'); if (p!=Nil) *p='E';
END
else p=s+strlen(s);
if ((p!=Nil) AND (*(p-1)=='.')) strcpy(p-1,p);
return s;
END
/****************************************************************************/
/* Symbol in String wandeln */
void StrSym(TempResult *t, Boolean WithSystem, char *Dest)
BEGIN
switch (t->Typ)
BEGIN
case TempInt:
strcpy(Dest,HexString(t->Contents.Int,1));
if (WithSystem)
switch (ConstMode)
BEGIN
case ConstModeIntel : strcat(Dest,"H"); break;
case ConstModeMoto : strprep(Dest,"$"); break;
case ConstModeC : strprep(Dest,"0x"); break;
END
break;
case TempFloat:
strcpy(Dest,FloatString(t->Contents.Float)); break;
case TempString:
strcpy(Dest,t->Contents.Ascii); break;
default: strcpy(Dest,"???");
END
END
/****************************************************************************/
/* Listingzaehler zuruecksetzen */
void ResetPageCounter(void)
BEGIN
int z;
for (z=0; z<=ChapMax; z++) PageCounter[z]=0;
LstCounter=0; ChapDepth=0;
END
/*--------------------------------------------------------------------------*/
/* eine neue Seite im Listing beginnen */
void NewPage(ShortInt Level, Boolean WithFF)
BEGIN
ShortInt z;
String Header,s;
char Save;
if (ListOn==0) return;
LstCounter=0;
if (ChapDepth<(Byte) Level)
BEGIN
memmove(PageCounter+(Level-ChapDepth),PageCounter,(ChapDepth+1)*sizeof(Word));
for (z=0; z<=Level-ChapDepth; PageCounter[z++]=1);
ChapDepth=Level;
END
for (z=0; z<=Level-1; PageCounter[z++]=1);
PageCounter[Level]++;
if (WithFF)
BEGIN
errno=0; fprintf(LstFile,"%c",Char_FF); ChkIO(10002);
END
sprintf(Header," AS V%s%s%s",Version,getmessage(Num_HeadingFileNameLab),NamePart(SourceFile));
if ((strcmp(CurrFileName,"INTERNAL")!=0) AND (strcmp(NamePart(CurrFileName),NamePart(SourceFile))!=0))
BEGIN
strmaxcat(Header,"(",255);
strmaxcat(Header,NamePart(CurrFileName),255);
strmaxcat(Header,")",255);
END
strmaxcat(Header,getmessage(Num_HeadingPageLab),255);
for (z=ChapDepth; z>=0; z--)
BEGIN
sprintf(s, IntegerFormat, PageCounter[z]);
strmaxcat(Header,s,255);
if (z!=0) strmaxcat(Header,".",255);
END
strmaxcat(Header," - ",255);
NLS_CurrDateString(s); strmaxcat(Header,s,255);
strmaxcat(Header," ",255);
NLS_CurrTimeString(False,s); strmaxcat(Header,s,255);
if (PageWidth!=0)
while (strlen(Header)>PageWidth)
BEGIN
Save=Header[PageWidth]; Header[PageWidth]='\0';
errno=0; fprintf(LstFile,"%s\n",Header); ChkIO(10002);
Header[PageWidth]=Save; strcpy(Header,Header+PageWidth);
END
errno=0; fprintf(LstFile,"%s\n",Header); ChkIO(10002);
if (PrtTitleString[0]!='\0')
BEGIN
errno=0; fprintf(LstFile,"%s\n",PrtTitleString); ChkIO(10002);
END
errno=0; fprintf(LstFile,"\n\n"); ChkIO(10002);
END
/*--------------------------------------------------------------------------*/
/* eine Zeile ins Listing schieben */
void WrLstLine(char *Line)
BEGIN
int LLength;
char bbuf[2500];
String LLine;
int blen=0,hlen,z,Start;
if (ListOn==0) return;
if (PageLength==0)
BEGIN
errno=0; fprintf(LstFile,"%s\n",Line); ChkIO(10002);
END
else
BEGIN
if ((PageWidth==0) OR ((strlen(Line)<<3)<PageWidth)) LLength=1;
else
BEGIN
blen=0;
for (z=0; z<strlen(Line); z++)
if (Line[z]==Char_HT)
BEGIN
memset(bbuf+blen,8-(blen&7),' ');
blen+=8-(blen&7);
END
else bbuf[blen++]=Line[z];
LLength=blen/PageWidth; if (blen%PageWidth!=0) LLength++;
END
if (LLength==1)
BEGIN
errno=0; fprintf(LstFile,"%s\n",Line); ChkIO(10002);
if ((++LstCounter)==PageLength) NewPage(0,True);
END
else
BEGIN
Start=0;
for (z=1; z<=LLength; z++)
BEGIN
hlen=PageWidth; if (blen-Start<hlen) hlen=blen-Start;
memcpy(LLine,bbuf+Start,hlen); LLine[hlen]='\0';
errno=0; fprintf(LstFile,"%s\n",LLine);
if ((++LstCounter)==PageLength) NewPage(0,True);
Start+=hlen;
END
END
END
END
/*****************************************************************************/
/* Ausdruck in Spalte vor Listing */
void SetListLineVal(TempResult *t)
BEGIN
StrSym(t,True,ListLine); strmaxprep(ListLine,"=",255);
if (strlen(ListLine)>14)
BEGIN
ListLine[12]='\0'; strmaxcat(ListLine,"..",255);
END
END
/****************************************************************************/
/* einen Symbolnamen auf Gueltigkeit ueberpruefen */
Boolean ChkSymbName(char *sym)
BEGIN
char *z;
if (*sym=='\0') return False;
if (NOT (isalpha((unsigned int) *sym) OR (*sym=='_') OR (*sym=='.'))) return False;
for (z=sym; *z!='\0'; z++)
if (NOT (isalnum((unsigned int) *z) OR (*z=='_') OR (*z=='.'))) return False;
return True;
END
Boolean ChkMacSymbName(char *sym)
BEGIN
char *z;
if (*sym=='\0') return False;
if (NOT isalpha((unsigned int) *sym)) return False;
for (z=sym; *z!='\0'; z++)
if (NOT isalnum((unsigned int) *z)) return False;
return True;
END
/****************************************************************************/
/* Fehlerkanal offen ? */
static void ForceErrorOpen(void)
BEGIN
if (NOT IsErrorOpen)
BEGIN
RewriteStandard(&ErrorFile,ErrorName); IsErrorOpen=True;
if (ErrorFile==Nil) ChkIO(10001);
END
END
/*--------------------------------------------------------------------------*/
/* eine Fehlermeldung mit Klartext ausgeben */
static void EmergencyStop(void)
BEGIN
if ((IsErrorOpen) AND (ErrorFile!=Nil)) fclose(ErrorFile);
fclose(LstFile);
if (ShareMode!=0)
BEGIN
fclose(ShareFile); unlink(ShareName);
END
if (MacProOutput)
BEGIN
fclose(MacProFile); unlink(MacProName);
END
if (MacroOutput)
BEGIN
fclose(MacroFile); unlink(MacroName);
END
if (MakeDebug) fclose(Debug);
if (CodeOutput)
BEGIN
fclose(PrgFile); unlink(OutName);
END
END
void WrErrorString(char *Message, char *Add, Boolean Warning, Boolean Fatal)
BEGIN
String h,h2;
char *p;
FILE *errfile;
strcpy(h,"> > >");
strmaxcat(h,p=GetErrorPos(),255); free(p);
if (NOT Warning)
BEGIN
strmaxcat(h,getmessage(Num_ErrName),255);
strmaxcat(h,Add,255);
strmaxcat(h,": ",255);
ErrorCount++;
END
else
BEGIN
strmaxcat(h,getmessage(Num_WarnName),255);
strmaxcat(h,Add,255);
strmaxcat(h,": ",255);
WarnCount++;
END
if ((strcmp(LstName, "/dev/null") != 0) AND (NOT Fatal))
BEGIN
strmaxcpy(h2, h, 255); strmaxcat(h2, Message, 255); WrLstLine(h2);
if ((ExtendErrors > 0) AND (*ExtendError != '\0'))
BEGIN
sprintf(h2, "> > > %s", ExtendError); WrLstLine(h2);
END
if (ExtendErrors > 1)
BEGIN
sprintf(h2, "> > > %s", OneLine); WrLstLine(h2);
END
END
ForceErrorOpen();
if ((strcmp(LstName, "!1")!=0) OR (Fatal))
BEGIN
errfile = (ErrorFile == Nil) ? stdout : ErrorFile;
fprintf(errfile, "%s%s%s\n", h, Message, ClrEol);
if ((ExtendErrors > 0) AND (*ExtendError != '\0'))
fprintf(errfile, "> > > %s%s\n", ExtendError, ClrEol);
if (ExtendErrors > 1)
fprintf(errfile, "> > > %s%s\n", OneLine, ClrEol);
END
*ExtendError = '\0';
if (Fatal)
BEGIN
fprintf((ErrorFile==Nil)?stdout:ErrorFile,"%s\n",getmessage(Num_ErrMsgIsFatal));
EmergencyStop();
exit(3);
END
END
/*--------------------------------------------------------------------------*/
/* eine Fehlermeldung ueber Code ausgeben */
static void WrErrorNum(Word Num)
BEGIN
String h;
char Add[11];
int msgno;
if ((NOT CodeOutput) AND (Num==1200)) return;
if ((SuppWarns) AND (Num<1000)) return;
switch (Num)
BEGIN
case 0: msgno=Num_ErrMsgUselessDisp; break;
case 10: msgno=Num_ErrMsgShortAddrPossible; break;
case 20: msgno=Num_ErrMsgShortJumpPossible; break;
case 30: msgno=Num_ErrMsgNoShareFile; break;
case 40: msgno=Num_ErrMsgBigDecFloat; break;
case 50: msgno=Num_ErrMsgPrivOrder; break;
case 60: msgno=Num_ErrMsgDistNull; break;
case 70: msgno=Num_ErrMsgWrongSegment; break;
case 75: msgno=Num_ErrMsgInAccSegment; break;
case 80: msgno=Num_ErrMsgPhaseErr; break;
case 90: msgno=Num_ErrMsgOverlap; break;
case 100: msgno=Num_ErrMsgNoCaseHit; break;
case 110: msgno=Num_ErrMsgInAccPage; break;
case 120: msgno=Num_ErrMsgRMustBeEven; break;
case 130: msgno=Num_ErrMsgObsolete; break;
case 140: msgno=Num_ErrMsgUnpredictable; break;
case 150: msgno=Num_ErrMsgAlphaNoSense; break;
case 160: msgno=Num_ErrMsgSenseless; break;
case 170: msgno=Num_ErrMsgRepassUnknown; break;
case 180: msgno=Num_ErrMsgAddrNotAligned; break;
case 190: msgno=Num_ErrMsgIOAddrNotAllowed; break;
case 200: msgno=Num_ErrMsgPipeline; break;
case 210: msgno=Num_ErrMsgDoubleAdrRegUse; break;
case 220: msgno=Num_ErrMsgNotBitAddressable; break;
case 230: msgno=Num_ErrMsgStackNotEmpty; break;
case 240: msgno=Num_ErrMsgNULCharacter; break;
case 250: msgno=Num_ErrMsgPageCrossing; break;
case 260: msgno=Num_ErrMsgWOverRange; break;
case 270: msgno=Num_ErrMsgNegDUP; break;
case 1000: msgno=Num_ErrMsgDoubleDef; break;
case 1010: msgno=Num_ErrMsgSymbolUndef; break;
case 1020: msgno=Num_ErrMsgInvSymName; break;
case 1090: msgno=Num_ErrMsgInvFormat; break;
case 1100: msgno=Num_ErrMsgUseLessAttr; break;
case 1105: msgno=Num_ErrMsgTooLongAttr; break;
case 1107: msgno=Num_ErrMsgUndefAttr; break;
case 1110: msgno=Num_ErrMsgWrongArgCnt; break;
case 1115: msgno=Num_ErrMsgWrongOptCnt; break;
case 1120: msgno=Num_ErrMsgOnlyImmAddr; break;
case 1130: msgno=Num_ErrMsgInvOpsize; break;
case 1131: msgno=Num_ErrMsgConfOpSizes; break;
case 1132: msgno=Num_ErrMsgUndefOpSizes; break;
case 1135: msgno=Num_ErrMsgInvOpType; break;
case 1140: msgno=Num_ErrMsgTooMuchArgs; break;
case 1150: msgno=Num_ErrMsgNoRelocs; break;
case 1155: msgno=Num_ErrMsgUnresRelocs; break;
case 1200: msgno=Num_ErrMsgUnknownOpcode; break;
case 1300: msgno=Num_ErrMsgBrackErr; break;
case 1310: msgno=Num_ErrMsgDivByZero; break;
case 1315: msgno=Num_ErrMsgUnderRange; break;
case 1320: msgno=Num_ErrMsgOverRange; break;
case 1325: msgno=Num_ErrMsgNotAligned; break;
case 1330: msgno=Num_ErrMsgDistTooBig; break;
case 1335: msgno=Num_ErrMsgInAccReg; break;
case 1340: msgno=Num_ErrMsgNoShortAddr; break;
case 1350: msgno=Num_ErrMsgInvAddrMode; break;
case 1351: msgno=Num_ErrMsgMustBeEven; break;
case 1355: msgno=Num_ErrMsgInvParAddrMode; break;
case 1360: msgno=Num_ErrMsgUndefCond; break;
case 1370: msgno=Num_ErrMsgJmpDistTooBig; break;
case 1375: msgno=Num_ErrMsgDistIsOdd; break;
case 1380: msgno=Num_ErrMsgInvShiftArg; break;
case 1390: msgno=Num_ErrMsgRange18; break;
case 1400: msgno=Num_ErrMsgShiftCntTooBig; break;
case 1410: msgno=Num_ErrMsgInvRegList; break;
case 1420: msgno=Num_ErrMsgInvCmpMode; break;
case 1430: msgno=Num_ErrMsgInvCPUType; break;
case 1440: msgno=Num_ErrMsgInvCtrlReg; break;
case 1445: msgno=Num_ErrMsgInvReg; break;
case 1450: msgno=Num_ErrMsgNoSaveFrame; break;
case 1460: msgno=Num_ErrMsgNoRestoreFrame; break;
case 1465: msgno=Num_ErrMsgUnknownMacArg; break;
case 1470: msgno=Num_ErrMsgMissEndif; break;
case 1480: msgno=Num_ErrMsgInvIfConst; break;
case 1483: msgno=Num_ErrMsgDoubleSection; break;
case 1484: msgno=Num_ErrMsgInvSection; break;
case 1485: msgno=Num_ErrMsgMissingEndSect; break;
case 1486: msgno=Num_ErrMsgWrongEndSect; break;
case 1487: msgno=Num_ErrMsgNotInSection; break;
case 1488: msgno=Num_ErrMsgUndefdForward; break;
case 1489: msgno=Num_ErrMsgContForward; break;
case 1490: msgno=Num_ErrMsgInvFuncArgCnt; break;
case 1495: msgno=Num_ErrMsgMissingLTORG; break;
case 1500: msgno= -1;
sprintf(h,"%s%s%s",getmessage(Num_ErrMsgNotOnThisCPU1),
MomCPUIdent,getmessage(Num_ErrMsgNotOnThisCPU2));
break;
case 1505: msgno= -1;
sprintf(h,"%s%s%s",getmessage(Num_ErrMsgNotOnThisCPU3),
MomCPUIdent,getmessage(Num_ErrMsgNotOnThisCPU2));
break;
case 1510: msgno=Num_ErrMsgInvBitPos; break;
case 1520: msgno=Num_ErrMsgOnlyOnOff; break;
case 1530: msgno=Num_ErrMsgStackEmpty; break;
case 1540: msgno=Num_ErrMsgNotOneBit; break;
case 1550: msgno=Num_ErrMsgMissingStruct; break;
case 1551: msgno=Num_ErrMsgOpenStruct; break;
case 1552: msgno=Num_ErrMsgWrongStruct; break;
case 1553: msgno=Num_ErrMsgPhaseDisallowed; break;
case 1554: msgno=Num_ErrMsgInvStructDir; break;
case 1600: msgno=Num_ErrMsgShortRead; break;
case 1610: msgno=Num_ErrMsgUnknownCodepage; break;
case 1700: msgno=Num_ErrMsgRomOffs063; break;
case 1710: msgno=Num_ErrMsgInvFCode; break;
case 1720: msgno=Num_ErrMsgInvFMask; break;
case 1730: msgno=Num_ErrMsgInvMMUReg; break;
case 1740: msgno=Num_ErrMsgLevel07; break;
case 1750: msgno=Num_ErrMsgInvBitMask; break;
case 1760: msgno=Num_ErrMsgInvRegPair; break;
case 1800: msgno=Num_ErrMsgOpenMacro; break;
case 1805: msgno=Num_ErrMsgEXITMOutsideMacro; break;
case 1810: msgno=Num_ErrMsgTooManyMacParams; break;
case 1815: msgno=Num_ErrMsgDoubleMacro; break;
case 1820: msgno=Num_ErrMsgFirstPassCalc; break;
case 1830: msgno=Num_ErrMsgTooManyNestedIfs; break;
case 1840: msgno=Num_ErrMsgMissingIf; break;
case 1850: msgno=Num_ErrMsgRekMacro; break;
case 1860: msgno=Num_ErrMsgUnknownFunc; break;
case 1870: msgno=Num_ErrMsgInvFuncArg; break;
case 1880: msgno=Num_ErrMsgFloatOverflow; break;
case 1890: msgno=Num_ErrMsgInvArgPair; break;
case 1900: msgno=Num_ErrMsgNotOnThisAddress; break;
case 1905: msgno=Num_ErrMsgNotFromThisAddress; break;
case 1910: msgno=Num_ErrMsgTargOnDiffPage; break;
case 1920: msgno=Num_ErrMsgCodeOverflow; break;
case 1925: msgno=Num_ErrMsgAdrOverflow; break;
case 1930: msgno=Num_ErrMsgMixDBDS; break;
case 1940: msgno=Num_ErrMsgNotInStruct; break;
case 1950: msgno=Num_ErrMsgParNotPossible; break;
case 1960: msgno=Num_ErrMsgInvSegment; break;
case 1961: msgno=Num_ErrMsgUnknownSegment; break;
case 1962: msgno=Num_ErrMsgUnknownSegReg; break;
case 1970: msgno=Num_ErrMsgInvString; break;
case 1980: msgno=Num_ErrMsgInvRegName; break;
case 1985: msgno=Num_ErrMsgInvArg; break;
case 1990: msgno=Num_ErrMsgNoIndir; break;
case 1995: msgno=Num_ErrMsgNotInThisSegment; break;
case 1996: msgno=Num_ErrMsgNotInMaxmode; break;
case 1997: msgno=Num_ErrMsgOnlyInMaxmode; break;
case 10001: msgno=Num_ErrMsgOpeningFile; break;
case 10002: msgno=Num_ErrMsgListWrError; break;
case 10003: msgno=Num_ErrMsgFileReadError; break;
case 10004: msgno=Num_ErrMsgFileWriteError; break;
case 10006: msgno=Num_ErrMsgHeapOvfl; break;
case 10007: msgno=Num_ErrMsgStackOvfl; break;
default : msgno= -1;
sprintf(h,"%s %d",getmessage(Num_ErrMsgIntError),(int) Num);
END
if (msgno!=-1) strmaxcpy(h,getmessage(msgno),255);
if (((Num==1910) OR (Num==1370)) AND (NOT Repass)) JmpErrors++;
if (NumericErrors) sprintf(Add,"#%d", (int)Num);
else *Add='\0';
WrErrorString(h,Add,Num<1000,Num>=10000);
END
void WrError(Word Num)
BEGIN
*ExtendError='\0'; WrErrorNum(Num);
END
void WrXError(Word Num, char *Message)
BEGIN
strmaxcpy(ExtendError,Message,255); WrErrorNum(Num);
END
/*--------------------------------------------------------------------------*/
/* I/O-Fehler */
void ChkIO(Word ErrNo)
BEGIN
int io;
io=errno; if ((io == 0) OR (io == 19) OR (io == 25)) return;
WrXError(ErrNo,GetErrorMsg(io));
END
/*--------------------------------------------------------------------------*/
/* Bereichsfehler */
Boolean ChkRange(LargeInt Value, LargeInt Min, LargeInt Max)
BEGIN
char s1[100],s2[100];
if (Value<Min)
BEGIN
strmaxcpy(s1,LargeString(Value),99);
strmaxcpy(s2,LargeString(Min),99);
strmaxcat(s1,"<",99); strmaxcat(s1,s2,99);
WrXError(1315,s1); return False;
END
else if (Value>Max)
BEGIN
strmaxcpy(s1,LargeString(Value),99);
strmaxcpy(s2,LargeString(Max),99);
strmaxcat(s1,">",99); strmaxcat(s1,s2,99);
WrXError(1320,s1); return False;
END
else return True;
END
/****************************************************************************/
LargeWord ProgCounter(void)
BEGIN
return PCs[ActPC];
END
/*--------------------------------------------------------------------------*/
/* aktuellen Programmzaehler mit Phasenverschiebung holen */
LargeWord EProgCounter(void)
BEGIN
return PCs[ActPC]+Phases[ActPC];
END
/*--------------------------------------------------------------------------*/
/* Granularitaet des aktuellen Segments holen */
Word Granularity(void)
BEGIN
return Grans[ActPC];
END
/*--------------------------------------------------------------------------*/
/* Linstingbreite des aktuellen Segments holen */
Word ListGran(void)
BEGIN
return ListGrans[ActPC];
END
/*--------------------------------------------------------------------------*/
/* pruefen, ob alle Symbole einer Formel im korrekten Adressraum lagen */
void ChkSpace(Byte Space)
BEGIN
Byte Mask=0xff-(1<<Space);
if ((TypeFlag&Mask)!=0) WrError(70);
END
/****************************************************************************/
/* eine Chunkliste im Listing ausgeben & Speicher loeschen */
void PrintChunk(ChunkList *NChunk)
BEGIN
LargeWord NewMin,FMin;
Boolean Found;
Word p=0,z;
int BufferZ;
String BufferS;
NewMin=0; BufferZ=0; *BufferS='\0';
do
BEGIN
/* niedrigsten Start finden, der ueberhalb des letzten Endes liegt */
Found=False;
#ifdef __STDC__
FMin=0xffffffffu;
#else
FMin=0xffffffff;
#endif
for (z=0; z<NChunk->RealLen; z++)
if (NChunk->Chunks[z].Start>=NewMin)
if (FMin>NChunk->Chunks[z].Start)
BEGIN
Found=True; FMin=NChunk->Chunks[z].Start; p=z;
END
if (Found)
BEGIN
strmaxcat(BufferS,HexString(NChunk->Chunks[p].Start,0),255);
if (NChunk->Chunks[p].Length!=1)
BEGIN
strmaxcat(BufferS,"-",255);
strmaxcat(BufferS,HexString(NChunk->Chunks[p].Start+NChunk->Chunks[p].Length-1,0),255);
END
strmaxcat(BufferS,Blanks(19-strlen(BufferS)%19),255);
if (++BufferZ==4)
BEGIN
WrLstLine(BufferS); *BufferS='\0'; BufferZ=0;
END
NewMin=NChunk->Chunks[p].Start+NChunk->Chunks[p].Length;
END
END
while (Found);
if (BufferZ!=0) WrLstLine(BufferS);
END
/*--------------------------------------------------------------------------*/
/* Listen ausgeben */
void PrintUseList(void)
BEGIN
int z,z2,l;
String s;
for (z=1; z<=PCMax; z++)
if (SegChunks[z].Chunks!=Nil)
BEGIN
sprintf(s," %s%s%s",getmessage(Num_ListSegListHead1),SegNames[z],
getmessage(Num_ListSegListHead2));
WrLstLine(s);
strcpy(s," ");
l=strlen(SegNames[z])+strlen(getmessage(Num_ListSegListHead1))+strlen(getmessage(Num_ListSegListHead2));
for (z2=0; z2<l; z2++) strmaxcat(s,"-",255);
WrLstLine(s);
WrLstLine("");
PrintChunk(SegChunks+z);
WrLstLine("");
END
END
void ClearUseList(void)
BEGIN
int z;
for (z=1; z<=PCMax; z++)
ClearChunk(SegChunks+z);
END
/****************************************************************************/
/* Include-Pfadlistenverarbeitung */
static char *GetPath(char *Acc)
BEGIN
char *p;
static String tmp;
p=strchr(Acc,DIRSEP);
if (p==Nil)
BEGIN
strmaxcpy(tmp,Acc,255); Acc[0]='\0';
END
else
BEGIN
*p='\0'; strmaxcpy(tmp,Acc,255); strcpy(Acc,p+1);
END
return tmp;
END
void AddIncludeList(char *NewPath)
BEGIN
String Test;
strmaxcpy(Test,IncludeList,255);
while (*Test!='\0')
if (strcmp(GetPath(Test),NewPath)==0) return;
if (*IncludeList!='\0') strmaxprep(IncludeList,SDIRSEP,255);
strmaxprep(IncludeList,NewPath,255);
END
void RemoveIncludeList(char *RemPath)
BEGIN
String Save;
char *Part;
strmaxcpy(IncludeList,Save,255); IncludeList[0]='\0';
while (Save[0]!='\0')
BEGIN
Part=GetPath(Save);
if (strcmp(Part,RemPath)!=0)
BEGIN
if (IncludeList[0]!='\0') strmaxcat(IncludeList,SDIRSEP,255);
strmaxcat(IncludeList,Part,255);
END
END
END
/****************************************************************************/
/* Liste mit Ausgabedateien */
void ClearOutList(void)
BEGIN
ClearStringList(&OutList);
END
void AddToOutList(char *NewName)
BEGIN
AddStringListLast(&OutList,NewName);
END
void RemoveFromOutList(char *OldName)
BEGIN
RemoveStringList(&OutList,OldName);
END
char *GetFromOutList(void)
BEGIN
return GetAndCutStringList(&OutList);
END
void ClearShareOutList(void)
BEGIN
ClearStringList(&ShareOutList);
END
void AddToShareOutList(char *NewName)
BEGIN
AddStringListLast(&ShareOutList,NewName);
END
void RemoveFromShareOutList(char *OldName)
BEGIN
RemoveStringList(&ShareOutList,OldName);
END
char *GetFromShareOutList(void)
BEGIN
return GetAndCutStringList(&ShareOutList);
END
/****************************************************************************/
/* Tokenverarbeitung */
static Boolean CompressLine_NErl(char ch)
BEGIN
return (((ch>='A') AND (ch<='Z')) OR ((ch>='a') AND (ch<='z')) OR ((ch>='0') AND (ch<='9')));
END
void CompressLine(char *TokNam, Byte Num, char *Line)
BEGIN
int z,e,tlen,llen;
Boolean SFound;
z=0; tlen=strlen(TokNam); llen=strlen(Line);
while (z<=llen-tlen)
BEGIN
e=z+strlen(TokNam);
SFound=(CaseSensitive) ? (strncmp(Line+z,TokNam,tlen)==0)
: (strncasecmp(Line+z,TokNam,tlen)==0);
if ( (SFound)
AND ((z==0) OR (NOT CompressLine_NErl(Line[z-1])))
AND ((e>=strlen(Line)) OR (NOT CompressLine_NErl(Line[e]))) )
BEGIN
strcpy(Line+z+1,Line+e); Line[z]=Num;
llen=strlen(Line);
END;
z++;
END
END
void ExpandLine(char *TokNam, Byte Num, char *Line)
BEGIN
char *z;
do
BEGIN
z=strchr(Line,Num);
if (z!=Nil)
BEGIN
strcpy(z,z+1);
strmaxins(Line,TokNam,z-Line,255);
END
END
while (z!=0);
END
void KillCtrl(char *Line)
BEGIN
char *z;
if (*(z=Line)=='\0') return;
do
BEGIN
if (*z=='\0');
else if (*z==Char_HT)
BEGIN
strcpy(z,z+1);
strprep(z,Blanks(8-((z-Line)%8)));
END
else if ((*z&0xe0)==0) *z=' ';
z++;
END
while (*z!='\0');
END
/****************************************************************************/
/* Buchhaltung */
void BookKeeping(void)
BEGIN
if (MakeUseList)
if (AddChunk(SegChunks+ActPC,ProgCounter(),CodeLen,ActPC==SegCode)) WrError(90);
if (DebugMode!=DebugNone)
BEGIN
AddSectionUsage(ProgCounter(),CodeLen);
AddLineInfo(InMacroFlag,CurrLine,CurrFileName,ActPC,PCs[ActPC],CodeLen);
END
END
/****************************************************************************/
/* Differenz zwischen zwei Zeiten mit Jahresueberlauf berechnen */
long DTime(long t1, long t2)
BEGIN
LongInt d;
d=t2-t1; if (d<0) d+=(24*360000);
return (d>0) ? d : -d;
END
/*--------------------------------------------------------------------------*/
/* Zeit holen */
#ifdef __MSDOS__
#include <dos.h>
long GTime(void)
BEGIN
static unsigned long *tick=MK_FP(0x40,0x6c);
double tmp=*tick;
return ((long) (tmp*5.4931641));
END
#elif __IBMC__
#include <time.h>
#define INCL_DOSDATETIME
#include <os2.h>
long GTime(void)
BEGINM
DATETIME dt;
struct tm ts;
DosGetDateTime(&dt);
memset(&ts,0,sizeof(ts));
ts.tm_year = dt.year-1900;
ts.tm_mon = dt.month-1;
ts.tm_mday = dt.day;
ts.tm_hour = dt.hours;
ts.tm_min = dt.minutes;
ts.tm_sec = dt.seconds;
return (mktime(&ts)*100)+(dt.hundredths);
END
#else
#include <sys/time.h>
long GTime(void)
BEGIN
struct timeval tv;
gettimeofday(&tv,Nil);
return (tv.tv_sec*100)+(tv.tv_usec/10000);
END
#endif
/**
{****************************************************************************}
{ Heapfehler abfedern }
FUNCTION MyHeapError(Size:Word):Integer;
Far;
BEGIN
IF Size<>0 THEN WrError(10006);
MyHeapError:=1;
END;
**/
/*-------------------------------------------------------------------------*/
/* Stackfehler abfangen - bis auf DOS nur Dummies */
#ifdef __TURBOC__
#ifdef __DPMI16__
#else
unsigned _stklen=STKSIZE;
unsigned _ovrbuffer=64*48;
#endif
#include <malloc.h>
#endif
void ChkStack(void)
BEGIN
#ifdef __TURBOC__
LongWord avail=stackavail();
if (avail<MinStack) WrError(10007);
if (avail<LowStack) LowStack=avail;
#endif
END
void ResetStack(void)
BEGIN
#ifdef __TURBOC__
LowStack=stackavail();
#endif
END
LongWord StackRes(void)
BEGIN
#ifdef __TURBOC__
return LowStack-MinStack;
#else
return 0;
#endif
END
#ifdef CKMALLOC
#undef malloc
#undef realloc
void *ckmalloc(size_t s)
BEGIN
void *tmp=malloc(s);
if (tmp==NULL) WrError(10006);
return tmp;
END
void *ckrealloc(void *p, size_t s)
BEGIN
void *tmp=realloc(p,s);
if (tmp==NULL) WrError(10006);
return tmp;
END
#endif
void asmsub_init(void)
BEGIN
char *CMess=InfoMessCopyright;
Word z;
LongWord XORVal;
#ifdef __TURBOC__
#ifdef __MSDOS__
#ifdef __DPMI16__
char *MemFlag,*p;
String MemVal,TempName;
unsigned long FileLen;
#else
char *envval;
int ovrerg;
#endif
#endif
#endif
for (z=0; z<strlen(CMess); z++)
BEGIN
XORVal=CMess[z];
XORVal=XORVal << (((z+1) % 4)*8);
Magic=Magic ^ XORVal;
END
InitStringList(&CopyrightList);
InitStringList(&OutList);
InitStringList(&ShareOutList);
#ifdef __TURBOC__
#ifdef __MSDOS__
#ifdef __DPMI16__
/* Fuer DPMI evtl. Swapfile anlegen */
MemFlag=getenv("ASXSWAP");
if (MemFlag!=Nil)
BEGIN
strmaxcpy(MemVal,MemFlag,255);
p=strchr(MemVal,',');
if (p==Nil) strcpy(TempName,"ASX.TMP");
else
BEGIN
*p=Nil; strcpy(TempName,MemVal);
strcpy(MemVal,p+1);
END;
KillBlanks(TempName); KillBlanks(MemVal);
FileLen=strtol(MemFlag,&p,0);
if (*p!='\0')
BEGIN
fputs(getmessage(Num_ErrMsgInvSwapSize),stderr); exit(4);
END;
if (MEMinitSwapFile(TempName,FileLen << 20)!=RTM_OK)
BEGIN
fputs(getmessage(Num_ErrMsgSwapTooBig),stderr); exit(4);
END
END
#else
/* Bei DOS Auslagerung Overlays in XMS/EMS versuchen */
envval=getenv("USEXMS");
if ((envval!=Nil) AND (toupper(*envval)=='N')) ovrerg=-1;
else ovrerg=_OvrInitExt(0,0);
if (ovrerg!=0)
BEGIN
envval=getenv("USEEMS");
if ((envval==Nil) OR (toupper(*envval)!='N')) _OvrInitEms(0,0,0);
END
#endif
#endif
#endif
#ifdef __TURBOC__
StartStack=stackavail(); LowStack=stackavail();
MinStack=StartStack-STKSIZE+0x800;
#else
StartStack=LowStack=MinStack=0;
#endif
END
Reference in New Issue View Git Blame Copy Permalink