BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /programs/develop/cmm/tokc.cpp @ 6445

  → /programs/develop/cmm/tokc.cpp @ 6446

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Regard whitespace Rev 6445 → Rev 6446

/programs/develop/cmm/tokc.cpp
0,0 → 1,10266
#define _TOKC_
#include <fcntl.h> /* O_ constant definitions */
#include "tok.h"
void GetFileTime(int fd,struct ftime *buf);
#define MAXIF 32
//idrec *crec=NULL;
char invaliddecrem[]="invalid token to be decremented";
char mesLOOPNZ[]="LOOPNZ";
char mesIF[]="IF";
char mesELSE[]="ELSE";
char mesWHILE[]="WHILE";
char mesFOR[]="FOR";
char mesRETURN[]="RETURN";
int tok,tok2; /* token holders current, next */
unsigned char string[STRLEN],string2[STRLEN+20],
string3[STRLEN]; //ñîäåðæèò íå ïðåîáðàçîâàííóþ ñòðîêó
unsigned int posts=0; /* number of post entrys */
postinfo *postbuf;
unsigned int maxposts=MAXPOSTS;
unsigned int secondcallnum=1; /* # of different second calls and labels */
unsigned int externnum=0;
unsigned long postsize=0; /* total size of all post vars */
unsigned int poststrptr=0; /* post string index in output */
unsigned int outptrsize=MAXDATA; //ðàçìåð âûõîäíîãî áóôåðà äëÿ êîäà
unsigned int outdatasize=MAXDATA; //ðàçìåð âûõîäíîãî áóôåðà äëÿ äàííûõ
long runfilesize;
int error=0; /* current error number holder */
unsigned char dos1=0,dos2=0; /* DOS version required for program execution */
unsigned char cpu=0; /* CPU required, 2 for 80286, 3 for 80386, ... */
unsigned int paramsize=0; /* byte size of all procedure parameters */
unsigned int localsize=0; /* byte size of all procedure local variables */
unsigned int procedure_start=0; /* address of start of procedure */
unsigned int current_proc_type; /* current procedure type */
int returntype; /* return type, (void, byte, word, ...) */
unsigned char warning;
/*+++++++++++++++++++++++ Óñòàíîâêè ïî óìîë÷àíèþ +++++++++++++++++++++++*/
unsigned char am32 = FALSE; // ðåæèì 32 áèòíîé àäðåñàöèè
unsigned char comfile = file_com; // output file format
unsigned char optimizespeed = 1; // optimize for size or speed flag
unsigned char alignword = 1; // flag whether or not to align words
unsigned char aligner = 0; // value used to align words
unsigned char header = 1; // output SPHINX C-- Ver1 Ver2 header
unsigned char chip = 0; // CPU optimization (286,386,486,...)
unsigned char killctrlc = 0; // add disable CTRL-C code in header
unsigned int stacksize = 2048; // stack size (2048 default)
unsigned char splitdata=FALSE; //îòäåëèòü äàííûå îò êîäà
unsigned char AlignCycle=FALSE; //âûðàâíèâàòü íà÷àëà öèêëîâ
/*+++++++++++++++++++ end of flexable compiler options ++++++++++++++++++++*/
unsigned char notdoneprestuff = TRUE; // flag if initial stuff has been entered
unsigned int datasize=0,alignersize=0; /* size of data and other */
unsigned int outptr=0x100,outptrdata=0x100; /* ptr to output */
unsigned char *output;
unsigned char *outputdata=NULL;
unsigned int linenumber=0;
unsigned char dynamic_flag=0; //ôëàã îáðàáîòêè äèíàìè÷åñêèõ ýëåìåíòîâ
unsigned char *input; /* dynamic input buffer */
unsigned int endinptr; /* end index of input array */
unsigned int inptr; /* index in input buffer */
unsigned char cha; /* pipe byte for token production */
char endoffile; /* end of input file flag */
unsigned char insertmode=FALSE;
unsigned int numblocks=0; //íîìåð âëîæåííîãî áëîêà
treelocalrec *tlr=NULL; //öåïî÷êà ëîêàëüíûõ áëîêîâ
treelocalrec *btlr=NULL; //öåïî÷êà èñïîëüçîâàíûõ ëîêàëüíûõ áëîêîâ
RETLIST *listreturn=NULL;
unsigned int numreturn=0;
idrec *staticlist;
unsigned char stat_reg[8]; //òàáëèöà çàíÿòîñòè ðåãèñòðîâ
int sizestack=0; //ðàçìåð íå êîìïåíñèðîâàííûõ ïàðàìåòðîâ ôóíêöèé
unsigned char addstack=TRUE;
extern char shorterr[];
extern unsigned long long li[];
/*-----------------01.05.98 19:22-------------------
äîïîëíèòåëüíûå ïåðåìåííûå äëÿ ðåàëèçàöèè BREAK CONTINUE
--------------------------------------------------*/
#define MAXIN 100 //ìàêñèìàëüíàÿ âëîæåíîñòü öèêëîâ
unsigned int numbr=0; //ñ÷åò÷èê îáùåãî ÷èñëà öèêëîâ LOOP DO-WHILE...
unsigned int listbr[MAXIN]; //òàáëèöà íîìåðîâ öèêëîâ
unsigned int usebr[MAXIN]; //èñïîëüçîâàíî break
unsigned int useco[MAXIN]; //èñïîëüçîâàíî continue
unsigned int curbr=0,curco=0; //òåêóùàÿâëîæåíîñòü öèêëîâ
unsigned int startStartup=0x100;
unsigned int endStartup=0;
unsigned char useStartup=FALSE;
unsigned char notpost=FALSE;
int retproc;
int lastcommand; //ïîñëåäíèé îïåðàòîð â áëîêå
unsigned char FastCallApi=TRUE; //ðàçðåøèòü áûñòðûé âûçîâ API ïðîöåäóð
unsigned char FixUp=FALSE; //Äåëàòü ëè òàáëèöó ïåðåìåùåíèé
unsigned char AlignProc=FALSE;
//------- ðàáîòà ñ union ---------------------------------------------
char param[256]; //áóôåð äëÿ ïàðàìåòðîâ ïðîöåäóðû
char *BackTextBlock; //áóôåð äëÿ ïåðåíåñåííîãî òåêñòà
int SizeBackBuf=0,MaxSizeBackBuf;
struct FILEINFO *startfileinfo=NULL;
unsigned int totalmodule=0;
unsigned int currentfileinfo;
unsigned char setzeroflag; //îïåðàöèÿ ìåíÿåò zero flag
unsigned char notunreach=FALSE;
unsigned int initBP=0;
int inlineflag=0; // flag for disabling entry and exit codes production
unsigned char fstatic=FALSE;
unsigned long addESP=0; //äîáàâêà ñòåêà
unsigned char blockproc=FALSE; //èäåòðàçáîðêà áëîêà ôóíêöèè
unsigned int updatelocalvar(char *str,int tok,unsigned int num);
void setuprm();
void doloop(unsigned int typeb); /* both short and long loops */
void doBREAK(unsigned char typeb);
void doCONTINUE(unsigned char typeb);
void dowhile(unsigned int typeb);
void MakeContinue(unsigned char typeb);
void dofor(unsigned int typeb);
void dodo();
void globalvar(); /* both initialized and unitialized combined */
void doswitch();
void CalcRegPar(int reg,int def,char *&ofsstr);
void JXorJMP();
int loadinputfile(char *inpfile);
int SaveStartUp(int size,char *var_name);
void LoadData(unsigned int size,int filehandle);
void SetNewTok(int type,int typev);
void doreturn(int type=tokens); /* do return(...); */
void notnegit(int notneg);
void insertcode(); // force code procedure at specified location
void interruptproc();
void dobigif();
void doif(void);
void doasmblock();
void declareextern();
unsigned long dounion(int,int);
void RunBackText();
int FindDublString(int segm,unsigned int len,int term);
void *liststring=NULL; //öåïî÷êà èíôîðìàöèîííûõ áëîêîâ î ñòðîêàõ
void GetNameLabel(int type,int num);
void CheckPosts();
SAVEPAR *SRparam(int save,SAVEPAR *par); //save or restore global param compiler
void AddRetList(int pos,int line,int type);
void CheckRealizable();
void declare_procedure(int oflag,int orm,int npointr);
void labelindata();
void AddRegistr(int razr,int reg);
void ClearRegister();
int GetRegister(int mode=0);
void RegAddNum(int reg);
void dowhilefast(unsigned int typeb);
int getrazr(int type);
void RestoreSaveReg();
void killlocals(/*int endp=TRUE*/);
void leaveproc();
int IsSaveReg();
void CorrectParamVar();
extern void ManyLogicCompare();
extern void maxdataerror();
extern void CompareOr();
extern void dynamiclabelerror();
extern void retvoid();
extern int numberbreak;
SAVEREG savereg;
SAVEREG *psavereg=&savereg;
int loadfile(char *filename,int firstflag)
{
int hold;
for(int i=0;i<=numfindpath;i++){
sprintf((char *)string2,"%s%s",findpath[(firstflag==0?i:numfindpath-i)],filename);
if((hold=loadinputfile((char *)string2))!=-2)break;
if(firstflag==2||(firstflag==0&&(i+1)==numfindpath))break;
}
if(hold==-2){
unableopenfile(filename); //ñîîáùåíèå î îøèáêå
exit(e_cannotopeninput); //çàâåðøèòü ðàáîòó åñëè íå ñìîãëè çàãðóçèòü ôàéë
}
return hold;
}
void compilefile(char *filename,int firstflag)
{
int hold;
hold=loadfile(filename,firstflag);
if(hold==1||hold==-1)return;
if(strcmp(filename,"startup.h--")==0)startupfile=currentfileinfo;
inptr=0;
endoffile=0;
startline=(char*)input;
endinput=startline+endinptr;
warning=gwarning;
nextchar();
cha2=cha; //ñèìâîë èç áóôåðà
inptr2=inptr; //çàïîìí óêàçàòåëü íà ñëåä ñèìâîë
linenum2=1; //íîìåð ñòðîêè
{ //ïðîâåðêà íà ôàéë ðåñóðñîâ è åãî îáðàáîòêà
char *a;
if((a=strrchr(filename,'.'))!=NULL){
if(stricmp(a,".rc")==0){
input_res();
free(input);
return;
}
}
}
nexttok(); //îïð òèï ïåðâîãî è âòîðîãî òîêåíà
while(tok!=tk_eof){ //öèêë ïîêà íå êîí÷èòñÿ ôàéë
while(tok==tk_question){
directive();//îáðàáîòêà äèðåêòèâ
if(tok==tk_semicolon)nexttok();
}
usedirectiv=FALSE;
if(notdoneprestuff==TRUE)doprestuff();//startup
switch(tok){
case tk_ID:
case tk_id:
if(FindTeg(TRUE)!=NULL){
InitStruct();
break;
}
if(tok2==tk_colon){
labelindata();
break;
}
case tk_far:
case tk_cdecl:
case tk_pascal:
case tk_stdcall:
case tk_fastcall:
case tk_declare:
case tk_undefproc:
case tk_float:
case tk_long:
case tk_dword:
case tk_word:
case tk_byte:
case tk_char:
case tk_int:
case tk_void:
case tk_export:
case tk_qword:
case tk_double:
case tk_fpust:
if((hold=testInitVar())==FALSE)define_procedure();
else if(hold==TRUE)globalvar();
break;
case tk_struct: InitStruct(); break;
case tk_interrupt: interruptproc(); break;
case tk_at: insertcode(); break; //âñòàâêà ðåãèñòðîâîé ïðîöåäóðû
case tk_colon:
nexttok();
dynamic_flag=2;
break;// îïð äèíàìè÷åñêîé ïðîöåäóðû
case tk_inline:
if(testInitVar()){
preerror("Bad header dynamic function");
nexttok();
}
dynamic_proc();
break;
case tk_static:
fstatic=2;
nexttok();
break;
case tk_enum: doenum(); break;
case tk_from: nexttok(); dofrom(); nextseminext(); break;
case tk_extract: nexttok(); doextract(); seminext(); break;
case tk_loop:
case tk_while:
case tk_do:
case tk_else:
case tk_ELSE:
case tk_if:
case tk_IF:
case tk_interruptproc:
case tk_proc:
case tk_charvar:
case tk_intvar:
case tk_bytevar:
case tk_longvar:
case tk_dwordvar:
case tk_floatvar:
case tk_qwordvar:
case tk_doublevar:
case tk_wordvar: idalreadydefined(); break;
case tk_reg32:
case tk_debugreg:
case tk_controlreg:
case tk_testreg:
case tk_reg:
case tk_seg:
case tk_beg:
case tk_reg64:
preerror("register name cannot be used as an identifier");
nexttok();
case tk_eof: break;
case tk_locallabel: internalerror("local label token found outside function block."); break;
case tk_extern: declareextern(); break;
case tk_union: dynamic_flag=0; dounion(TRUE,fstatic==0?0:f_static); break;
case tk_semicolon: nexttok(); break;
case tk_asm:
if(tok2==tk_openbrace)doasmblock();
else doasm();
break;
case tk_idasm: doasm(TRUE); break;
case tk_dollar: doasm(FALSE); break;
default: unuseableinput();
/* while(itok.type==tp_stopper&&tok!=tk_eof)*/nexttok();
break;
}
if(fstatic)fstatic--;
else if(dynamic_flag)dynamic_flag--;
}
(startfileinfo+currentfileinfo)->stlist=staticlist;
free(input);
}
/* ------------------- output procedures start ------------------- */
int CheckCodeSize()
//ïðîâåðêà ðàçìåðà áóôåðà äëÿ êîäà
{
if(!am32){
maxoutputerror();
return FALSE;
}
outptrsize+=MAXDATA;
output=(unsigned char *)REALLOC(output,outptrsize);
if(splitdata==FALSE)outputdata=output;
return TRUE;
}
int CheckDataSize()
//ïðîâåðêà ðàçìåðà áóôåðà äëÿ êîäà
{
if(!am32){
maxoutputerror();
return FALSE;
}
outdatasize+=MAXDATA;
outputdata=(unsigned char *)REALLOC(outputdata,outdatasize);
return TRUE;
}
void op(int byte)
{
if(outptr>=outptrsize&&CheckCodeSize()==FALSE)return;
output[outptr++]=(unsigned char)byte;
if(splitdata==FALSE)outptrdata=outptr;
retproc=FALSE;
}
void opd(int byte)
{
if(splitdata==FALSE){
if(outptr>=outptrsize&&CheckCodeSize()==FALSE)return;
output[outptr++]=(unsigned char)byte;
outptrdata=outptr;
}
else{
if(outptrdata>=outdatasize&&CheckDataSize()==FALSE)return;
outputdata[outptrdata++]=(unsigned char)byte;
}
}
void CorrectOfsBit(int bitofs)
{
bitofs=(bitofs+7)/8;
if(splitdata)outptrdata+=bitofs;
else{
outptr+=bitofs;
outptrdata=outptr;
}
}
long GetBitMask(int ofs,int size)
{
return (~((li[size]-1)<<ofs));
}
void opb(unsigned long num,unsigned int ofs,unsigned int size)
{
int s;
//ïðîâåðèòü âûõîä çà ãðàíèöû áëîêà ïàìÿòè
s=(ofs+size+7)/8;
if(splitdata==FALSE){
if((outptr+s+8)>=outptrsize&&CheckCodeSize()==FALSE)return;
}
else{
if((outptrdata+s+8)>=outdatasize&&CheckDataSize()==FALSE)return;
}
if(size!=32)num=num&(li[size]-1);
s=outptrdata+ofs/8;
ofs=ofs%8;
*(long *)&outputdata[s]&=GetBitMask(ofs,size);
*(long *)&outputdata[s]|=(num<<ofs);
// printf("ofs=%Xh mask=%X value=%X\n",s,GetBitMask(ofs,size),(num<<ofs));
if((ofs+size)>32){
*(long *)&outputdata[s+4]&=GetBitMask(0,ofs+size-32);
*(long *)&outputdata[s+4]|=(num>>(64-ofs-size));
// printf("continue ofs=%Xh mask=%X value=%X\n",s+4,GetBitMask(0,ofs+size-32),num>>(64-ofs-size));
}
}
void outword(unsigned int num)
{
op(num);
op(num/256);
}
void outwordd(unsigned int num)
{
opd(num);
opd(num/256);
}
void outdword(unsigned long num)
{
outword((unsigned int)(num&0xFFFFL));
outword((unsigned int)(num/0x10000L));
}
void outdwordd(unsigned long num)
{
outwordd((unsigned int)(num&0xFFFFL));
outwordd((unsigned int)(num/0x10000L));
}
void outqword(unsigned long long num)
{
outdword((unsigned long)(num&0xFFFFFFFFL));
outdword((unsigned long)(num/0x100000000LL));
}
void outqwordd(unsigned long long num)
{
outdwordd((unsigned long)(num&0xFFFFFFFFL));
outdwordd((unsigned long)(num/0x100000000LL));
}
void doasmblock()
{
nexttok();
useasm=TRUE;
expecting(tk_openbrace);
for(;;){
if(tok==tk_closebrace)break;
if(tok==tk_eof){
unexpectedeof();
break;
}
lastcommand=tok;
if(dbg)AddLine();
doasm(TRUE);
}
useasm=FALSE;
nexttok();
}
void doblock()
{
expecting(tk_openbrace);
doblock2();
/* for(;;){
if(tok==tk_closebrace)break;
if(tok==tk_eof){
unexpectedeof();
break;
}
docommand();
}
RestoreStack();*/
}
void doblock2()
{
for(;;){
if(tok==tk_closebrace)break;
if(tok==tk_eof){
unexpectedeof();
break;
}
docommand();
}
if(numblocks==1&&addstack&&sizestack&&localsize&&am32&&ESPloc&&IsSaveReg()==FALSE){
localsize+=sizestack;
sizestack=0;
}
else RestoreStack();
}
void gotodo()
{
nexttok();
if(gotol(0))nexttok();
seminext();
}
void GOTOdo()
{
nexttok();
if(GOTO())nexttok();
seminext();
}
void docommand() /* do a single command */
{
unsigned int useflag;
useflag=0;
if(dbg)AddLine();
//loops:
lastcommand=tok;
// printf("tok=%d %s\n",tok,itok.name);
switch(tok){
case tk_ID: useflag++;
case tk_id:
if((useflag=doid((char)useflag,tk_void))!=tokens){
nextseminext();
if(useflag==tk_fpust)preerror("function returned parametr in FPU stack");
}
else if(tok!=tk_closebrace)docommand();
break;
case tk_apiproc:
case tk_undefproc:
case tk_declare:
if(doanyundefproc()!=tokens)nextseminext();
else if(tok!=tk_closebrace)docommand();
break;
case tk_proc:
doanyproc();
nextseminext();
break;
case tk_interruptproc:
outword(0x0E9C); //pushf //push cs
useflag=itok.post;
callloc(itok.number);
nexttok();
expecting(tk_openbracket);
expecting(tk_closebracket);
#ifdef OPTVARCONST
FreeGlobalConst();
#endif
seminext();
clearregstat(useflag);
break;
case tk_bits:
dobits();
break;
case tk_charvar: useflag=1;
case tk_bytevar:
dobytevar(useflag);
break;
case tk_intvar: useflag=1;
case tk_wordvar:
do_d_wordvar(useflag,r16);
break;
case tk_longvar: useflag=1;
case tk_dwordvar:
do_d_wordvar(useflag,r32);
break;
case tk_doublevar:
useflag=4;
case tk_floatvar:
dofloatvar(useflag,tk_floatvar,tk_semicolon);
break;
case tk_qwordvar:
doqwordvar();
break;
case tk_fpust:
dofloatstack(itok.number);
break;
case tk_structvar:
dostruct();
break;
case tk_pointer:
dopointer();
break;
case tk_mult:
dovalpointer();
break;
case tk_RETURN:
case tk_return:
RestoreStack();
#ifdef OPTVARCONST
ClearLVIC();
#endif
doreturn(tok);
CheckRealizable();
break;
case tk_at:
nexttok();
if(tok2==tk_colon){
LLabel();
if(tok!=tk_closebrace)docommand();
}
else if(macros(tk_void)!=0)nextseminext();
break;
case tk_if: RestoreStack(); doif(); break;
case tk_IF: RestoreStack(); dobigif(); break;
case tk_loopnz:
case tk_LOOPNZ:
case tk_loop: RestoreStack(); doloop(tok); break;
case tk_while:
case tk_WHILE: RestoreStack(); dowhilefast(tok); break;
case tk_do: RestoreStack(); dodo(); break;
case tk_for:
case tk_FOR: RestoreStack(); dofor(tok); break;
case tk_reg32: doreg_32((unsigned int)itok.number,r32); break;
case tk_reg: doreg_32((unsigned int)itok.number,r16); break;
case tk_beg: dobeg((unsigned int)itok.number); break;
case tk_reg64: doreg64(itok.number); break;
case tk_seg: doseg((unsigned int)itok.number); break;
case tk_openbrace:
startblock();
doblock();
nexttok();
endblock();
break;
case tk_from: nexttok(); dofrom(); nextseminext(); break;
case tk_extract: nexttok(); doextract(); seminext(); break;
case tk_minus: useflag=8;
case tk_not:
notnegit(useflag);
nextseminext();
break;
case tk_locallabel: RestoreStack(); define_locallabel(); break;
case tk_camma:
case tk_semicolon: nexttok(); break;
case tk_else:
preerror("else without preceeding if or IF");
nexttok();
break;
case tk_ELSE:
preerror("ELSE without preceeding IF or if");
nexttok();
break;
case tk_eof: unexpectedeof(); break;
case tk_void:
case tk_long:
case tk_dword:
case tk_word:
case tk_byte:
case tk_int:
case tk_char:
preerror("cannot declare variables within function { } block");
nexttok();
break;
case tk_GOTO:
RestoreStack();
GOTOdo();
CheckRealizable();
break;
case tk_goto:
RestoreStack();
gotodo();
CheckRealizable();
break;
case tk_BREAK:
RestoreStack();
doBREAK(BREAK_SHORT);
CheckRealizable();
break;
case tk_break:
RestoreStack();
doBREAK((unsigned char)(am32==FALSE?BREAK_NEAR:BREAK_32));
CheckRealizable();
break;
case tk_CONTINUE:
RestoreStack();
doCONTINUE(CONTINUE_SHORT);
CheckRealizable();
break;
case tk_continue:
RestoreStack();
doCONTINUE((unsigned char)(am32==FALSE?CONTINUE_NEAR:CONTINUE_32));
CheckRealizable();
break;
case tk_asm:
if(tok2==tk_openbrace)doasmblock();
else doasm();
break;
case tk_idasm:
useflag=TRUE;
case tk_dollar:
doasm(useflag);
break;
case tk_SWITCH:
case tk_switch: RestoreStack(); doswitch(); break;
case tk_delete: dodelete(); break;
case tk_new: donew(); seminext(); break;
case tk_question:
// calcnumber=FALSE;
while(tok==tk_question)directive();
break;
/* case tk_openbracket:
nexttok();
nexttok();
expectingoperand(tk_closebracket);
goto loops;*/
default: unuseableinput(); break;
}
notunreach=FALSE;
}
void doBREAK(unsigned char typeb)
{
if(curbr==0)preerror("'BREAK' or 'break' use only in loop, do-while..");
else MakeBreak(typeb);
nextseminext();
}
void doCONTINUE(unsigned char typeb)
{
if(curco==0)preerror("'CONTINUE' or 'continue' use only in loop, do-while..");
else MakeContinue(typeb);
nextseminext();
}
void MakeBreak(unsigned char typeb)
{
unsigned int nbr=0;
if(tok2==tk_number){
nexttok();
nbr=itok.number;
if(nbr>=curbr)preerror("'BREAK' or 'break' on incorrect number skip cycle");
}
numberbreak=nbr;
nbr=curbr-1-nbr;
if(usebr[nbr]==0){
GetNameLabel(tk_break,nbr);
addlocalvar((char *)string2,tk_locallabel,secondcallnum,TRUE);
usebr[nbr]=secondcallnum;
secondcallnum++;
}
addacall(usebr[nbr],typeb);
if(typeb==BREAK_SHORT)outword(0x00EB); // JMP SHORT
else jumploc0();
}
void MakeContinue(unsigned char typeb)
{
unsigned int nbr=0;
if(tok2==tk_number){
nexttok();
nbr=itok.number;
if(nbr>=curco)preerror("'CONTINUE' or 'continue' on incorrect number skip cycle");
}
nbr=curco-1-nbr;
if(useco[nbr]==0){
GetNameLabel(tk_continue,nbr);
// printf("%s nbr=%d\n",(char *)string2,nbr);
addlocalvar((char *)string2,tk_locallabel,secondcallnum,TRUE);
useco[nbr]=secondcallnum;
secondcallnum++;
}
addacall(useco[nbr],typeb);
if(typeb==CONTINUE_SHORT)outword(0x00EB); // JMP SHORT
else jumploc0();
}
int CheckExitProc()
{
if(strcmp(itok.name,"EXIT")==0||strcmp(itok.name,"ABORT")==0)return TRUE;
return FALSE;
}
void LLabel()
{
localrec *ptr;
#ifdef OPTVARCONST
ClearLVIC();
#endif
RestoreStack();
clearregstat();
switch(tok){
case tk_id:
case tk_ID:
FindOff((unsigned char *)itok.name,CS);
ptr=addlocalvar(itok.name,tk_number,outptr,TRUE);
if(FixUp)ptr->rec.flag=f_reloc;
break;
case tk_undefproc:
ptr=addlocalvar(itok.name,tk_number,outptr,TRUE);//äîáàâèòü â ëîêàëüíûé ñïèñîê
if(FixUp)ptr->rec.flag=f_reloc;
updatecall((unsigned int)itok.number,outptr,procedure_start);//îáðàáîòàòü ðàííèå îáðàùåíèÿ
break;
default:
preerror("error declaretion local label");
break;
}
nexttok();
nexttok();
}
void AddApiToPost(unsigned int num)
{
CheckPosts();
(postbuf+posts)->type=CALL_32I;
(postbuf+posts)->loc=outptr;
(postbuf+posts)->num=num;
posts++;
outdword(0);
}
/* ---------------------- Procedure Calling Starts -------------------- */
int doanyundefproc(int jumpsend)
{
unsigned int cnum,snum;
int returnvalue;
int regs;
char fname[IDLENGTH];
if(tok2==tk_colon){ // if a label
#ifdef OPTVARCONST
ClearLVIC();
#endif
RestoreStack();
clearregstat();
if(CidOrID()==tk_ID){//local label that has been used, but not placed
localrec *ptr=addlocalvar(itok.name,tk_number,outptr,TRUE);
if(FixUp)ptr->rec.flag=f_reloc;
updatecall((unsigned int)itok.number,outptr,procedure_start);//îáðàáîòàòü ðàííèå îáðàùåíèÿ
}
else{ //ãëîáàëüíàÿ ìåòêà
tok=tk_proc;
itok.number=outptr;
string[0]=0;
updatecall((unsigned int)updatetree(),(unsigned int)itok.number,0);
}
nexttok(); // move past id
nexttok(); // move past :
return(tokens);
}
if(tok2==tk_openbracket){
strcpy(fname,itok.name);
if(tok==tk_declare){ //ñìåíèòü ñòàòóñ ïðîöåäóðû ñ îáúÿâëåíîé íà íåèçâåñòíóþ
tok=tk_undefproc;
updatetree();
if(itok.flag&f_classproc)AddUndefClassProc();
}
cnum=(unsigned int)itok.number;
regs=itok.post;
returnvalue=itok.rm;
unsigned int tproc=itok.flag;
unsigned char apiproc=FALSE;
unsigned int oaddESP=addESP;
int sizestack=-1;
if(tok==tk_apiproc){
apiproc=TRUE;
sizestack=itok.size; //ðàçìåð ñòåêà ïîä ïàðàìåòðû
}
#ifdef OPTVARCONST
if(tproc&f_useidx)ClearLVIC();
else FreeGlobalConst();
#endif
int exitproc=CheckExitProc();
snum=initparamproc();
if(sizestack!=-1){
if(snum>(unsigned int)sizestack)extraparam(fname);
else if(snum<(unsigned int)sizestack)missingpar(fname);
}
if((tproc&f_typeproc)!=tp_cdecl){
snum=0;
addESP=oaddESP;
}
if(FastCallApi==TRUE&&apiproc!=FALSE){
if(jumpsend)outword(0x25ff);
else outword(0x15FF);
AddApiToPost(cnum);
}
else{
addacall(cnum,(unsigned char)((tproc&f_extern)!=0?CALL_EXT:(am32!=FALSE?CALL_32:CALL_NEAR)));
if(jumpsend)jumploc0();
else callloc0(); /* produce CALL [#] */
}
clearregstat(regs);
if(snum!=0&&jumpsend==FALSE)CorrectStack(snum);
retproc=exitproc;
return(returnvalue);
}
thisundefined(itok.name);
nexttok();
return(tk_long);
}
void CorrectStack(unsigned int num)
{
if(addstack){
sizestack+=num;
// printf("%s(%d)> Add %d bytes stacks.\n",startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,linenumber,num);
}
else{
if(short_ok(num)){
outword(0xC483);
op(num);
}
else{
outword(0xC481);
if(am32==FALSE)outword(num);
else outdword(num);
}
addESP-=num;
}
}
unsigned int initparamproc()
{
unsigned int typep=itok.flag,snum=0;
ITOK ostructadr=structadr;
strcpy(param,(char *)string);
nexttok();
switch(typep&f_typeproc){
case tp_cdecl:
case tp_stdcall:
snum=swapparam();
break;
case tp_pascal:
doparams();
break;
case tp_fastcall:
doregparams();
break;
}
// if(crec)printf("after doparams num=%08X\n",crec->recnumber);
if((typep&f_classproc)&&(!(typep&f_static))){
if((current_proc_type&f_static)&&structadr.sib==THIS_PARAM )return snum;
structadr=ostructadr;
if(structadr.sib==THIS_PARAM){
if(structadr.number==0){
op(0xff);
if(ESPloc&&am32){
int num;
num=localsize+addESP+4;
if(short_ok(num,TRUE)){
outword(0x2474);
op(num);
}
else{
outword(0x24B4);
outdword(num);
}
}
else outword(am32==FALSE?0x0476:0x0875);//push[ebp+4]
}
else{
int reg=GetRegister(1);
op(0x8B);
if(ESPloc&&am32){
int num;
num=localsize+addESP+4;
if(short_ok(num,TRUE)){
op(4+reg*8+64);
op(0x24);
op(num);
}
else{
op(4+reg*8+128);
op(0x24);
outdword(num);
}
}
else{
op((am32==FALSE?6:5)+reg*8+64);
op((am32==FALSE?4:8));//mov ESI,[ebp+4]
}
RegAddNum(reg);
op(0x50+reg); //push reg
warningreg(regs[am32][reg]);
}
}
else if(structadr.sib==THIS_REG){
if(structadr.number/*size*/!=0){
int reg=GetRegister(1);
if(reg==structadr.rm)RegAddNum(reg);
else{
if(am32==FALSE){
switch(structadr.rm){
case BX:
structadr.rm=7;
break;
case DI:
structadr.rm=5;
break;
case SI:
structadr.rm=4;
break;
case BP:
structadr.rm=6;
break;
default:
regBXDISIBPexpected();
}
structadr.sib=CODE16;
}
else structadr.sib=CODE32;
structadr.rm|=(structadr.number<128?rm_mod01:rm_mod10);
op(0x8d); //lea reg [reg2+num]
op(structadr.rm+reg*8);
outaddress(&structadr);
}
op(0x50+reg);
warningreg(regs[am32][reg]);
}
else op(0x50+structadr.rm);
}
else if(structadr.sib==THIS_NEW){
RunNew(structadr.number);
op(0x50);
}
else if(structadr.sib==THIS_ZEROSIZE){
outword(0x6a); //push 0
}
else{
// printf("post=%d\n",structadr.post);
if(structadr.post==LOCAL){
int reg=GetRegister(1);
structadr.post=0;
outseg(&structadr,2);
op(0x8d);
op(structadr.rm+reg*8);
outaddress(&structadr);
op(0x50+reg);
warningreg(regs[am32][reg]);
}
else{
if(strinf.bufstr){
int reg=GetRegister(1);
int newreg;
if((newreg=CheckIDXReg(strinf.bufstr,strinf.size,reg))!=NOINREG){
if(newreg!=SKIPREG){
if(am32==FALSE&&newreg!=BX&&newreg!=DI&&newreg!=SI&&newreg!=BP)goto noopt;
waralreadinitreg(regs[am32][reg],regs[am32][newreg]);
reg=newreg;
}
free(strinf.bufstr);
goto cont1;
}
noopt:
if(newreg=CheckMassiv(strinf.bufstr,strinf.size,reg)!=-1)reg=newreg;
cont1:
strinf.bufstr=NULL;
RegAddNum(reg);
op(0x50+reg);
}
else{
op(0x68);
if(structadr.post/*&&structadr.post!=USED_DIN_VAR*/)setwordpost(&structadr);
else if(FixUp)AddReloc();
if(am32==FALSE)outword((unsigned int)structadr.number);
else outdword(structadr.number);
}
}
}
snum+=(am32==FALSE?2:4);
addESP+=(am32==FALSE?2:4);
}
if(typep&f_far)op(0x0e); //push cs
return snum;
}
int doanyproc(int jumpsend)
{
unsigned int cloc,snum;
int returnvalue,dynamicindex;
int regs;
if(tok2==tk_colon){
preerror("dublication global label");
nexttok();
return 0;
}
cloc=(unsigned int)itok.number; /* get address or handle */
returnvalue=itok.rm;
regs=itok.post;
// printf("regs=%08X name=%s\n",regs,itok.name);
int flag=itok.flag;
if(itok.npointr)dopointerproc();
else{
if((itok.flag&f_inline)!=0&&(useinline==TRUE||(useinline==2&&optimizespeed))){
if(macros(tk_void)!=0)return(returnvalue);
}
dynamicindex=itok.segm;
// printf("%s %08X seg=%d\n",rec->recid/*itok.name*/,itok.flag,itok.segm);
if(itok.segm==DYNAMIC){
itok.segm=DYNAMIC_USED;
updatetree();
}
unsigned int oaddESP=addESP;
snum=initparamproc();
if((flag&f_typeproc)!=tp_cdecl){
snum=0;
addESP=oaddESP;
}
if(dynamicindex<NOT_DYNAMIC){ //äèíàìè÷åñêàÿ ïðîöåäóðà
addacall(cloc,(unsigned char)(am32!=FALSE?CALL_32:CALL_NEAR));
if(jumpsend)jumploc0();
else{
callloc0();
if(snum!=0)CorrectStack(snum);
}
}
else{
if(jumpsend)jumploc(cloc);
else{
callloc(cloc);
if(snum!=0)CorrectStack(snum);
}
}
}
#ifdef OPTVARCONST
if(flag&f_useidx)ClearLVIC();
else FreeGlobalConst();
#endif
clearregstat(regs);
return(returnvalue);
}
int doid(char uppercase,int expectedreturn)
{
int cnum;
if(tok2==tk_colon){ // if a label
#ifdef OPTVARCONST
ClearLVIC();
#endif
RestoreStack();
clearregstat();
cnum=FindOff((unsigned char *)itok.name,CS);
if(uppercase){
localrec *ptr=addlocalvar(itok.name,tk_number,outptr,TRUE);
if(FixUp)ptr->rec.flag=f_reloc;
}
else{
tok=tk_proc;
itok.rm=tk_void;
itok.number=outptr;
itok.segm=NOT_DYNAMIC;
itok.flag=0;
string[0]=0;
itok.type=tp_ucnovn;
addtotree(itok.name);
itok.rec->count=cnum;
}
nexttok(); // move past id
nexttok(); // move past :
return(tokens);
}
if(tok2==tk_openbracket){
if((cnum=CheckMacros())!=tokens)return cnum;
tobedefined(am32==FALSE?CALL_NEAR:CALL_32,expectedreturn);
cnum=posts-1;
param[0]=0;
int flag=itok.flag;
int exitproc=CheckExitProc();
unsigned int oaddESP=addESP;
if(itok.flag==tp_stdcall){
nexttok();
swapparam();
}
else{
nexttok();
if(uppercase)doregparams();
else doparams();
}
(postbuf+cnum)->loc=outptr+1;
callloc0(); /* produce CALL [#] */
clearregstat();
addESP=oaddESP;
#ifdef OPTVARCONST
if(flag&f_useidx)ClearLVIC();
else FreeGlobalConst();
#endif
retproc=exitproc;
return(expectedreturn);
}
thisundefined(itok.name);
return(tk_long);
}
int typesize(int vartype) // âîçâðàùàåò ðàçìåð â áàéòàõ êîäà âîçâðàòà
{
switch(vartype){
case tk_char:
case tk_byte: return(1);
case tk_int:
case tk_word: return(2);
case tk_float:
case tk_dword:
case tk_long: return(4);
case tk_double:
case tk_qword: return 8;
}
return(0);
}
void FpuSt2Number()
{
op66(r32); //push EAX
op(0x50);
CheckInitBP();
fistp_stack();
RestoreBP();
fwait3();
op66(r32);
op(0x58); //pop EAX
if(cpu<3)cpu=3;
}
void FpuSt2QNumber()
{
op66(r32); //push EAX
op(0x50);
op66(r32); //push EAX
op(0x50);
CheckInitBP();
fistp_stack(4);
RestoreBP();
fwait3();
op66(r32);
op(0x58+EDX); //pop EAX
op66(r32);
op(0x58); //pop EAX
if(cpu<3)cpu=3;
}
void fwait3_4()
{
if(chip<4)op(0x9B);
}
void convert_returnvalue(int expectedreturn,int actualreturn)
{
if(expectedreturn==tk_void)return; //17.09.05 17:52
if(actualreturn==tk_void/*||expectedreturn==tk_void*/){
retvoid();
return;
}
switch(expectedreturn){
case tk_byte:
case tk_char:
case tk_word:
case tk_int:
if(actualreturn==tk_float||actualreturn==tk_double){
op66(r32);
op(0x50);
FloatToNumer(actualreturn==tk_float?0:4);
}
else if(actualreturn==tk_fpust)FpuSt2Number();
else if(expectedreturn==tk_word||expectedreturn==tk_int){
if(actualreturn==tk_char)cbw();
else if(actualreturn==tk_byte)xorAHAH();
}
break;
case tk_long:
case tk_dword:
switch(actualreturn){
case tk_char:
op66(r32);
op(0x0F); outword(0xC0BE); //MOVSX EAX,AL
break;
case tk_byte: /* MOVZX EAX,AL */
op66(r32);
op(0x0F); outword(0xC0B6);
break;
case tk_word: /* MOVZX EAX,AX */
op66(r32);
op(0x0F); outword(0xC0B7);
break;
case tk_int: /* MOVSX EAX,AX */
op66(r32);
op(0x0F); outword(0xC0BF);
break;
case tk_double:
case tk_fpust:
FpuSt2Number();
break;
// case tk_double:
case tk_float:
op66(r32);
op(0x50);
FloatToNumer(/*actualreturn==tk_float?0:4*/);
break;
}
if(cpu<3)cpu=3;
break;
case tk_qword:
switch(actualreturn){
case tk_char:
op66(r32);
op(0x0F); outword(0xC0BE); //MOVSX EAX,AL
cwdq(r32);
break;
case tk_byte: /* MOVZX EAX,AL */
op66(r32);
op(0x0F); outword(0xC0B6);
ZeroReg(EDX,r32);
break;
case tk_word: /* MOVZX EAX,AX */
op66(r32);
op(0x0F); outword(0xC0B7);
case tk_dword:
ZeroReg(EDX,r32);
break;
case tk_int: /* MOVSX EAX,AX */
op66(r32);
op(0x0F); outword(0xC0BF);
case tk_long:
cwdq(r32);
break;
case tk_fpust:
case tk_double:
FpuSt2QNumber();
break;
case tk_float:
op66(r32);
op(0x50);
FloatToNumer(actualreturn==tk_float?0:4);
cwdq(r32);
break;
}
if(cpu<3)cpu=3;
break;
case tk_fpust:
if(tok2==tk_semicolon)break;
switch(actualreturn){
case tk_char:
CheckInitBP();
cbw();
op66(r32);
outword(0xDF50); //push EAX
goto endfxld; //fild ss[bp-4]/[esp]
case tk_byte:
CheckInitBP();
xorAHAH();
op66(r32);
outword(0xDF50); //push EAX
goto endfxld; //fild ss[bp-4]/[esp]
case tk_word:
CheckInitBP();
op66(r16);
outword(0x6A); //push 0
op66(r16);
outword(0xDB50); //push AX
goto endfxld; //fild ss[bp-4]/[esp]
case tk_int:
CheckInitBP();
op66(r32);
outword(0xDF50); //push eax
goto endfxld; //fild ss[bp-4]/[esp]
case tk_dword:
CheckInitBP();
op66(r32); //push 0L
outword(0x6A);
op66(r32);
op(0x50); //push EAX
fildq_stack();
RestoreBP();
op66(r32);
op(0x58); //pop eax
op66(r32);
op(0x58); //pop eax
break;
case tk_long:
CheckInitBP();
op66(r32);
outword(0xDB50); //push EAX
goto endfxld; //fild ss[bp-4]/[esp]
case tk_float:
CheckInitBP();
op66(r32);
outword(0xd950); //push EAX
endfxld:
fld_stack(4+localsize);
RestoreBP();
op66(r32);
op(0x58); //pop eax
break;
case tk_qword:
// case tk_double:
CheckInitBP();
op66(r32);
op(0x50+EDX); //push EDX
op66(r32);
op(0x50); //push EAX
/* if(actualreturn==tk_double){
op(0xDD);
fld_stack(8+localsize);
}
else*/ fildq_stack();
RestoreBP();
op66(r32);
op(0x58); //pop eax
op66(r32);
op(0x58); //pop eax
break;
}
if(cpu<3)cpu=3;
break;
default:
// printf("expectedreturn=%d %s %d\n",expectedreturn,(startfileinfo+currentfileinfo)->filename,linenumber);
break;
}
}
int procdo(int expectedreturn)
{
int actualreturn;
char idflag=0;
switch(tok){
case tk_ID: idflag++;
case tk_id:
actualreturn=doid(idflag,expectedreturn);
break;
case tk_proc:
actualreturn=doanyproc();
break;
case tk_apiproc:
case tk_undefproc:
case tk_declare:
// if((actualreturn=doanyundefproc())==tk_void)actualreturn=expectedreturn;
actualreturn=doanyundefproc(); //17.09.05 17:56
break;
default: internalerror("Bad tok in procdo();"); break;
}
convert_returnvalue(expectedreturn,actualreturn);
return actualreturn;
}
/* +++++++++++++++++++++++ loops and ifs start ++++++++++++++++++++++++ */
void endcmpfloat()
{
fwait3();
outword(0xE0DF);//fstsw ax
op(0x9E);
RestoreBP();
}
int outcmp(int swapped,int ctok,ITOK *cstok,char *&cbuf,SINFO *cstr,int ctok2,ITOK *cstok2,char *&cbuf2,SINFO *cstr2,int typet)
{
unsigned char err=0;
int typef=0;
int vop=0;
long long lnumber;
unsigned int ofs;
int i,reg,reg1;
if(typet<r16)typet=r16;
switch(ctok){
case tk_reg64:
reg=cstok->number/256;
switch(ctok2){
case tk_reg64:
reg1=cstok2->number/256;
for(i=0;i<2;i++){
op66(r32);
op(0x39); //cmp reg,reg
op(0xC0+reg+reg1*8);
if(i==1)break;
outword(0x75);
ofs=outptr;
reg=cstok->number&255;
reg1=cstok2->number&255;
}
output[ofs-1]=outptr-ofs;
break;
case tk_number:
case tk_postnumber:
case tk_undefofs:
lnumber=cstok2->lnumber>>32;
for(i=0;i<2;i++){
op66(r32);
//ïðîâåðêà íà âîçìîæíîñòü áîëåå êîðîòêîãî êîäà
if((cstok2->flag&f_reloc)==0&&ctok2!=tk_postnumber&&ctok2!=tk_undefofs&&
short_ok(lnumber,TRUE)){
if(!lnumber){
op(0x85); //test reg,reg
op(0xc0+reg*9);
}
else{
op(0x83); //cmp reg,
op(0xF8+reg);
op(lnumber);
}
}
else{
if(reg==AX)op(0x3D);
else{
op(0x81);
op(0xF8+reg);
}
if(i==1){
if(ctok2==tk_postnumber)(cstok2->flag&f_extern)==0?setwordpost(cstok2):setwordext(&cstok2->number);
else if((cstok2->flag&f_reloc)!=0)AddReloc(cstok2->segm);
if(ctok2==tk_undefofs)AddUndefOff(2,cstok2->name);
}
outdword(cstok2->number);
}
if(i==1)break;
outword(0x75);
ofs=outptr;
reg=cstok->number&255;
}
output[ofs-1]=outptr-ofs;
break;
default:
if(swapped)err=1;
else return(outcmp(1,ctok2,cstok2,cbuf2,cstr2,ctok,cstok,cbuf,cstr,typet));
break;
}
break;
case tk_reg32:
case tk_reg:
switch(ctok2){
case tk_reg:
case tk_reg32:
if(ctok!=ctok2)err=1;
else{
op66(typet);
op(0x39); //cmp reg,reg
op(0xC0+(unsigned int)cstok->number+(unsigned int)cstok2->number*8);
}
break;
case tk_number:
if(cstok2->number==0&&(cstok2->flag&f_reloc)==0){
op66(typet);
op(0x85); //test reg,reg
op(0xc0+(unsigned int)cstok->number*9);
break;
}
case tk_postnumber:
case tk_undefofs:
op66(typet);
//ïðîâåðêà íà âîçìîæíîñòü áîëåå êîðîòêîãî êîäà
if((cstok2->flag&f_reloc)==0&&ctok2!=tk_postnumber&&ctok2!=tk_undefofs&&
short_ok(cstok2->number,ctok==tk_reg?FALSE:TRUE)){
op(0x83); //cmp reg,
op(0xF8+(unsigned int)cstok->number);
op(cstok2->number);
break;
}
if(cstok->number==AX)op(0x3D);
else{
op(0x81);
op(0xF8+(unsigned int)cstok->number);
}
if(ctok2==tk_postnumber)(cstok2->flag&f_extern)==0?setwordpost(cstok2):setwordext(&cstok2->number);
else if((cstok2->flag&f_reloc)!=0)AddReloc(cstok2->segm);
if(ctok2==tk_undefofs)AddUndefOff(2,cstok2->name);
if(ctok==tk_reg)outword((unsigned int)cstok2->number);
else outdword(cstok2->number);
break;
default:
if(swapped)err=1;
else return(outcmp(1,ctok2,cstok2,cbuf2,cstr2,ctok,cstok,cbuf,cstr,typet));
break;
}
break;
case tk_qwordvar:
cstok->number+=4;
compressoffset(cstok);
switch(ctok2){
case tk_postnumber:
case tk_number:
case tk_undefofs:
lnumber=cstok2->lnumber>>32;
CheckAllMassiv(cbuf,8,cstr,cstok);
for(i=0;i<2;i++){
op66(r32);
outseg(cstok,2);
//ïðîâåðêà íà âîçìîæíîñòü áîëåå êîðîòêîãî êîäà
if((cstok2->flag&f_reloc)==0&&ctok2!=tk_postnumber&&ctok2!=tk_undefofs&&
short_ok(lnumber,1)){
op(0x83);
op(0x38+cstok->rm);
outaddress(cstok);
op(lnumber);
}
else{
op(0x81);
op(0x38+cstok->rm);
outaddress(cstok);
if(i==1){
if(ctok2==tk_postnumber)(cstok2->flag&f_extern)==0?setwordpost(cstok2):setwordext(&cstok2->number);
else if((cstok2->flag&f_reloc)!=0)AddReloc(cstok2->segm);
if(ctok2==tk_undefofs)AddUndefOff(2,cstok2->name);
}
outdword(lnumber);
}
if(i==1)break;
outword(0x75);
ofs=outptr;
cstok->number-=4;
compressoffset(cstok);
lnumber=cstok2->lnumber;
}
output[ofs-1]=outptr-ofs;
break;
case tk_reg64:
CheckAllMassiv(cbuf,8,cstr,cstok);
reg=cstok2->number/256;
for(i=0;i<2;i++){
op66(r32);
outseg(cstok,2);
op(0x39); /* CMP [word],AX */
op(cstok->rm+reg*8);
outaddress(cstok);
if(i==1)break;
reg=cstok2->number&255;
outword(0x75);
ofs=outptr;
cstok->number-=4;
compressoffset(cstok);
}
output[ofs-1]=outptr-ofs;
break;
default:
i=EAX|(EDX*256);
getintoreg64(i);
doregmath64(i);
CheckAllMassiv(cbuf,8,cstr,cstok);
reg=EDX;
for(i=0;i<2;i++){
op66(r32);
outseg(cstok,2);
op(0x39); /* CMP [word],AX */
op(cstok->rm+reg*8);
outaddress(cstok);
if(i==1)break;
reg=EAX;
outword(0x75);
ofs=outptr;
cstok->number-=4;
compressoffset(cstok);
}
output[ofs-1]=outptr-ofs;
break;
}
break;
case tk_intvar:
case tk_wordvar:
if(swapped&&typet==r32)typet=r16;
case tk_longvar:
case tk_dwordvar:
switch(ctok2){
case tk_reg32:
case tk_reg:
CheckAllMassiv(cbuf,typet,cstr,cstok);
op66(typet);
outseg(cstok,2);
op(0x39);
op((unsigned int)cstok2->number*8+cstok->rm);
outaddress(cstok);
break;
case tk_postnumber:
case tk_number:
case tk_undefofs:
CheckAllMassiv(cbuf,typet,cstr,cstok);
op66(typet);
outseg(cstok,2);
//ïðîâåðêà íà âîçìîæíîñòü áîëåå êîðîòêîãî êîäà
if((cstok2->flag&f_reloc)==0&&ctok2!=tk_postnumber&&ctok2!=tk_undefofs&&
short_ok(cstok2->number,typet/2-1)){
op(0x83);
op(0x38+cstok->rm);
outaddress(cstok);
op(cstok2->number);
break;
}
op(0x81);
op(0x38+cstok->rm);
outaddress(cstok);
if(ctok2==tk_postnumber)(cstok2->flag&f_extern)==0?setwordpost(cstok2):setwordext(&cstok2->number);
else if((cstok2->flag&f_reloc)!=0)AddReloc(cstok2->segm);
if(ctok2==tk_undefofs)AddUndefOff(2,cstok2->name);
if(typet==r16)outword((unsigned int)cstok2->number);
else outdword(cstok2->number);
break;
case tk_charvar:
case tk_intvar:
getinto_e_ax(1,ctok2,cstok2,cbuf2,cstr2,typet);
CheckAllMassiv(cbuf,typet,cstr,cstok);
op66(typet);
outseg(cstok,2);
op(0x39); /* CMP [word],AX */
op(cstok->rm);
outaddress(cstok);
break;
default:
getinto_e_ax(0,ctok2,cstok2,cbuf2,cstr2,typet);
// ClearReg(AX);
CheckAllMassiv(cbuf,typet,cstr,cstok);
op66(typet);
outseg(cstok,2);
op(0x39); /* CMP [word],AX */
op(cstok->rm);
outaddress(cstok);
break;
}
break;
case tk_number:
if(ctok2==tk_postnumber){
op(0xB8); /* MOV AX,# */
if((cstok->flag&f_reloc)!=0)AddReloc(cstok->segm);
if(am32==FALSE)outword((unsigned int)cstok->number);
else outdword(cstok->number);
op(0x3D); /* CMP AX,# */
(cstok2->flag&f_extern)==0?setwordpost(cstok2):setwordext(&cstok2->number);
if(am32==FALSE)outword((unsigned int)cstok2->number);
else outdword(cstok2->number);
}
if(ctok2==tk_number){
if(cstok2->rm!=tk_float&&cstok->rm!=tk_float){
if((unsigned long)cstok2->number<256&&(unsigned long)cstok->number<256){
op(0xB0); //mov al,number
op(cstok->number);
op(0x3C); //cmp Al,number
op(cstok2->number);
}
else if((unsigned long)cstok2->number<65536&& cstok->number<65536){
op66(r16);
op(0xB8); /* MOV AX,# */
if((cstok->flag&f_reloc)!=0)AddReloc(cstok->segm);
outword((unsigned int)cstok->number);
op66(r16);
op(0x3D); /* CMP AX,# */
if((cstok2->flag&f_reloc)!=0)AddReloc(cstok2->segm);
outword((unsigned int)cstok2->number);
}
else{
op66(r32);
op(0xB8); /* MOV AX,# */
if((cstok->flag&f_reloc)!=0)AddReloc(cstok->segm);
outdword(cstok->number);
op66(r32);
op(0x3D); /* CMP AX,# */
if((cstok2->flag&f_reloc)!=0)AddReloc(cstok2->segm);
outdword(cstok2->number);
}
}
else{
op(0x55); //push bp
outword(0xe589);//mov bp,sp
op66(r32);
if(short_ok(cstok->number,TRUE)){ //push num
op(0x6A);
op(cstok->number);
}
else{
op(0x68);
outdword(cstok->number);
}
op66(r32);
if(short_ok(cstok2->number,TRUE)){ //push num
op(0x6A);
op(cstok2->number);
}
else{
op(0x68);
outdword(cstok2->number);
}
outword(am32==FALSE?0x46d9:0x45d9);
op(0xfC);//fld ssdword[bp-4]
op(0xD8);
outword(0xF85e - am32); //fcomp [bp-8]
endcmpfloat();
}
}
else{
if(swapped)err=1;
else return(outcmp(1,ctok2,cstok2,cbuf2,cstr2,ctok,cstok,cbuf,cstr,typet));
}
break;
case tk_postnumber:
if(ctok2==tk_number||ctok2==tk_postnumber){
op(0xB8); /* MOV AX,# */
(cstok->flag&f_extern)==0?setwordpost(cstok):setwordext(&cstok->number);
if(am32==FALSE)outword((unsigned int)cstok->number);
else outdword(cstok->number);
op(0x3D); /* CMP AX,# */
if(ctok2==tk_postnumber)(cstok2->flag&f_extern)==0?setwordpost(cstok2):setwordext(&cstok2->number);
else if((cstok2->flag&f_reloc)!=0)AddReloc(cstok2->segm);
if(am32==FALSE)outword((unsigned int)cstok2->number);
else outdword(cstok2->number);
}
else{
if(swapped)err=1;
else return(outcmp(1,ctok2,cstok2,cbuf2,cstr2,ctok,cstok,cbuf,cstr,typet));
}
break;
case tk_charvar:
case tk_bytevar:
switch(ctok2){
case tk_number:
CheckAllMassiv(cbuf,1,cstr,cstok);
outseg(cstok,2);
op(0x80); /* CMP [byte],# */
op(0x38+cstok->rm);
outaddress(cstok);
op((unsigned int)cstok2->number);
break;
case tk_reg:
case tk_reg32:
if(cstok2->number>3)goto defchar;
case tk_beg:
CheckAllMassiv(cbuf,1,cstr,cstok);
outseg(cstok,2);
op(0x38); /* CMP [byte],beg */
op((unsigned int)cstok2->number*8+cstok->rm);
outaddress(cstok);
break;
default:
defchar:
getintoal(ctok2,cstok2,cbuf2,cstr2);
CheckAllMassiv(cbuf,1,cstr,cstok);
outseg(cstok,2);
op(0x38); /* CMP [byte],AL */
op(cstok->rm);
outaddress(cstok);
break;
}
break;
case tk_beg:
switch(ctok2){
case tk_number:
if(cstok2->number==0){
op(0x84); //test beg,beg
op(0xc0+(unsigned int)cstok->number*9);
break;
}
if((unsigned int)cstok->number==AL)op(0x3C);
else{
op(0x80);
op(0xF8+(unsigned int)cstok->number);
}
op((unsigned int)cstok2->number);
break;
case tk_beg:
op(0x38);
op(0xC0+(unsigned int)cstok->number+(unsigned int)cstok2->number*8);
break;
case tk_reg:
if((unsigned int)cstok2->number<=BX){ /* CMP beg,beg */
op(0x38);
op(0xC0+(unsigned int)cstok->number+(unsigned int)cstok2->number*8);
}
else{
op66(r16);
op(0x89); /* MOV AX,reg */
op(0xC0+(unsigned int)cstok2->number*8);
op(0x38); /* CMP beg,AL */
op(0xC0+(unsigned int)cstok->number);
}
break;
default:
if(swapped)err=1;
else return(outcmp(1,ctok2,cstok2,cbuf2,cstr2,ctok,cstok,cbuf,cstr,typet));
break;
}
break;
case tk_doublevar:
vop=4;
goto cont_float;
case tk_fpust:
typef++;
if(cstok->type==tp_modif)typef++;
else{
if(cstok->number!=0){
op(0xd9); //fld st(x)
op(0xC0+cstok->number);
typef++;
}
}
case tk_floatvar:
cont_float:
switch(ctok2){
case tk_beg:
CheckInitBP();
switch(cstok2->rm){
case tk_char:
case tk_int:
case tk_long:
outword(0xBE0F); /* MOVSX AX,beg */
op(0xC0+(unsigned int)cstok2->number);
break;
default:
if((optimizespeed&&chip>3&&chip<7)||cstok2->number==AL){
xorAHAH();
if(cstok2->number!=AL){
op(0x88);
op(0xC0+cstok2->number*8); //mov al,beg
}
}
else{
outword(0xB60F); // MOVZX AX,beg
op(0xC0+(unsigned int)cstok2->number);
}
break;
}
outword(0xDF50); //push AX
fld_stack(2+localsize);
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
op(0x58); // pop EAX
endcmpfloat();
swapped=1;
break;
case tk_reg:
CheckInitBP();
op66(r32);
switch(cstok2->rm){
case tk_char:
case tk_int:
case tk_long:
outword(0xBF0F); /* MOVSX EAX,reg */
break;
default:
if(optimizespeed&&chip>3&&chip<7&&cstok2->number!=AX){
outword(0xC031); // xor EAX,EAX
op66(r16);
op(0x8B);
}
else outword(0xB70F); // MOVZX EAX,reg
break;
}
op(0xC0+(unsigned int)cstok2->number);
op66(r32);
outword(0xDB50); //push EAX
fld_stack(4+localsize);
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
op66(r32);
op(0x58); // pop EAX
endcmpfloat();
swapped=1;
break;
case tk_reg32:
CheckInitBP();
if(cstok2->rm==tk_float){
op66(r32);
op(0x50+(unsigned int)cstok2->number); //push reg32
op(0xd9);
fld_stack(4+localsize);
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
op66(r32);
op(0x58); // pop EAX
}
else{
if(cstok2->rm!=tk_char&&cstok2->rm!=tk_int&&cstok2->rm!=tk_long){
typet=tk_word;
op66(r32);
outword(0x6a); //$push 0
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
}
op66(r32);
op(0x50+cstok2->number); //push reg32
if(typet!=r16)fildq_stack();
else{
op(0xdb);
fld_stack(4+localsize);
}
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
if(typet!=r16){
if(optimizespeed||am32==FALSE){
outword(0xC483);
op(8);
}
else{
op(0x58); // pop EAX
op(0x58); // pop EAX
}
}
else{
op66(r32);
op(0x58); // pop EAX
}
}
endcmpfloat();
swapped=1;
break;
case tk_charvar:
CheckAllMassiv(cbuf2,1,cstr2,cstok2);
outseg(cstok2,3); /* MOVSX AX,[charvar] */
outword(0xBE0F); op(cstok2->rm);
outaddress(cstok2);
CheckInitBP();
outword(0xdf50); //push ax
fld_stack(2+localsize);
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
op(0x58); // pop EAX
endcmpfloat();
swapped=1;
break;
case tk_intvar:
CheckAllMassiv(cbuf2,2,cstr2,cstok2);
outseg(cstok2,2);
if(typef){
op(0xDE); //ficomp var2
op(cstok2->rm+0x08+typef*8);
outaddress(cstok2);
}
else{
op(0xdf); //fild var
op(cstok2->rm);
outaddress(cstok2);
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
swapped=1;
}
fwait3_4();
outword(0xE0DF);//fstsw ax
op(0x9E);
break;
case tk_bytevar:
CheckAllMassiv(cbuf2,1,cstr2,cstok2);
if(optimizespeed&&chip>3&&chip<7){
outword(0xC031);
outseg(cstok2,2);
op(0x8A);
}
else{
outseg(cstok2,3);
outword(0xB60F);
}
op(cstok2->rm); // MOVZX regL,[byte]
outaddress(cstok2);
CheckInitBP();
outword(0xDF50); //push ax
fld_stack(2+localsize);
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
op(0x58); // pop EAX
endcmpfloat();
swapped=1;
break;
case tk_wordvar:
CheckInitBP();
op66(r16);
outword(0x6a); //push 0
CheckAllMassiv(cbuf2,2,cstr2,cstok2);
op66(r16);
outseg(cstok2,2); //push var
op(0xFF);
op(cstok2->rm+0x30);
outaddress(cstok2);
op(0xDB);
fld_stack(4+localsize);
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=4;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
op66(r32);
op(0x58); // pop EAX
endcmpfloat();
swapped=1;
break;
case tk_dwordvar:
CheckInitBP();
op66(r32); //push 0L
outword(0x6a);
CheckAllMassiv(cbuf2,4,cstr2,cstok2);
op66(r32); //push var
outseg(cstok2,2);
op(0xFF);
op(cstok2->rm+0x30);
outaddress(cstok2);
fildq_stack();
if(typef==2)outword(0xD9DE); //FCOMPP
else if(typef==1)outword(0xD9D8); //FCOMP
else{
if(ESPloc&&am32&&cstok->segm==SS)cstok->number+=8;
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
if(optimizespeed||am32==FALSE){
outword(0xC483);
op(8);
}
else{
op(0x58); // pop EAX
op(0x58); // pop EAX
}
endcmpfloat();
swapped=1;
break;
case tk_longvar:
CheckAllMassiv(cbuf2,4,cstr2,cstok2);
outseg(cstok2,2);
if(typef){
op(0xDA); //ficomp var2
op(cstok2->rm+0x08+typef*8);
outaddress(cstok2);
}
else{
op(0xdb); //fild var
op(cstok2->rm);
outaddress(cstok2);
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
swapped=1;
}
endcmpfloat();
break;
case tk_number:
if(!typef){
CheckAllMassiv(cbuf,4,cstr,cstok);
outseg(cstok,2); //fld val
op(0xd9);
op(cstok->rm);
outaddress(cstok);
}
if(cstok2->rm!=tk_double&&cstok2->rm!=tk_float){
cstok2->dnumber=cstok2->lnumber;
cstok2->rm=tk_double;
}
else if(vop==4&&cstok2->rm==tk_float){
cstok2->dnumber=cstok2->fnumber;
cstok2->rm=tk_double;
}
if(am32&&(cstok2->rm==tk_float&&cstok2->fnumber==0.0)||
(cstok2->rm==tk_double&&cstok2->dnumber==0.0)||cstok2->lnumber==0){
outword(0xe4d9); //ftst
if(typef!=1)outword(0xC0DD); //ffree
}
else{
op66(r32);
int rm;
rm=(am32==FALSE?0x1eD8:0x1DD8);
if(typef==1)rm-=0x800;
if(cstok2->rm==tk_double||vop==4)rm+=4;
outword(rm); //fcom(p)
AddFloatConst(cstok2->lnumber,cstok2->rm);
outword(0);
if(am32)outword(0);
}
endcmpfloat();
break;
case tk_floatvar:
if(!typef){
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fld val
op(0xd9+vop);
op(cstok->rm);
outaddress(cstok);
}
CheckAllMassiv(cbuf2,4,cstr2,cstok2);
outseg(cstok2,2); //fcomp var
op(0xd8);
op(cstok2->rm+(typef==1?0x10:0x18));
outaddress(cstok2);
endcmpfloat();
break;
case tk_doublevar:
if(!typef){
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fld val
op(0xd9+vop);
op(cstok->rm);
outaddress(cstok);
}
CheckAllMassiv(cbuf2,8,cstr2,cstok2);
outseg(cstok2,2); //fcomp var
op(0xd8+4);
op(cstok2->rm+(typef==1?0x10:0x18));
outaddress(cstok2);
endcmpfloat();
break;
case tk_fpust:
if(typef==2){ //fcomp
if(chip>=7){ //fcomip
op(0xDF);
op(0xF0+cstok2->number+1);
swapped=1;
break;
}
op(0xD8);
op(0xD8+cstok2->number+1);
}
else if(typef==1){ //fcom
if(chip>=7){ //fcomi
op(0xDB);
op(0xF0+cstok2->number);
swapped=1;
break;
}
op(0xD8);
op(0xD0+cstok2->number);
}
else{
if(cstok2->type!=tp_modif){
op(0xd9); //fld st(x)
op(0xC0+cstok2->number);
}
CheckAllMassiv(cbuf,4+vop,cstr,cstok);
outseg(cstok,2); //fcomp var
op(0xd8+vop);
op(cstok->rm+0x18);
outaddress(cstok);
}
endcmpfloat();
swapped=1;
break;
default:
err=1;
break;
}
break;
default: err=1; break;
}
if(err)preerror("unable to create comparison, check restrictions");
return(swapped);
}
int CheckCompareTok(int reg)
{
int comparetok=tk_equalto;
if(itok.type==tp_compare)comparetok=tok;
else unknowncompop();
getoperand(reg);
return comparetok;
}
int typenumber(int vtok)
{
switch(vtok){
case tk_char:
case tk_beg:
case tk_byte:
return tk_byte;
case tk_int:
case tk_reg:
case tk_word:
return tk_word;
case tk_reg64:
case tk_qword:
return tk_qword;
case tk_floatvar:
case tk_float:
return tk_float;
case tk_doublevar:
case tk_double:
return tk_double;
}
return tk_dword;
}
#ifdef OPTVARCONST
int constructcompare(int invertflag,unsigned int startloc,LVIC *comconst)
#else
int constructcompare(int invertflag,unsigned int startloc)
#endif
/* build cmp for IF, if and do {} while */
{
int comparetok=0,jumptype,vartype=tokens,notflag=FALSE;
int ittok,ittok2=tokens,type2=tokens;//,retcompare=tokens;
int razr=r_undef;
char *ibuf,*ibuf2;
ITOK htok,htok2;
SINFO hstr,hstr2;
int preg=(am32==TRUE?EAX:SI);
int use_cxz=0;
char *ofsstr=NULL,*ofsstr2=NULL;
int usereg=-1;
int usereg2=-1;
//////04.10.04 13:45
int bracket=0;
unsigned char oinline=useinline;
useinline=0;
do{
nexttok();
// printf("tok=%d tok2=%d\n",tok,tok2);
if(tok==tk_openbracket)bracket++;
if(tok==tk_not)notflag=(notflag+1)%2;
}while(tok2==tk_openbracket||tok2==tk_not);
if(bracket==0)expected('(');
/////////////////
setzeroflag=FALSE;
ofsstr=GetLecsem(tk_closebracket,tk_eof,tp_compare);
getoperand(); //NEW 04.10.04 13:45
if(tok==tk_openbracket){
bracket++;
getoperand();
}
if(tok==tk_not){
notflag=(notflag+1)%2;
getoperand();
}
switch(tok){
case tk_closebracket:
useinline=oinline;
getoperand();
return voidcompr;
case tk_asm:
if(tok2==tk_openbrace){
nexttok();
type2=tok;
}
case tk_dollar:
nexttok();
case tk_idasm:
if(stricmp(itok.name,"test")==0){
if(iTest(1)==FALSE)InvOperComp();
ittok=0x75;
if(type2==tk_openbrace)expecting(tk_closebrace);
goto endcomp;
}
else preerror("Only 'TEST' possible use in compare");
break;
case tk_qword:
case tk_double:
razr+=4;
case tk_beg:
case tk_reg32:
case tk_reg: vartype=tok; break;
case tk_float:
case tk_long:
case tk_dword:
razr+=2;
case tk_int:
case tk_word:
razr++;
case tk_char:
case tk_byte:
razr++;
vartype=tok;
getoperand();
if(tok==tk_closebracket&&bracket>1){
bracket--;
getoperand();
}
break;
case tk_undefproc:
case tk_declare:
// if(itok.rm==tk_void)itok.rm=(am32==FALSE?tk_word:tk_dword);
case tk_proc:
case tk_apiproc:
vartype=itok.rm;
if(vartype==tokens)vartype=(am32==FALSE?tk_word:tk_dword);
else if(vartype==tk_void&&(itok.flag&f_retproc)==0){
retvoid();
vartype=itok.rm=(am32==FALSE?tk_word:tk_dword);
}
if(ofsstr){
free(ofsstr);
ofsstr=NULL;
}
break;
case tk_bytevar: vartype=tk_byte; break;
case tk_charvar: vartype=tk_char; break;
case tk_intvar: vartype=tk_int; break;
case tk_wordvar: vartype=tk_word; break;
case tk_dwordvar: vartype=tk_dword; break;
case tk_longvar: vartype=tk_long; break;
case tk_floatvar: vartype=tk_float; break;
case tk_qwordvar: vartype=tk_qword; break;
case tk_fpust:
case tk_doublevar: vartype=tk_double; break;
case tk_bits:
int i;
i=itok.bit.ofs+itok.bit.siz;
if(i<=64){
vartype=tk_dword;
razr=r64;
}
if(i<=32){
vartype=tk_dword;
razr=r32;
}
if(i<=16){
vartype=tk_word;
razr=r16;
}
if(i<=8){
vartype=tk_byte;
razr=r8;
}
break;
case tk_at:
if(ofsstr){
free(ofsstr);
ofsstr=NULL;
}
nexttok();
if(itok.flag&f_retproc){
comparetok=(itok.flag&f_retproc)/256+tk_overflowflag-1;
// notflag=(notflag==FALSE?TRUE:FALSE);
vartype=tk_ID;
ittok2=macros(vartype);
if(tok2==tk_closebracket){
nexttok();
ittok=0x70+comparetok-tk_overflowflag;
goto endcomp;
}
if(ittok2==0){
vartype=itok.rm;
break;
}
goto mac1;
}
if((itok.flag&f_typeproc)==tp_fastcall&&itok.segm!=NOT_DYNAMIC)vartype=itok.rm;
else vartype=tk_ID;
if((ittok2=macros(vartype))==0){
vartype=itok.rm;
break;
}
mac1:
vartype=ittok2;
switch(vartype){
case tk_byte:
case tk_char: tok=tk_beg; break;
case tk_int:
case tk_word: tok=tk_reg; break;
case tk_float:
case tk_dword:
case tk_long: tok=tk_reg32; break;
case tk_double:
case tk_qword: tok=tk_reg64; break;
default:
preerror("Macro has a return type of void");
tok=tk_reg;
vartype=tk_word;
break;
}
itok.number=AX; // or AL or EAX
break;
default:
if((tok>=tk_overflowflag)&&(tok<=tk_plusflag)){
ittok=0x70+tok-tk_overflowflag;
nexttok();
if(tok!=tk_closebracket&&(tok==tk_oror||tok==tk_andand||tok==tk_notequal||tok==tk_equalto)){
int oper;
int oper2;
oper=tok;
nexttok();
ittok^=notflag;
notflag=0;
if(tok==tk_not){
notflag=TRUE;
nexttok();
}
if((tok>=tk_overflowflag)&&(tok<=tk_plusflag)){
ittok-=0x70;
ittok2=tok-tk_overflowflag;
ittok2^=notflag;
notflag=0;
nexttok();
switch(oper){
case tk_oror:
if((ittok==2&&ittok2==4)||(ittok==4&&ittok2==2))ittok=6;
else if(ittok==4&&(ittok2==8||ittok2==0))ittok=(ittok|ittok2)+1;
else unknowncompop();
break;
case tk_andand:
if((ittok==3&&ittok2==5)||(ittok==5&&ittok2==3))ittok=7;
else if(ittok==5&&(ittok2==8||ittok2==0))ittok=(ittok|ittok2)+1;
else unknowncompop();
break;
case tk_notequal:
if((ittok==8&&ittok2==0)||(ittok==0&&ittok2==8))ittok=12;
else unknowncompop();
break;
case tk_equalto:
if((ittok==8&&ittok2==0)||(ittok==0&&ittok2==8))ittok=13;
else unknowncompop();
break;
}
if(tok!=tk_closebracket&&(tok==tk_notequal||tok==tk_equalto)){
oper2=tok;
nexttok();
if(tok==tk_not){
notflag=TRUE;
nexttok();
}
if((tok>=tk_overflowflag)&&(tok<=tk_plusflag)){
ittok2=tok-tk_overflowflag;
ittok2^=notflag;
notflag=0;
nexttok();
if(oper2==tk_notequal){
if(oper==tk_oror&&((ittok==5&&ittok2==8)||(ittok==13&&ittok2==0)))ittok=14;
else unknowncompop();
}
else{
if(oper==tk_andand&&((ittok==6&&ittok2==8)||(ittok==14&&ittok2==0)))ittok=15;
else unknowncompop();
}
}
else unknowncompop();
}
}
else unknowncompop();
ittok+=0x70;
}
goto endcomp;
}
vartype=(am32==FALSE?tk_word:tk_dword);
break;
}
CheckMinusNum();
if(itok2.type!=tp_compare&&tok2!=tk_closebracket){ //ñëîæíûé îïåðàíä
if(ofsstr){
int retreg;
razr=getrazr(vartype);
if((retreg=CheckIDZReg(ofsstr,AX,razr))!=NOINREG){
GetEndLex(tk_closebracket,tk_semicolon,tp_compare);
nexttok();
if(razr==r16)ittok=tk_reg;
else if(razr==r32)ittok=tk_reg32;
else ittok=tk_beg;
usereg=htok.number=retreg==SKIPREG?AX:retreg;
goto nn1;
}
}
comparetok=0;//èñïîëüçóåòñÿ âðåìåííî íå ïîñìûñëó
ittok=tok;
htok=itok;
ibuf=NULL;
hstr.bufstr=NULL;
ittok2=tok2;
preg=BX;
switch(tok2){
case tk_assign:
case tk_plusplus:
case tk_minusminus:
case tk_divequals:
case tk_minusequals:
case tk_multequals:
case tk_plusequals:
switch(tok){
case tk_charvar: comparetok=1;
case tk_bytevar:
if((comparetok=dobytevar(comparetok,0))==tk_reg||comparetok==tk_beg){
usereg=htok.number=AX;
ittok=tk_beg;
}
break;
case tk_intvar: comparetok=1;
case tk_wordvar:
if((comparetok=do_d_wordvar(comparetok,r16,0))==tk_reg){
usereg=htok.number=AX;
ittok=tk_reg;
}
break;
case tk_longvar: comparetok=1;
case tk_dwordvar:
if((comparetok=do_d_wordvar(comparetok,r32,0))==tk_reg32){
usereg=htok.number=AX;
ittok=tk_reg32;
}
break;
case tk_floatvar:
if(dofloatvar(0,tk_fpust,0)==tk_fpust){
ittok=tk_fpust;
htok.type=tp_modif;
}
break;
case tk_qwordvar:
if((comparetok=doqwordvar(0))==tk_reg64){
ittok=tk_reg64;
usereg=htok.number=EAX|(EDX*256);
}
break;
case tk_reg64:
usereg=itok.number;
getintoreg64(itok.number);
doregmath64(itok.number);
comparetok=tk_reg64;
break;
case tk_reg32:
usereg=itok.number;
comparetok=doreg_32((unsigned int)itok.number,r32,0);
// printf("comparetok=%d\n",comparetok);
break;
case tk_reg:
usereg=itok.number;
comparetok=doreg_32((unsigned int)itok.number,r16,0);
break;
case tk_beg:
usereg=itok.number;
comparetok=dobeg((unsigned int)itok.number,0);
break;
default: InvOperComp(); break;
}
if(ittok<tk_floatvar&&(!(comparetok>=tk_overflowflag&&comparetok<=tk_plusflag))){
if(ittok2!=tk_assign&&ittok2!=tk_divequals&&ittok2!=tk_multequals){
if(tok==tk_closebracket){
ittok=0x75;
goto endcomp;
}
if(tok2==tk_number&&itok2.number==0){
if((ittok2==tk_plusplus||ittok2==tk_minusminus)&&
tok!=tk_notequal&&tok!=tk_equalto)break;
comparetok=CheckCompareTok(BX);
nexttok();
goto createopcode;
}
}
}
break;
default:
switch(vartype){
case tk_int: comparetok=do_e_axmath(1,r16,&ofsstr); ittok=tk_reg; break;
case tk_reg:
case tk_word: comparetok=do_e_axmath(0,r16,&ofsstr); ittok=tk_reg; break;
case tk_char: comparetok=doalmath(1,&ofsstr); ittok=tk_beg; break;
case tk_beg:
case tk_byte: comparetok=doalmath(0,&ofsstr); ittok=tk_beg; break;
case tk_long: comparetok=do_e_axmath(1,r32,&ofsstr); ittok=tk_reg32; break;
case tk_reg32:
case tk_dword:
comparetok=do_e_axmath(0,r32,&ofsstr);
ittok=tk_reg32;
break;
case tk_qword:
usereg=htok.number=EAX|(EDX*256);
getintoreg64(usereg);
doregmath64(usereg);
comparetok=ittok=tk_reg64;
break;
case tk_float:
doeaxfloatmath(tk_fpust);
ittok=tk_fpust;
htok.type=tp_modif;
break;
default:
if(itok.flag&f_retproc){
comparetok=(itok.flag&f_retproc)/256+tk_overflowflag-1;
// printf("tok=%d flag=%08X comparetok=%u %s\n",tok,itok.flag,comparetok,itok.name);
// notflag=(notflag==FALSE?TRUE:FALSE);
switch(tok){
case tk_undefproc:
case tk_declare:
case tk_apiproc:
doanyundefproc();
break;
case tk_proc:
doanyproc();
break;
}
nexttok();
if(tok!=tk_closebracket){
retvoid();
do{
nexttok();
}while(tok!=tk_closebracket);
}
}
else{
internalerror("Bad vartype value in constructcompare();");
tok=tk_reg; break;
}
}
if(ittok!=tk_reg64)usereg=htok.number=AX; // same value as AL and EAX
}
RestoreStack();
}
else{
#ifdef OPTVARCONST
CheckConstVar3(&tok,&itok,razr);
#endif
if(tok>=tk_charvar&&tok<=tk_doublevar){
switch(vartype){
case tk_int: tok=tk_intvar; break;
case tk_word: tok=tk_wordvar; break;
case tk_char: tok=tk_charvar; break;
case tk_byte: tok=tk_bytevar; break;
case tk_long: tok=tk_longvar; break;
case tk_dword: tok=tk_dwordvar; break;
case tk_float: tok=tk_floatvar; break;
case tk_qword: tok=tk_qwordvar; break;
case tk_double: tok=tk_doublevar; break;
}
}
else if(tok==tk_number){
if(tok2==tk_closebracket){
invertflag=(itok.number==0?zerocompr:voidcompr);
nexttok();
getoperand();
useinline=oinline;
return invertflag;
}
if(itok.rm==tk_float)vartype=tk_float;
}
else if(tok==tk_bits){
bits2reg(AX,razr);
switch(razr){
case r64:
case r32:
tok=tk_reg32;
break;
case r16:
tok=tk_reg;
break;
case r8:
tok=tk_beg;
break;
}
itok.number=0;
}
if(tok==tk_beg||tok==tk_reg||tok==tk_reg32)itok.rm=vartype; //òèï ñîäåðæèìîãî â reg32
ittok=tok;
htok=itok;
ibuf=bufrm;
bufrm=NULL;
hstr=strinf;
strinf.bufstr=NULL;
nexttok();
}
nn1:
if(razr==r_undef){
switch(vartype){
case tk_qword:
case tk_double:
razr+=4;
case tk_long:
case tk_dword:
case tk_float:
case tk_reg32:
razr+=2;
case tk_int:
case tk_word:
case tk_reg:
razr++;
case tk_char:
case tk_byte:
case tk_beg:
razr++;
}
}
if(tok!=tk_closebracket){ //ñðàâíåíèå
ofsstr2=GetLecsem(tk_closebracket);
comparetok=CheckCompareTok(preg);
if(tok>=tk_char&&tok<=tk_double){
type2=tok;
if(ofsstr2)free(ofsstr2);
ofsstr2=GetLecsem(tk_closebracket);
getoperand(preg);
}
if(tok==tk_minus){
if(CheckMinusNum()==FALSE){
preerror("only negative of constants valid within compairsons");
nexttok();
}
}
#ifdef OPTVARCONST
CheckConstVar3(&tok,&itok,razr);
#endif
if(tok==tk_number){
switch(vartype){
case tk_long:
case tk_int:
case tk_char:
htok2.number=doconstlongmath();
itok.flag=(unsigned char)postnumflag;
break;
case tk_dword:
case tk_reg32:
case tk_beg:
case tk_reg:
case tk_word:
case tk_byte:
htok2.number=doconstdwordmath();
itok.flag=(unsigned char)postnumflag;
break;
case tk_float:
htok2.number=doconstfloatmath();
break;
case tk_reg64:
case tk_qword:
htok2.lnumber=doconstqwordmath();
itok.flag=(unsigned char)postnumflag;
break;
case tk_double:
htok2.lnumber=doconstdoublemath();
break;
}
htok2.rm=typenumber(vartype);
ittok2=tk_number;
htok2.flag=itok.flag;
}
else{
if(ittok>=tk_charvar&&ittok<=tk_doublevar&&(tok==tk_proc||tok==tk_id||
tok==tk_undefproc||tok==tk_declare||tok==tk_apiproc||tok==tk_ID||
itok2.type==tp_opperand||(tok>=tk_charvar&&tok<=tk_doublevar))){
if(ofsstr2){
int retreg;
razr=getrazr(vartype);
if((retreg=CheckIDZReg(ofsstr2,AX,razr))!=NOINREG){
GetEndLex(tk_closebracket);
usereg2=retreg==SKIPREG?AX:retreg;
if(razr==r16)ittok2=tk_reg;
else if(razr==r32)ittok2=tk_reg32;
else ittok2=tk_beg;
htok2.number=usereg2;
nexttok();
goto en2;
}
}
int sign=0;
switch(ittok){
case tk_charvar: sign=1;
case tk_bytevar:
doalmath(sign,&ofsstr2);
usereg2=htok2.number=AX;
ittok2=tk_beg;
break;
case tk_intvar: sign=1;
case tk_wordvar:
do_e_axmath(sign,r16,&ofsstr2);
usereg2=htok2.number=AX;
ittok2=tk_reg;
break;
case tk_longvar: sign=1;
case tk_dwordvar:
do_e_axmath(sign,r32,&ofsstr2);
usereg2=htok2.number=AX;
ittok2=tk_reg32;
break;
case tk_floatvar:
doeaxfloatmath(tk_fpust);
ittok2=tk_fpust;
htok2.type=tp_modif;
htok2.number=0;
ClearReg(AX);
break;
case tk_doublevar:
doeaxfloatmath(tk_fpust,0,4);
ittok2=tk_fpust;
htok2.type=tp_modif;
htok2.number=0;
ClearReg(AX);
break;
case tk_qwordvar:
usereg2=htok2.number=EAX|(EDX*256);
getintoreg64(usereg2);
doregmath64(usereg2);
ittok2=tk_reg64;
ClearReg(AX);
ClearReg(DX);
break;
}
}
else{
if(tok==tk_bits){
int i=itok.bit.ofs+itok.bit.siz;
int vops;
if(i<=64)vops=r64;
if(i<=32)vops=r32;
if(i<=16)vops=r16;
if(i<=8)vops=r8;
if(vops<razr)vops=razr;
i=AX;
if((ittok==tk_reg32||ittok==tk_reg||ittok==tk_beg)&&htok.number==0)i=CX;
bits2reg(i,vops);
switch(razr){
case r64:
case r32:
tok=tk_reg32;
break;
case r16:
tok=tk_reg;
break;
case r8:
tok=tk_beg;
break;
}
itok.number=i;
ClearReg(i);
}
switch(tok){
case tk_beg:
case tk_reg:
case tk_reg32:
itok.rm=type2; //òèï ñîäåðæèìîãî â reg32
if((ittok==tk_reg32||ittok==tk_reg||ittok==tk_beg)&&
htok.number==itok.number)preerror("Comparison two identical registers");
break;
}
int next=TRUE;
int sign=0;
if(ittok==tk_reg32){
if(ofsstr2){
int retreg;
int treg;
treg=(htok.number==0?DX:AX);
razr=r32;
if((retreg=CheckIDZReg(ofsstr2,treg,r32))!=NOINREG){
if(retreg==SKIPREG)retreg=treg;
if(retreg!=htok.number){
GetEndLex(tk_closebracket);
ittok2=tk_reg32;
htok2.number=usereg2=retreg;
nexttok();
goto en2;
}
}
}
switch(tok){
case tk_intvar:
sign=1;
case tk_wordvar:
if(htok.number!=0){
do_e_axmath(sign,r32,&ofsstr2);
usereg2=itok.number=0;
}
else{
getintoreg_32(DX,r32,sign,&ofsstr2);
usereg2=itok.number=DX;
}
warningreg(regs[1][itok.number]);
next=FALSE;
ittok2=tk_reg32;
htok2=itok;
}
}
if(next){
ittok2=tok;
htok2=itok;
ibuf2=bufrm;
bufrm=NULL;
hstr2=strinf;
strinf.bufstr=NULL;
nexttok();
}
}
RestoreStack();
}
}
else{ // !=0
if((comparetok>=tk_overflowflag)&&(comparetok<=tk_plusflag)){
ittok=0x70+comparetok-tk_overflowflag;
goto endcomp;
}
htok2.rm=typenumber(vartype);
comparetok=tk_notequal;
ittok2=tk_number;
htok2.number=0;
htok2.flag=0;
}
if(ittok2==tk_number&&htok2.number==0&&(htok2.flag&f_reloc)==0){
if(setzeroflag){
if(comparetok==tk_notequal){
ittok=0x75;
goto endcomp;
}
if(comparetok==tk_equalto){
ittok=0x74;
goto endcomp;
}
}
if(htok.number==CX&&optimizespeed==0){
if(ittok==tk_reg||ittok==tk_reg32){
if(comparetok==tk_notequal)use_cxz=notflag==0?cxnzcompr:cxzcompr;
else if(comparetok==tk_equalto)use_cxz=notflag==TRUE?cxnzcompr:cxzcompr;
}
}
}
en2:
if(ittok>=tk_charvar&&ittok<=tk_floatvar){
if(ofsstr){
int retreg;
razr=getrazr(vartype);
if((retreg=CheckIDZReg(ofsstr,AX,razr))!=NOINREG){
usereg=retreg==SKIPREG?AX:retreg;
if(!((ittok2==tk_reg||ittok2==tk_reg32||ittok2==tk_beg)&&usereg==htok2.number)){
if(razr==r16)ittok=tk_reg;
else if(razr==r32)ittok=tk_reg32;
else ittok=tk_beg;
htok.number=usereg;
if(ibuf){
free(ibuf);
ibuf=NULL;
}
if(hstr.bufstr){
free(hstr.bufstr);
hstr.bufstr=NULL;
}
}
else{
usereg=-1;
}
}
else{
if(ittok==tk_floatvar)ClearReg(AX);
else if(ittok>=tk_intvar&&ittok<tk_floatvar){
switch(ittok2){
case tk_reg:
case tk_reg32:
case tk_number:
case tk_postnumber:
case tk_undefofs:
break;
default:
usereg2=0;
break;
}
}
else{
switch(ittok2){
case tk_reg:
case tk_reg32:
ClearReg(AX);
case tk_number:
case tk_beg:
break;
default:
usereg2=0;
break;
}
}
}
}
}
if(ittok==tk_number&&htok.flag==0&&ittok2==tk_number&&htok2.flag==0){
invertflag=(htok.number!=htok2.number?zerocompr:voidcompr);
useinline=oinline;
return invertflag;
}
if((ittok==tk_number||ittok==tk_postnumber)&&(ittok2==tk_number||ittok2==tk_postnumber))usereg=0;
#ifdef OPTVARCONST
if(comconst){
if(comparetok==tk_equalto||comparetok==tk_notequal){
if(ittok>=tk_charvar&&ittok<=tk_doublevar&&ittok2==tk_number&&
(htok2.flag&f_reloc)==0&&htok.rec&&(htok.flag&f_useidx)==0){
comconst->rec=htok.rec;
comconst->lnumber=htok2.lnumber;
comconst->contype=htok2.rm;
}
else if(ittok2>=tk_charvar&&ittok2<=tk_doublevar&&ittok==tk_number&&
(htok.flag&f_reloc)==0&&htok2.rec&&(htok2.flag&f_useidx)==0){
comconst->rec=htok2.rec;
comconst->lnumber=htok.lnumber;
comconst->contype=htok.rm;
}
comconst->typevar=comparetok;
if(notflag)comconst->typevar=(comparetok==tk_equalto?tk_notequal:tk_equalto);
}
}
#endif
if(outcmp(0,ittok,&htok,ibuf,&hstr,ittok2,&htok2,ibuf2,&hstr2,razr)){
switch(comparetok){
case tk_less: comparetok=tk_greater; break;
case tk_lessequal: comparetok=tk_greaterequal; break;
case tk_greater: comparetok=tk_less; break;
case tk_greaterequal: comparetok=tk_lessequal; break;
}
}
createopcode:
jumptype=0;
if(vartype==tk_char||vartype==tk_int||vartype==tk_long)jumptype=1;
switch(comparetok){
case tk_equalto: ittok=0x74; break;
case tk_notequal: ittok=0x75; break;
case tk_greater:
ittok=(jumptype==0?0x77:0x7F);
break;
case tk_less:
ittok=(jumptype==0?0x72:0x7C);
break;
case tk_greaterequal:
ittok=(jumptype==0?0x73:0x7D);
break;
case tk_lessequal:
ittok=(jumptype==0?0x76:0x7E);
break;
default: unknowncompop(); break;
}
endcomp:
if(ofsstr){
if(usereg!=-1)IDZToReg(ofsstr,usereg,razr);
free(ofsstr);
}
if(ofsstr2){
// printf("usereg2=%08X %s\n",usereg2,ofsstr2);
if(usereg2!=-1)IDZToReg(ofsstr2,usereg2,razr);
free(ofsstr2);
}
if(invertflag==2)invertflag=((outptr+2-startloc)>128?1:0);
ittok^=invertflag;
ittok^=notflag;
op(ittok); /* output instruction code */
expecting(tk_closebracket);
useinline=oinline;
return invertflag|use_cxz;
}
#ifdef OPTVARCONST
ICOMP *compare(int type,unsigned int *numcomp,REGISTERSTAT **bakreg,REGISTERSTAT **changereg,LVIC *comconst)
#else
ICOMP *compare(int type,unsigned int *numcomp,REGISTERSTAT **bakreg,REGISTERSTAT **changereg)
#endif
{
unsigned int i;
ICOMP *icomp;
int j=0;
int ifline=linenumber;
int ptok=tk_oror;
int rcompr;
int useor=FALSE;
REGISTERSTAT *bakregstat=NULL,*changeregstat=NULL;
if(am32)j=2;
icomp=(ICOMP *)MALLOC(sizeof(ICOMP)*MAXIF); //áëîê äëÿ èíôî î ñðàâíåíèÿõ
i=0;
do{
#ifdef OPTVARCONST
if((rcompr=constructcompare(0,outptr,comconst))==voidcompr||rcompr==zerocompr)i=1;
#else
if((rcompr=constructcompare(0,outptr))==voidcompr||rcompr==zerocompr)i=1;
#endif
if(i){
if(rcompr==voidcompr&&ptok==tk_andand){
i=0;
ptok=tok;
}
continue;
}
op(0x03+j);
if(tok!=tk_oror){
JXorJMP();
if(am32!=FALSE)outword(0);
outword(0);
}
(icomp+*numcomp)->loc=outptr;
(icomp+*numcomp)->type=tok;
// (icomp+*numcomp)->use_cxz=rcompr&0xFC;
(*numcomp)++ ;
if(*numcomp==MAXIF){
ManyLogicCompare();
free(icomp);
return NULL;
}
ptok=tok;
/* if(tok!=tk_andand&&tok!=tk_oror&&bakregstat==NULL){
bakregstat=BakRegStat();
changeregstat=BakRegStat();
}*/
}while(tok==tk_oror||tok==tk_andand);
if(tok==tk_closebracket)nexttok();
for(i=0;i<*numcomp;i++){
unsigned long temp=outptr-(icomp+i)->loc;
if((icomp+i)->type==tk_oror){
#ifdef OPTVARCONST
if(comconst)comconst->rec=NULL;
#endif
if(temp>127)CompareOr();
output[(icomp+i)->loc-1]=(unsigned char)temp;
clearregstat();
useor=TRUE;
}
else if(chip>2){
if(am32==FALSE)*(unsigned short *)&output[(icomp+i)->loc-2]=(unsigned short)temp;
else *(unsigned long *)&output[(icomp+i)->loc-4]=(unsigned long)temp;
}
}
if(bakregstat==NULL){
bakregstat=BakRegStat();
changeregstat=BakRegStat();
}
if(type==tk_if&&rcompr!=zerocompr){
if(rcompr==voidcompr)warcompeqconst();
if(tok==tk_return||tok==tk_RETURN){
if(tok2==tk_semicolon||(tok2==tk_openbracket&&ScanTok3()==tk_closebracket)){
if(insertmode||(!optimizespeed)){
if(tok==tk_return||tok==tk_RETURN)goto merge_if;
}
}
startblock();
doreturn(tok);
endblock();
int di;
if(rcompr==voidcompr)di=0;
else di=am32==FALSE?2:4;
for(unsigned int i=0;i<*numcomp;i++){
if((icomp+i)->type!=tk_oror){
if(am32==FALSE)*(unsigned short *)&output[(icomp+i)->loc-di]=(unsigned short)(outptr-(icomp+i)->loc);
else *(unsigned long *)&output[(icomp+i)->loc-di]=(unsigned long)(outptr-(icomp+i)->loc);
}
}
if((outptr-icomp->loc)<=127)warningjmp(mesIF,ifline);
if(tok==tk_else||tok==tk_ELSE){
notunreach=TRUE;
nexttok();
docommand();
}
free(icomp);
return NULL;
}
if(tok==tk_break||tok==tk_BREAK||tok==tk_continue||tok==tk_CONTINUE||tok==tk_goto||tok==tk_GOTO){
merge_if:
if(rcompr==voidcompr)goto endp;
if(chip<3){
for(i=0;i<*numcomp;i++){
if((icomp+i)->type==tk_oror)output[(icomp+i)->loc-1]=(unsigned char)(output[(icomp+i)->loc-1]-3-j);
else{
if((icomp+i)->type!=tk_andand)output[(icomp+i)->loc-5-j]=(unsigned char)(output[(icomp+i)->loc-5-j]^1);
else{
if(am32==FALSE)*(unsigned short *)&output[(icomp+i)->loc-2]=(unsigned short)(outptr-(icomp+i)->loc);
else *(unsigned long *)&output[(icomp+i)->loc-4]=(unsigned long)(outptr-(icomp+i)->loc);
}
}
}
outptr-=3+j;
}
else{
for(i=0;i<*numcomp;i++){
if((icomp+i)->type==tk_oror)output[(icomp+i)->loc-1]=(unsigned char)(output[(icomp+i)->loc-1]-2-j);
else{
if((icomp+i)->type!=tk_andand){
output[(icomp+i)->loc-4-j]=(unsigned char)(output[(icomp+i)->loc-3-j]-0x10);
output[(icomp+i)->loc-3-j]=(unsigned char)(3+j);
}
else{
if(am32==FALSE)*(unsigned short *)&output[(icomp+i)->loc-2]=(unsigned short)(outptr-(icomp+i)->loc+1);
else *(unsigned long *)&output[(icomp+i)->loc-4]=(unsigned long)(outptr-(icomp+i)->loc+1);
}
}
}
outptr-=2+j;
if(cpu<3)cpu=3;
}
int delta=0; //new 07.06.06 20:27
if(tok==tk_break||tok==tk_BREAK){
if(useor==FALSE){
int ooutptr=outptr-2;
int otok=tok;
i=(unsigned char)(output[ooutptr]^1);
outptr--;
if(tok==tk_break)i+=0x10;
else outptr--;
doBREAK((unsigned char)(tok==tk_BREAK?BREAK_SHORT:(am32==FALSE?BREAK_NEAR:BREAK_32)));
if(otok==tk_break){
output[ooutptr]=0x0f;
output[ooutptr+1]=i;
delta=-1;
}
else{
output[ooutptr]=i;
delta=(am32==TRUE?-5:-3);
}
}
else{
if(tok==tk_BREAK){
output[outptr-1]-=(am32==TRUE?3:1);
}
doBREAK((unsigned char)(tok==tk_BREAK?BREAK_SHORT:(am32==FALSE?BREAK_NEAR:BREAK_32)));
}
}
else if(tok==tk_return||tok==tk_RETURN){
//new 07.06.06 21:12
if(useor==FALSE){
int ooutptr=outptr-2;
int otok=tok;
i=(unsigned char)(output[ooutptr]^1);
outptr--;
if(tok==tk_return){
i+=0x10;
}
else outptr--;
AddRetList(outptr+1,linenumber,tok);
if(tok2==tk_openbracket){
nexttok();
nexttok();
}
if(otok==tk_return){
output[ooutptr]=0x0f;
output[ooutptr+1]=i;
delta=-1;
}
else{
output[ooutptr]=i;
delta=(am32==TRUE?-5:-3);
}
}
else{
if(tok==tk_RETURN)output[outptr-1]-=(am32==TRUE?3:1);
AddRetList(outptr+1,linenumber,tok);
if(tok==tk_return&&tok2==tk_openbracket){
nexttok();
nexttok();
}
}
nextseminext();
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
}
else if(tok==tk_goto||tok==tk_GOTO){
int ooutptr=outptr;
if(useor==FALSE){
if(tok==tk_GOTO){
outptr-=2;
i=(unsigned char)(output[outptr]^1);
GOTOdo();
output[outptr-2]=i;
delta=(am32==0?-3:-5);
}
else{
int otok2=tok2;
gotodo();
if(output[ooutptr]==0xEB){ //áûë êîðîòêèé ïåðåõîä
outptr=ooutptr-2;
op(output[outptr]^1);
op(output[ooutptr+1]+2);
delta=(am32==0?-3:-5);
}
else if(am32&&otok2==tk_number){
outptr=ooutptr-2;
i=(unsigned char)((output[outptr]^1)+0x10);
op(0x0f);
op(i);
if(output[outptr]==0xE9)outdword(*(unsigned long *)&output[ooutptr+1]+1);
else outdword(*(unsigned short *)&output[ooutptr+2]);
delta=-1;
}
}
}
else{ // useor
if(tok==tk_goto)gotodo();
else GOTOdo();
if(output[ooutptr]==0xEB){ //áûë êîðîòêèé ïåðåõîä
output[ooutptr-1]-=(am32==TRUE?3:1);
}
}
}
else{
if(useor==FALSE){
int ooutptr=outptr-2;
int otok=tok;
i=(unsigned char)(output[ooutptr]^1);
outptr--;
if(tok==tk_continue)i+=0x10;
else outptr--;
doCONTINUE((unsigned char)(tok==tk_CONTINUE?CONTINUE_SHORT:(am32==FALSE?CONTINUE_NEAR:CONTINUE_32)));
if(otok==tk_continue){
output[ooutptr]=0x0f;
output[ooutptr+1]=i;
delta=-1;
}
else{
output[ooutptr]=i;
delta=(am32==TRUE?-5:-3);
}
}
else{
if(tok==tk_CONTINUE){
output[outptr-1]-=(am32==TRUE?3:1);
}
doCONTINUE((unsigned char)(tok==tk_CONTINUE?CONTINUE_SHORT:(am32==FALSE?CONTINUE_NEAR:CONTINUE_32)));
}
}
for(i=0;i<*numcomp;i++){
// if((icomp+i)->type==tk_oror)output[(icomp+i)->loc-1]+=delta;
// else
if((icomp+i)->type==tk_andand){
if(am32==FALSE)*(signed short *)&output[(icomp+i)->loc-2]+=delta;
else *(signed long *)&output[(icomp+i)->loc-4]+=delta;
}
}
if(tok==tk_else||tok==tk_ELSE){
notunreach=TRUE;
nexttok();
docommand();
}
free(icomp);
return NULL;
}
}
endp:
if(type!=tk_for){
startblock();
if(rcompr==zerocompr)warcompneqconst();
if(tok==tk_openbrace){
if(rcompr==zerocompr){
cha=cha2;
inptr=inptr2;
SkipBlock();
inptr2=inptr;
cha2=cha;
linenum2=linenumber;
nexttok();
}
else{
#ifdef OPTVARCONST
if(comconst&&comconst->rec&&comconst->typevar==tk_equalto){
Const2VarRec(comconst);
}
#endif
doblock();
nexttok();
}
}
else{
if(rcompr==zerocompr){
do{
nexttok();
}while(tok!=tk_semicolon&&tok!=tk_eof);
}
else{
#ifdef OPTVARCONST
if(comconst&&comconst->rec&&comconst->typevar==tk_equalto){
Const2VarRec(comconst);
}
#endif
docommand();
}
}
endblock();
RestoreStack();
}
if(bakreg)*bakreg=bakregstat;
if(changereg)*changereg=changeregstat;
return icomp;
}
void opt_if_else_stop(unsigned int newptr)
{
unsigned int ooutptr,ooutptrdata;
unsigned char instr;
dbgact++;
ooutptr=outptr;
ooutptrdata=outptrdata;
outptr=newptr;
instr=output[outptr];
docommand();
if(output[newptr]==0xEB){
signed char ofs=output[newptr+1];
if(output[newptr-1]==0x0F&&instr>=0x80&&instr<0x90){
ofs--;
if(am32)ofs-=(signed char)2;
}
if(am32)*(long *)&output[newptr+1]=ofs;
else*(short *)&output[newptr+1]=ofs;
}
if(am32&&output[newptr]==0x66&&output[newptr+1]==0xE9){
signed short ofs=(signed short)(*(short *)&output[newptr+2]-1);
*(long *)&output[newptr+1]=ofs;
}
output[newptr]=instr;
outptr=ooutptr;
outptrdata=ooutptrdata;
dbgact--;
}
void doif()
{
unsigned int startloc,elseline,numcomp=0,ifline;
ICOMP *icomp;
REGISTERSTAT *bakregstat=NULL,*changeregstat=NULL;
unsigned int oaddESP=addESP;
ifline=linenumber;
#ifdef OPTVARCONST
LVIC comconst;
comconst.rec=NULL;
icomp=compare(tk_if,&numcomp,&bakregstat,&changeregstat,&comconst);
#else
icomp=compare(tk_if,&numcomp,&bakregstat,&changeregstat);
#endif
// i=CheckStopBlock();
/*-----------------19.08.99 22:35-------------------
Óáèðàòü else ìîæíî òîëüêî ïîñëå ïåðâîãî if
Ïîñëå else if â ñëåäóþùèé else óáèðàòü íåëüçÿ
--------------------------------------------------*/
if(icomp!=NULL){
elseline=linenumber;
unsigned long temp;
unsigned int j=0;
unsigned int otok=tok;
unsigned int oinptr=inptr2;
unsigned char ocha=cha2;
unsigned int oline=linenumber;
if(tok==tk_else||tok==tk_ELSE){
if(dbg)AddLine();
j=(am32==FALSE?3:5);
if(tok2==tk_goto||tok2==tk_break||tok2==tk_continue||//ïîãëîòèòü èõ
tok2==tk_RETURN||tok2==tk_return||tok2==tk_GOTO||tok2==tk_BREAK||tok2==tk_CONTINUE){
nexttok();
switch(tok){
case tk_GOTO: otok=tk_goto; break;
case tk_BREAK: otok=tk_break; break;
case tk_CONTINUE: otok=tk_continue; break;
case tk_return:
case tk_RETURN:
if(tok2==tk_semicolon||(tok2==tk_openbracket&&
ScanTok3()==tk_closebracket)){
startblock();
otok=tk_return;
break;
}
tok=otok; //íåâîçìîæíî îïòèìèçèðîâàòü
inptr2=oinptr;
cha2=ocha;
linenumber=oline;
goto nooptim;
default:otok=tok; break;
}
oinptr=inptr2;
ocha=cha2;
oline=linenumber;
for(unsigned int i=0;i<numcomp;i++){
if((icomp+i)->type!=tk_oror){
notunreach=TRUE;
tok=otok;
inptr2=oinptr;
cha2=ocha;
linenumber=oline;
opt_if_else_stop((icomp+i)->loc-j);
}
}
if(otok==tk_return)endblock();
if((outptr+j-icomp->loc)<=127)warningjmp(mesIF,ifline);
free(icomp);
retproc=FALSE;
lastcommand=tk_if;
return;
}
nooptim:
if(tok==tk_ELSE)j=2;
}
notunreach=TRUE;
for(unsigned int i=0;i<numcomp;i++){
if((icomp+i)->type!=tk_oror){
if(am32==FALSE)*(unsigned short *)&output[(icomp+i)->loc-2]=(unsigned short)(outptr+j-(icomp+i)->loc);
else *(unsigned long *)&output[(icomp+i)->loc-4]=(unsigned long)(outptr+j-(icomp+i)->loc);
}
}
if((outptr+j-icomp->loc)<=127)warningjmp(mesIF,ifline);
switch(lastcommand){
case tk_return:
case tk_RETURN:
case tk_goto:
case tk_GOTO:
case tk_break:
case tk_BREAK:
case tk_continue:
case tk_CONTINUE:
addESP=oaddESP;
break;
}
if(retproc)CopyRegStat(bakregstat);
else{
switch(lastcommand){
case tk_return:
case tk_RETURN:
case tk_goto:
case tk_GOTO:
case tk_break:
case tk_BREAK:
case tk_continue:
case tk_CONTINUE:
CopyRegStat(bakregstat);
break;
default:
CompareRegStat(changeregstat);
break;
}
}
// printf("lastcommand=%d\n",lastcommand);
// CompareRegStat(changeregstat);
if(tok==tk_else/*&&i==FALSE*/){
addESP=oaddESP;
RestoreStack();
CopyRegStat(bakregstat);
jumploc0();
startloc=outptr;
getoperand();
#ifdef OPTVARCONST
if(tok!=tk_if&&tok!=tk_IF&&comconst.rec&&comconst.typevar==tk_notequal){
Const2VarRec(&comconst);
}
#endif
startblock();
if(tok==tk_return||tok==tk_RETURN){
if(dbg)AddLine();
doreturn(tok);
}
else docommand();
endblock();
RestoreStack();
temp=outptr-startloc;
if(temp<=127)warningjmp(mesELSE,elseline);
if(am32==FALSE)*(unsigned short *)&output[startloc-2]=(unsigned short)temp;
else *(unsigned long *)&output[startloc-4]=temp;
CompareRegStat(changeregstat);
}
else if(tok==tk_ELSE/*&&i==FALSE*/){
addESP=oaddESP;
RestoreStack();
CopyRegStat(bakregstat);
outword(0x00EB);
startloc=outptr;
getoperand();
#ifdef OPTVARCONST
if(tok!=tk_if&&tok!=tk_IF&&comconst.rec&&comconst.typevar==tk_notequal){
Const2VarRec(&comconst);
}
#endif
startblock();
if(tok==tk_return||tok==tk_RETURN){
if(dbg)AddLine();
doreturn(tok);
}
else docommand();
endblock();
RestoreStack();
temp=outptr-startloc;
if(temp>127)jumperror(elseline,mesELSE);
output[startloc-1]=(unsigned char)temp;
CompareRegStat(changeregstat);
}
/* else{
if(i!=FALSE&&(tok==tk_else||tok==tk_ELSE))nexttok();
}*/
free(icomp);
CopyRegStat(changeregstat);
}
FreeStat(bakregstat);
FreeStat(changeregstat);
retproc=FALSE;
lastcommand=tk_if;
}
#ifdef OPTVARCONST
ICOMP *bigcompare(int type,unsigned int *numcomp,REGISTERSTAT **bakreg,REGISTERSTAT **changereg,LVIC *comconst)
#else
ICOMP *bigcompare(int type,unsigned int *numcomp,REGISTERSTAT **bakreg,REGISTERSTAT **changereg)
#endif
{
unsigned int ifline;
ICOMP *icomp;
unsigned int i=0;
int j=0;
int ptok=tk_oror;
int rcompr;
int useor=FALSE;
REGISTERSTAT *bakregstat=NULL,*changeregstat=NULL;
if(am32!=FALSE)j=2;
icomp=(ICOMP *)MALLOC(sizeof(ICOMP)*MAXIF); //áëîê äëÿ èíôî î ñðàâíåíèÿõ
ifline=linenumber;
do{
#ifdef OPTVARCONST
if((rcompr=constructcompare(1,outptr,comconst))==voidcompr||rcompr==zerocompr)i=1;
#else
if((rcompr=constructcompare(1,outptr))==voidcompr||rcompr==zerocompr)i=1;
#endif
(icomp+*numcomp)->use_cxz=rcompr&0xFC;
if(i){
if(rcompr==voidcompr&&ptok==tk_andand){
i=0;
ptok=tok;
}
continue;
}
op(0x00);
(icomp+*numcomp)->loc=outptr;
(icomp+*numcomp)->type=tok;
(*numcomp)++;
if(*numcomp==MAXIF){
ManyLogicCompare();
free(icomp);
return NULL;
}
ptok=tok;
/* if(tok==tk_andand&&bakregstat==NULL){
bakregstat=BakRegStat();
changeregstat=BakRegStat();
}*/
}while(tok==tk_oror||tok==tk_andand);
if(tok==tk_closebracket)nexttok();
for(i=0;i<*numcomp;i++){
if(outptr-(icomp+i)->loc>127)CompareOr();
output[(icomp+i)->loc-1]=(unsigned char)(outptr-(icomp+i)->loc);
if((icomp+i)->type==tk_oror){
#ifdef OPTVARCONST
if(comconst)comconst->rec=NULL;
#endif
output[(icomp+i)->loc-2]=(unsigned char)(output[(icomp+i)->loc-2]^1);
clearregstat();
useor=TRUE;
}
}
if(bakregstat==NULL){
bakregstat=BakRegStat();
changeregstat=BakRegStat();
}
if(type==tk_IF&&rcompr!=zerocompr){
if(rcompr==voidcompr)warcompeqconst();
if(tok==tk_return||tok==tk_RETURN){
if(tok2==tk_semicolon||(tok2==tk_openbracket&&ScanTok3()==tk_closebracket)){
if(insertmode||(!optimizespeed)){
if(tok==tk_RETURN)goto merge_if;
else if(chip>2&&(insertmode||(paramsize&&
(current_proc_type&f_typeproc)!=tp_cdecl)))goto merge_if2;
}
}
startblock();
doreturn(tok);
endblock();
for(unsigned int i=0;i<*numcomp;i++){
if((icomp+i)->type!=tk_oror){
if((outptr-(icomp+i)->loc)>127)jumperror(ifline,mesIF);
output[(icomp+i)->loc-1]=(unsigned char)(outptr-(icomp+i)->loc);
}
}
if(tok==tk_else||tok==tk_ELSE){
notunreach=TRUE;
getoperand();
docommand();
}
free(icomp);
return NULL;
}
if(tok==tk_BREAK||tok==tk_CONTINUE||tok==tk_GOTO){
merge_if:
int otok=tok;
for(i=0;i<*numcomp;i++){
unsigned char oldcode;
if(((icomp+i)->type==tk_oror)||((i+1)==*numcomp)){
outptr=(icomp+i)->loc-2;
oldcode=output[outptr];
if(tok==tk_BREAK)MakeBreak(BREAK_SHORT);
else if(tok==tk_RETURN){
AddRetList(outptr+1,ifline,tk_RETURN);
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
}
else if(tok==tk_GOTO){
if((i+1)!=*numcomp){
int optr,ocha,oline;
optr=inptr2;
ocha=cha2;
oline=linenum2;
GOTOdo();
if(outptr!=(icomp+i)->loc)jumperror(oline,"GOTO");
inptr2=optr;
cha2=(unsigned char)ocha;
linenum2=oline;
tok=tk_GOTO;
}
else{
getoperand();
CheckIP();
if(tok==tk_number||tok==tk_interruptproc||tok==tk_proc){
long hnumber;
if(tok==tk_number)hnumber=doconstdwordmath();
else{
hnumber=itok.number;
nexttok();
}
long loc=hnumber-outptr-2;
if(loc>-129&&loc<128){
op((unsigned char)(oldcode^1));
op(loc);
}
else{
loc-=3;
outptr++;
op(am32==0?3:5);
op(0xE9);
if(am32==FALSE)outword(loc);
else{
loc-=2;
outdword(loc);
}
}
seminext();
break;
}
else if(GOTO())nexttok();
seminext();
}
}
else MakeContinue(CONTINUE_SHORT);
if((i+1)==*numcomp)oldcode^=1;
output[outptr-2]=oldcode;
}
}
if(tok==tk_RETURN&&tok2==tk_openbracket){
nexttok();
nexttok();
}
if(otok!=tk_GOTO&&rcompr!=voidcompr)nextseminext();
if(tok==tk_else||tok==tk_ELSE){
notunreach=TRUE;
getoperand();
docommand();
}
free(icomp);
return NULL;
}
if((tok==tk_break||tok==tk_continue||tok==tk_goto)&&chip>2){
merge_if2:
// printf("%s (%u) %s %s tok=%d\n",(startfileinfo+currentfileinfo)->filename,linenumber,itok.name,string,tok);
if(*numcomp==1&&(!(tok==tk_goto&&(tok2==tk_reg||tok2==tk_reg32)))){
outptr-=2;
i=(output[outptr]^1)+0x10;
op(0x0F);
}
if(tok==tk_break)doBREAK((unsigned char)(am32==FALSE?BREAK_NEAR:BREAK_32));
else if(tok==tk_return){
AddRetList(outptr+1,ifline,tk_return);
if(tok2==tk_openbracket){
nexttok();
nexttok();
}
nextseminext();
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
}
else if(tok==tk_goto){
nexttok();
CheckIP();
if((tok==tk_number&&*numcomp==1)||tok==tk_interruptproc||tok==tk_proc){
if(tok==tk_proc&&tok2==tk_openbracket)doanyproc(TRUE);
else{
long hnumber;
if(tok==tk_number)hnumber=doconstdwordmath();
else{
hnumber=itok.number;
nexttok();
}
long loc=hnumber-outptr-2;
if(loc>-130&&loc<127){
outptr--;
op((unsigned char)(i-0x10));
op(loc+1);
seminext();
goto c1;
}
else{
loc--;
op(0xE9);
if(am32==FALSE)outword(loc);
else{
loc-=2;
outdword(loc);
}
}
}
}
else{
if(tok==tk_reg||tok==tk_reg32){
i=outptr;
if(gotol(0))nexttok();
i=outptr-i;
output[outptr-i-1]=(unsigned char)i;
goto c1;
}
if(gotol(0))nexttok();
}
seminext();
}
else doCONTINUE((unsigned char)(am32==FALSE?CONTINUE_NEAR:CONTINUE_32));
if(*numcomp==1)output[outptr-3-j]=(unsigned char)i;
c1:
if(cpu<3)cpu=3;
if(tok==tk_else||tok==tk_ELSE){
notunreach=TRUE;
getoperand();
docommand();
}
if(*numcomp!=1){
for(unsigned int i=0;i<*numcomp;i++){
if((icomp+i)->type!=tk_oror){
if((outptr-(icomp+i)->loc)>127)jumperror(ifline,mesIF);
output[(icomp+i)->loc-1]=(unsigned char)(outptr-(icomp+i)->loc);
}
}
}
free(icomp);
return NULL;
}
}
if((icomp+(*numcomp-1))->use_cxz==cxnzcompr){
outptr-=4;
outword(0xE3);
(icomp+(*numcomp-1))->loc=outptr;
for(i=(*numcomp-1);i!=0;i--){
if((icomp+i-1)->type==tk_oror)output[(icomp+i-1)->loc-1]-=(unsigned char)2;
}
}
if(type!=tk_FOR){
startblock();
if(rcompr==zerocompr)warcompneqconst();
if(tok==tk_openbrace){
if(rcompr==zerocompr){
cha=cha2;
inptr=inptr2;
SkipBlock();
inptr2=inptr;
cha2=cha;
linenum2=linenumber;
nexttok();
}
else{
#ifdef OPTVARCONST
if(comconst&&comconst->rec&&comconst->typevar==tk_equalto)Const2VarRec(comconst);
#endif
doblock();
nexttok();
}
}
else{
if(rcompr==zerocompr){
do{
nexttok();
}while(tok!=tk_semicolon&&tok!=tk_eof);
}
else{
#ifdef OPTVARCONST
if(comconst&&comconst->rec&&comconst->typevar==tk_equalto)Const2VarRec(comconst);
#endif
docommand();
}
}
endblock();
RestoreStack();
}
if(bakreg)*bakreg=bakregstat;
if(changereg)*changereg=changeregstat;
return icomp;
}
void dobigif()
{
unsigned int ifline,numcomp=0,j=0;
ICOMP *icomp;
int ic;
unsigned int oaddESP=addESP;
REGISTERSTAT *bakregstat=NULL,*changeregstat=NULL;
ifline=linenumber;
#ifdef OPTVARCONST
LVIC comconst;
comconst.rec=NULL;
icomp=bigcompare(tk_IF,&numcomp,&bakregstat,&changeregstat,&comconst);
#else
icomp=bigcompare(tk_IF,&numcomp,&bakregstat,&changeregstat);
#endif
if(icomp!=NULL){
unsigned int elseline;
elseline=linenumber;
if(tok==tk_else)j=(am32==FALSE?3:5);
else if(tok==tk_ELSE)j=2;
notunreach=TRUE;
if(dbg)AddLine();
for(unsigned int i=0;i<numcomp;i++){
if((icomp+i)->type!=tk_oror){
if((outptr+j-(icomp+i)->loc)>127)jumperror(ifline,mesIF);
output[(icomp+i)->loc-1]=(unsigned char)(outptr+j-(icomp+i)->loc);
}
}
switch(lastcommand){
case tk_return:
case tk_RETURN:
case tk_goto:
case tk_GOTO:
case tk_break:
case tk_BREAK:
case tk_continue:
case tk_CONTINUE:
addESP=oaddESP;
break;
}
if(retproc)CopyRegStat(bakregstat);
else{
switch(lastcommand){
case tk_return:
case tk_RETURN:
case tk_goto:
case tk_GOTO:
case tk_break:
case tk_BREAK:
case tk_continue:
case tk_CONTINUE:
CopyRegStat(bakregstat);
break;
default:
CompareRegStat(changeregstat);
break;
}
// CompareRegStat(changeregstat);
}
if(tok==tk_else/*&&i==FALSE*/){
addESP=oaddESP;
RestoreStack();
CopyRegStat(bakregstat);
jumploc0();
ic = outptr;
getoperand();
#ifdef OPTVARCONST
if(tok!=tk_if&&tok!=tk_IF&&comconst.rec&&comconst.typevar==tk_notequal)Const2VarRec(&comconst);
#endif
startblock();
if(tok==tk_return||tok==tk_RETURN){
if(dbg)AddLine();
doreturn(tok);
}
else docommand();
endblock();
RestoreStack();
if((outptr-ic)<=127)warningjmp(mesELSE,elseline);
if(am32==FALSE)*(unsigned short *)&output[ic-2]=(unsigned short)(outptr-ic);
else *(unsigned long *)&output[ic-4]=(unsigned long)(outptr-ic);
CompareRegStat(changeregstat);
}
else if(tok==tk_ELSE/*&&ic==FALSE*/){
addESP=oaddESP;
RestoreStack();
CopyRegStat(bakregstat);
outword(0x00EB);
ic=outptr;
getoperand();
#ifdef OPTVARCONST
if(tok!=tk_if&&tok!=tk_IF&&comconst.rec&&comconst.typevar==tk_notequal)Const2VarRec(&comconst);
#endif
startblock();
if(tok==tk_return||tok==tk_RETURN){
if(dbg)AddLine();
doreturn(tok);
}
else docommand();
endblock();
RestoreStack();
if((outptr-ic)>127)jumperror(elseline,mesELSE);
output[ic-1]=(unsigned char)(outptr-ic);
CompareRegStat(changeregstat);
}
free(icomp);
CopyRegStat(changeregstat);
}
FreeStat(bakregstat);
FreeStat(changeregstat);
retproc=FALSE;
lastcommand=tk_IF;
}
void JXorJMP()
{
if(chip<3){
op(0xE9);
}
else{
unsigned char i;
outptr-=2;
i=(unsigned char)((output[outptr]^1)+0x10);
op(0x0F); op(i);
if(cpu<3)cpu=3;
}
}
void dowhile(unsigned int typeb)
{
unsigned int ifline,conloc,numcomp=0;
ICOMP *icomp;
REGISTERSTAT *bakregstat=NULL,*changeregstat=NULL;
uptdbr();
if(AlignCycle)AlignCD(CS,aligncycle);
conloc=outptr;
ifline=linenumber;
if(typeb==tk_while)
#ifdef OPTVARCONST
icomp=compare(typeb,&numcomp,&bakregstat,&changeregstat,NULL);
#else
icomp=compare(typeb,&numcomp,&bakregstat,&changeregstat);
#endif
else
#ifdef OPTVARCONST
icomp=bigcompare(typeb,&numcomp,&bakregstat,&changeregstat,NULL);
#else
icomp=bigcompare(typeb,&numcomp,&bakregstat,&changeregstat);
#endif
SetContinueLabel();
jumploc(conloc);
if(icomp!=NULL){
if(typeb==tk_WHILE){
for(unsigned int i=0;i<numcomp;i++){
if((icomp+i)->type!=tk_oror){
if((outptr-(icomp+i)->loc)>127)jumperror(ifline,mesWHILE);
output[(icomp+i)->loc-1]=(unsigned char)(outptr-(icomp+i)->loc);
}
}
}
else{
for(unsigned int i=0;i<numcomp;i++){
if((icomp+i)->type!=tk_oror){
if(am32==FALSE)*(unsigned short *)&output[(icomp+i)->loc-2]=(unsigned short)(outptr-(icomp+i)->loc);
else *(unsigned long *)&output[(icomp+i)->loc-4]=(unsigned long)(outptr-(icomp+i)->loc);
}
}
if((outptr-icomp->loc)<=127)warningjmp(mesWHILE,ifline);
}
free(icomp);
}
if(retproc){
if(bakregstat)CopyRegStat(bakregstat);
}
else if(changeregstat)CompareRegStat(changeregstat);
if(changeregstat)CopyRegStat(changeregstat);
SetBreakLabel();
if(usebr[curbr]!=0)clearregstat();
FreeStat(bakregstat);
FreeStat(changeregstat);
#ifdef OPTVARCONST
ClearLVIC();
#endif
lastcommand=tk_do;
}
void dowhilefast(unsigned int typeb)
{
unsigned int numcomp=0;
unsigned int startloc,i;
ICOMP *icomp;
ITOK oitok,ostructadr;
SINFO ostr;
unsigned int oldinptr;
int otok,otok2;
char *ostring,*obufrm;
int blinenum,olinenum,oinptr;
char *ostartline,*bstartline;
char ocha,bcha;
int jmptocompr=0;
int rcompr;
unsigned char *oinput;
unsigned int oaddESP=addESP;
ocha=cha2;
oinptr=inptr2;
olinenum=linenumber;
ostartline=startline;
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
do{
nexttok();
if(tok2==tk_openbracket)nexttok();
if(tok2==tk_closebracket){
nexttok();
jmptocompr=1;
break;
}
if(tok2==tk_number){
nexttok();
if(tok2==tk_closebracket){
if(itok.number!=0)jmptocompr=1;
else jmptocompr=2;
nexttok();
break;
}
}
nexttok(); //íåîáõîäèìî äëÿ èçáåæàíèÿ ïðåäóïðåæäåíèÿ î íåèíèöèàëèçèðîâàííîé ïåðåìåííîé
cha=cha2;
inptr=inptr2;
SkipParam();
inptr2=inptr;
cha2=cha;
linenum2=linenumber;
nexttok();
if(typeb==tk_while&&tok==tk_oror&&optimizespeed==0){
cha2=ocha;
inptr2=oinptr;
linenumber=linenum2=olinenum;
startline=ostartline;
dowhile(typeb);
if(ESPloc&&am32&&oaddESP!=addESP)warESP();
return;
}
if(bufrm){
free(bufrm);
bufrm=NULL;
}
if(strinf.bufstr){
free(strinf.bufstr);
strinf.bufstr=NULL;
}
}while(tok==tk_andand||tok==tk_oror);
while(tok==tk_closebracket)nexttok();
if(!jmptocompr){
if(typeb==tk_WHILE)outword(0x00EB); // JMP SHORT
else jumploc0();
}
i=outptr;
if(AlignCycle)AlignCD(CS,aligncycle);
startloc=outptr;
uptdbr();
if(tok!=tk_openbrace){
if(jmptocompr==2){
do{
nexttok();
}while(tok!=tk_semicolon&&tok!=tk_eof);
}
else docommand();
}
else{
if(jmptocompr==2){
cha=cha2;
inptr=inptr2;
SkipBlock();
inptr2=inptr;
cha2=cha;
linenum2=linenumber;
nexttok();
}
else{
startblock();
doblock();
nexttok();
endblock();
}
}
RestoreStack();
if(!jmptocompr){
if(typeb==tk_WHILE){
if(i!=outptr){
if((outptr-i)>127)jumperror(olinenum,mesWHILE);
output[i-1]=(unsigned char)(outptr-i);
}
else{
if(dbg&1)KillLastLine();
outptr-=2;
startloc-=2;
}
}
else{
if(i!=outptr){
if((outptr-i)<=127)warningjmp(mesWHILE,olinenum);
if(am32) *(unsigned long *)&output[i-4]=(unsigned long)(outptr-i);
else *(unsigned short *)&output[i-2]=(unsigned short)(outptr-i);
}
else{
i=3;
if(am32)i+=2;
if(dbg){
KillLastLine();
KillLastLine();
}
outptr-=i;
startloc-=i;
}
}
}
SetContinueLabel();
clearregstat(); //06.09.04 21:56
#ifdef OPTVARCONST
ClearLVIC();
#endif
icomp=(ICOMP *)MALLOC(sizeof(ICOMP)*MAXIF); //áëîê äëÿ èíôî î ñðàâíåíèÿõ
// oitok2=itok2;
ostring=BackString((char *)string);
oldinptr=inptr2;
oinput=input;
bcha=cha2;
otok=tok;
otok2=tok2;
oitok=itok;
ostructadr=structadr;
ostr=strinf;
strinf.bufstr=NULL;
obufrm=bufrm;
int oldendinptr=endinptr;
COM_MOD *tempcurmod=cur_mod;
if(cur_mod)BackMod();
bufrm=NULL;
blinenum=linenum2;
inptr2=oinptr;
cha2=ocha;
linenumber=linenum2=olinenum;
bstartline=startline;
startline=ostartline;
if(dbg)AddLine();
int ptok=tk_oror;
do{
i=0;
#ifdef OPTVARCONST
if((rcompr=constructcompare(2,startloc,NULL))==voidcompr||rcompr==zerocompr)i=1;
#else
if((rcompr=constructcompare(2,startloc))==voidcompr||rcompr==zerocompr)i=1;
#endif
if(i){
if(ptok==tk_andand){
// i=0;
ptok=tok;
}
continue;
}
if((rcompr&1)){;
op(0x03);
if(tok!=tk_andand){
JXorJMP();
if(am32==FALSE)outword(startloc-(outptr+2));
else outdword(startloc-(outptr+4));
}
}
else{
op(startloc-(outptr+1)); /* the small jump */
if(tok==tk_andand)output[outptr-2]=(unsigned char)(output[outptr-2]^1);
}
(icomp+numcomp)->loc=outptr;
(icomp+numcomp)->type=tok;
numcomp++;
if(numcomp==MAXIF){
ManyLogicCompare();
break;
}
ptok=tok;
}while(tok==tk_oror||tok==tk_andand);
if(jmptocompr==1)jumploc(startloc);
startline=bstartline;
strinf=ostr;
inptr2=oldinptr;
input=oinput;
endinptr=oldendinptr;
cha2=bcha;
tok=otok;
itok=oitok;
structadr=ostructadr;
bufrm=obufrm;
tok2=otok2;
cur_mod=tempcurmod;
strcpy((char *)string,ostring);
free(ostring);
linenumber=linenum2=blinenum;
itok2=oitok;
for(i=0;i<numcomp;i++){
if((icomp+i)->type==tk_andand){
if(outptr-(icomp+i)->loc>127)CompareOr();
output[(icomp+i)->loc-1]=(unsigned char)(outptr-(icomp+i)->loc);
}
}
if(rcompr==cxzcompr){
outptr-=4;
op(0xE3);
op(startloc-outptr-1);
for(i=(numcomp-1);i!=0;i--){
if((icomp+i-1)->type==tk_andand)output[(icomp+i-1)->loc-1]-=(unsigned char)2;
}
}
SetBreakLabel();
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
free(icomp);
if(ESPloc&&am32&&oaddESP!=addESP)warESP();
lastcommand=tk_do;
}
void dodo()
{
unsigned int startloc,numcomp=0,i=0;
ICOMP *icomp;
int ptok=tk_oror;
int rcompr;
unsigned int oaddESP=addESP;
nexttok();
if(AlignCycle)AlignCD(CS,aligncycle);
startloc=outptr;
uptdbr();
if(dbg&1)KillLastLine();
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
docommand();
SetContinueLabel();
if(dbg)AddLine();
if(tok!=tk_while)preerror("'while' expected following 'do'");
icomp=(ICOMP *)MALLOC(sizeof(ICOMP)*MAXIF); //áëîê äëÿ èíôî î ñðàâíåíèÿõ
do{
#ifdef OPTVARCONST
if((rcompr=constructcompare(2,startloc,NULL))==voidcompr||rcompr==zerocompr)i=1;
#else
if((rcompr=constructcompare(2,startloc))==voidcompr||rcompr==zerocompr)i=1;
#endif
if(i){
if(ptok==tk_andand){
i=0;
ptok=tok;
}
continue;
}
if((rcompr&1)){;
op(0x03);
if(tok!=tk_andand){
JXorJMP();
if(am32==FALSE)outword(startloc-(outptr+2));
else outdword(startloc-(outptr+4));
}
}
else{
op(startloc-(outptr+1)); /* the small jump */
if(tok==tk_andand)output[outptr-2]=(unsigned char)(output[outptr-2]^1);
}
(icomp+numcomp)->loc=outptr;
(icomp+numcomp)->type=tok;
numcomp++;
if(numcomp==MAXIF){
ManyLogicCompare();
goto end;
}
ptok=tok;
}while(tok==tk_oror||tok==tk_andand);
if(i)jumploc(startloc);
if(tok==tk_closebracket)nexttok();
for(i=0;i<numcomp;i++){
if((icomp+i)->type==tk_andand){
if(outptr-(icomp+i)->loc>127)CompareOr();
output[(icomp+i)->loc-1]=(unsigned char)(outptr-(icomp+i)->loc);
}
}
if(rcompr==cxzcompr){
outptr-=4;
op(0xE3);
op(startloc-outptr-1);
for(i=(numcomp-1);i!=0;i--){
if((icomp+i-1)->type==tk_andand)output[(icomp+i-1)->loc-1]-=(unsigned char)2;
}
}
seminext();
SetBreakLabel();
if(usebr[curbr]!=0||useco[curco]!=0)clearregstat();
end:
#ifdef OPTVARCONST
ClearLVIC();
#endif
free(icomp);
if(ESPloc&&am32&&oaddESP!=addESP)warESP();
lastcommand=tk_do;
}
void dofor(unsigned int typeb)
{
unsigned int ifline,conloc,blinenum,numcomp=0;
unsigned char bcha;
unsigned char COMPARE=FALSE,modif=FALSE;
int i;
unsigned char *buf;
unsigned int oaddESP=addESP;
ICOMP *icomp=NULL;
REGISTERSTAT *bakregstat=NULL,*changeregstat=NULL;
ifline=linenumber;
// printf("start for, curco=%u curbr=%u\n",curco,curbr);
uptdbr();
nexttok();
i=inptr2;
bcha=cha2;
expecting(tk_openbracket); //ïðîâ íà îòêð ñêîáêó
if(tok!=tk_semicolon){ //ÅÑÒÜ ÏÐÅÄÂÀÐÈÒÅËÜÍÛÅ ÓÑÒÀÍÎÂÊÈ
for(;;){ //çàïèñàòü èõ â áóôåð
AddBackBuf(i,bcha);
if(tok==tk_semicolon)break;
if(tok!=tk_camma){
expecting(tk_semicolon);
break;
}
i=inptr2;
bcha=cha2;
nexttok();
}
if(bufrm){
free(bufrm);
bufrm=NULL;
}
if(strinf.bufstr){
free(strinf.bufstr);
strinf.bufstr=NULL;
}
CharToBackBuf('}');
CharToBackBuf(0);
RunBackText(); //âûïîëíèòü åãî
}
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
bcha=cha2;
i=inptr2;
nexttok();
if(AlignCycle)AlignCD(CS,aligncycle);
conloc=outptr; //çàïîìíèòü òî÷êó íà÷àëà öèêëà
if(tok!=tk_semicolon){ //åñëè åñòü óñëîâèå
if(tok!=tk_openbracket){ //åñëè óñëîâèå íà÷èíàåòñÿ íå ñ (
CharToBackBuf('('); //äîáàâèòü åå
COMPARE=TRUE; //è ôëàã óñòàíîâèòü
}
AddBackBuf(i,bcha); //çàïîìíèòü óñëîâèå
if(tok!=tk_semicolon)expected(';');
SizeBackBuf--;
if(COMPARE)CharToBackBuf(')'); //åñëè íàäî, çàêðûòü ñêîáêó
CharToBackBuf(0);
int oendinptr=endinptr;
endinptr=SizeBackBuf-1;//strlen(BackTextBlock);
i=inptr2;
buf=input;
bcha=cha2;
input=(unsigned char *)BackTextBlock;
SizeBackBuf=0;
inptr2=1;
cha2='(';
if(typeb==tk_for)
#ifdef OPTVARCONST
icomp=compare(typeb,&numcomp,&bakregstat,&changeregstat,NULL);
#else
icomp=compare(typeb,&numcomp,&bakregstat,&changeregstat);
#endif
else
#ifdef OPTVARCONST
icomp=bigcompare(typeb,&numcomp,&bakregstat,&changeregstat,NULL);
#else
icomp=bigcompare(typeb,&numcomp,&bakregstat,&changeregstat);
#endif
free(input);
input=buf;
inptr2=i;
cha2=bcha;
endinptr=oendinptr;
COMPARE=TRUE;
nexttok();
}
else{
i=inptr2;
bcha=cha2;
nexttok();
}
if(tok!=tk_closebracket){ //åñòü ìîäèôèêàöèÿ
modif=TRUE;
while(tok!=tk_closebracket){
AddBackBuf(i,bcha);
if(cha==')'||cha==26){
CharToBackBuf(';');
nextchar();
cha2=cha;
inptr2=inptr;
break;
}
if(bufrm){
free(bufrm);
bufrm=NULL;
}
if(strinf.bufstr){
free(strinf.bufstr);
strinf.bufstr=NULL;
}
i=inptr2;
bcha=cha2;
nexttok();
}
CharToBackBuf('}');
CharToBackBuf(0);
buf=(unsigned char *)REALLOC(BackTextBlock,SizeBackBuf);
SizeBackBuf=0;
}
blinenum=linenumber;
nexttok();
///////////////////
if(tok==tk_openbrace){
if(COMPARE&&(icomp+numcomp)->use_cxz==zerocompr){
warcompneqconst();
cha=cha2;
inptr=inptr2;
SkipBlock();
inptr2=inptr;
cha2=cha;
linenum2=linenumber;
nexttok();
}
else{
startblock();
doblock();
nexttok();
endblock();
}
}
else{
if(COMPARE&&(icomp+numcomp)->use_cxz==zerocompr){
warcompneqconst();
do{
nexttok();
}while(tok!=tk_semicolon&&tok!=tk_eof);
}
else docommand();
}
RestoreStack();
SetContinueLabel();
// puts((char *)string2);
// printf("end for, curco=%u curbr=%u\n",curco,curbr);
if(modif){
unsigned int oldlinenum=linenum2;
ITOK oitok;
oitok=itok2;
BackTextBlock=(char *)buf;
linenum2=blinenum;
RunBackText();
linenumber=linenum2=oldlinenum;
itok2=oitok;
}
if(COMPARE==FALSE||(COMPARE&&(icomp+numcomp)->use_cxz!=zerocompr)){
if(COMPARE&&(icomp+numcomp)->use_cxz==voidcompr)warcompeqconst();
jumploc(conloc);//JMP íà íà÷àëî öèêëà
}
if(COMPARE){
for(unsigned int i=0;i<numcomp;i++){
if((icomp+i)->type!=tk_oror){
if(typeb==tk_FOR){
if((outptr-(icomp+i)->loc)>127)jumperror(ifline,mesFOR);
output[(icomp+i)->loc-1]=(unsigned char)(outptr-(icomp+i)->loc);
}
else{
if((outptr-(icomp+i)->loc)<=127)warningjmp(mesFOR,ifline);
if(am32==FALSE)*(unsigned short *)&output[(icomp+i)->loc-2]=(unsigned short)(outptr-(icomp+i)->loc);
else *(unsigned long *)&output[(icomp+i)->loc-4]=(unsigned long)(outptr-(icomp+i)->loc);
}
}
}
free(icomp);
}
if(retproc){
if(bakregstat)CopyRegStat(bakregstat);
}
else if(changeregstat)CompareRegStat(changeregstat);
if(changeregstat)CopyRegStat(changeregstat);
SetBreakLabel();
if(usebr[curbr]!=0||useco[curco]!=0)clearregstat();
FreeStat(bakregstat);
FreeStat(changeregstat);
#ifdef OPTVARCONST
ClearLVIC();
#endif
if(ESPloc&&am32&&oaddESP!=addESP)warESP();
lastcommand=tk_for;
}
void decit(int dectok,ITOK *detok,char *&decbuf,SINFO *dstr)
// outputs code to decrement the given variable one.
{
int vop=0,i=0,razr=r16;
switch(dectok){
case tk_dwordvar:
case tk_longvar:
CheckAllMassiv(decbuf,4,dstr,detok);
op66(r32);
if(cpu<3)cpu=3;
vop=1;
goto l2;
case tk_wordvar:
case tk_intvar: vop=1;
op66(r16);
i=1;
case tk_bytevar:
case tk_charvar:
i++;
CheckAllMassiv(decbuf,i,dstr,detok);
if(vop!=0)op66(r16);
l2:
outseg(detok,2);
op(0xFE + vop);
op(0x08+detok->rm);
outaddress(detok);
break;
case tk_reg32:
if(cpu<3)cpu=3;
razr=r32;
case tk_reg:
op66(razr);
op(0x48+detok->number);
break;
case tk_beg:
op(0xFE);
op(0xC8+detok->number);
break;
default:
preerror(invaliddecrem);
break;
}
}
void uptdbr(/*int usesw*/)
{
listbr[curbr]=numbr; //íîìåð ýòîãî öèêëà
usebr[curbr]=0;
curbr++; //÷èñëî âëîæåíèé
numbr++; //âñåãî öèêëîâ
// if(!usesw){
useco[curco]=0;
curco++;
// }
if(curbr==MAXIN)preerror("to many inside bloks");
}
void doloop(unsigned int typeb) // both short and long loops
{
unsigned int startloc,startloc2;
int looptok;
ITOK lootok;
char *loopbuf;
signed char delta;
SINFO lstr;
int j=0,sline=linenumber;
unsigned int oaddESP=addESP;
nexttok();
// printf("tok=%u name=%s bufrm=%s\n",tok,itok.name,bufrm);
expecting(tk_openbracket);
looptok=tok;
lootok=itok;
loopbuf=bufrm;
bufrm=NULL;
lstr=strinf;
strinf.bufstr=NULL;
// printf("bufrm=%s strinf=%s\n",loopbuf,lstr.bufstr);
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
uptdbr();
if(dbg&1)KillLastLine();
if((tok<tk_charvar||tok>tk_dwordvar)&&tok!=tk_reg&&tok!=tk_reg32
&&tok!=tk_beg&&tok!=tk_closebracket)
preerror(invaliddecrem);
if(tok!=tk_closebracket){
if(typeb!=tk_loop){
if(dbg)AddLine();
int vop=tok==tk_reg?r16:r32;
if(typeb==tk_LOOPNZ&&((tok==tk_reg&&itok.number==CX)||
(tok==tk_reg32&&itok.number==ECX))&&(!(optimizespeed&&chip>3&&chip<7))){
op67(vop);
outword(0xE3);
}
else{
if(tok==tk_reg||tok==tk_reg32||tok==tk_beg){
if(tok==tk_beg)op(0x84);
else{
op66(vop);
op(0x85);
}
op(0xc0+(unsigned int)itok.number*9);
}
else{
ITOK htok2;
htok2.number=0;
htok2.rm=(am32==FALSE?rm_d16:rm_d32);
htok2.segm=DS;
htok2.post=0;
htok2.sib=(am32==FALSE?CODE16:CODE32);
htok2.flag=0;
int razr=r_undef;
switch(tok){
case tk_longvar:
case tk_dwordvar:
razr=2;
case tk_intvar:
case tk_wordvar:
razr++;
case tk_charvar:
case tk_bytevar:
razr++;
}
outcmp(0,tok,&itok,bufrm,&strinf,tk_number,&htok2,loopbuf,&lstr,razr);
}
if(typeb==tk_LOOPNZ)outword(0x74);
else{
if(chip<3){
outword(0x0375); // JNZ past jump up
op(0xE9);
}
else{
outword(0x840F);
}
outword(0);
if(am32!=FALSE)outword(0);
}
}
}
nexttok(); //òî ÷òî óìåíüøàåòñÿ
}
expecting(tk_closebracket);
startloc2=outptr;
if(AlignCycle)AlignCD(CS,aligncycle);
startloc=outptr;
docommand();
RestoreStack();
SetContinueLabel();
if(looptok!=tk_closebracket){
if(((outptr-startloc)<=(127-3))&&(chip<3||optimizespeed==0)&&
((looptok==tk_reg&&lootok.number==CX)||(looptok==tk_reg32&&lootok.number==ECX))){
delta=(char)(startloc-(outptr+2));
if(op67(looptok==tk_reg?r16:r32)!=FALSE)delta--;
op(0xE2);
op(delta); /* LOOP 'delta' */
}
else{
decit(looptok,&lootok,loopbuf,&lstr);
if((outptr-startloc)>(unsigned int)(127-2-j)){ /* long jump */
if(chip<3){
outword(0x0374); // JZ past jump up
op(0xE9);
} /* JMP top of loop */
else{
outword(0x850F);
if(cpu<3)cpu=3;
}
if(am32==FALSE)outword(startloc-(outptr+2));
else outdword(startloc-(outptr+4));
}
else{
op(0x75); // short jump
op(startloc-(outptr+1));
} /* JNZ 'delta' */
}
}
else jumploc(startloc);//JMP íà íà÷àëî öèêëà
if(typeb!=tk_loop){
looptok=outptr-startloc2;
if(typeb==tk_LOOPNZ){
if(looptok>127)jumperror(sline,mesLOOPNZ);
output[startloc2-1]=(unsigned char)looptok;
}
else{
if(looptok<=127)warningjmp(mesLOOPNZ,sline);
if(am32==FALSE)*(unsigned short *)&output[startloc2-2]=(unsigned short)looptok;
else *(unsigned long *)&output[startloc2-4]=(unsigned long)looptok;
}
}
SetBreakLabel();
if(usebr[curbr]!=0||useco[curco]!=0||typeb!=tk_loop)clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
if(ESPloc&&am32&&oaddESP!=addESP)warESP();
lastcommand=tk_loop;
}
void GetNameLabel(int type,int num)
{
sprintf((char *)string2,type==tk_break?"BREAK%04X":"CONTINUE%04X",listbr[num]);
}
void SetBreakLabel()
{
curbr--;
if(usebr[curbr]!=0){
GetNameLabel(tk_break,curbr);
updatecall((unsigned int)updatelocalvar((char *)string2,tk_number,outptr),outptr,procedure_start);
// clearregstat();
}
}
void SetContinueLabel()
{
curco--;
if(useco[curco]!=0){
GetNameLabel(tk_continue,curco);
updatecall((unsigned int)updatelocalvar((char *)string2,tk_number,outptr),outptr,procedure_start);
}
}
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
void SaveDataVal(unsigned int ssize,unsigned long long val)
{
switch(ssize){
case 1: opd(val); break;
case 2: outwordd(val); break;
case 4: outdwordd(val); break;
case 8: outqwordd(val); break;
}
}
long AddVarString()
{
long loop=0;
int term;
do{
term=itok.flag;
for(int i=0;i<itok.number;i++){ //ââåñòè ñòðîêó
opd(string[i]);
loop++;
}
nexttok();
}while(tok==tk_string);
switch(term&3){
case zero_term:
if(term&s_unicod)opd(0);
opd(0);
loop++;
break;
case dos_term:
if(term&s_unicod)opd(0);
opd('$');
loop++;
break;
}
return loop;
}
long initglobalvar(int type,long elements,long ssize,char typev)
{
long loop;
long long i=0;
int htok;
char name[IDLENGTH];
nexttok();
loop=0;
if(dbg&2)AddDataLine((tok==tk_string&&typev!=pointer?(char)3:(char)ssize));
loopsw:
htok=tok;
switch(tok){ //çàïîëíèòü âåëè÷èíàìè
case tk_apioffset: AddApiToPost(itok.number); nexttok(); break;
case tk_postnumber:
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
itok.flag=0;
goto cn1;
case tk_undefofs:
strcpy(name,itok.name);
// AddUndefOff(1,itok.name);
cn1:
tok=tk_number;
case tk_minus:
case tk_number:
if(type==tk_byte||type==tk_word||type==tk_dword)i+=doconstdwordmath();
else if(type==tk_float)i=doconstfloatmath();
else if(type==tk_double)i=doconstdoublemath();
else if(type==tk_qword)i+=doconstqwordmath();
else i+=doconstlongmath();
if(tok==tk_plus&&tok2==tk_postnumber&&htok!=tk_undefofs){
nexttok();
goto loopsw;
}
if(elements!=0){
for(;loop<elements;loop++){
if(postnumflag&f_reloc)AddReloc();
if(htok==tk_undefofs)AddUndefOff(3,name);
SaveDataVal(ssize,i);
}
}
loop=loop*ssize;
break;
case tk_string:
if(typev==pointer){
loop=(am32==FALSE?2:4);
i=addpoststring(DS);
if(am32==FALSE)outwordd(i);
else outdwordd(i);
nexttok();
}
else{
loop=AddVarString();
if(elements!=0){
for(;loop<ssize*elements;loop++){//äîïîëíèòü 0 åñëè êîðîòêàÿ
opd(aligner);
}
}
}
break;
case tk_from: //ñ÷èòàòü ôàéë ñ äàííûìè
nexttok();
loop=dofrom();
if(elements!=0){
for(;loop<ssize*elements;loop++)opd(aligner);
}
nexttok();
break;
case tk_extract: //ñ÷èòàòü ôðàãìåíò ôàéëà ñ äàííûìè
nexttok();
loop=doextract();
if(elements!=0){
for(;loop<ssize*elements;loop++)opd(aligner);
}
break;
case tk_openbrace: //ìàññèâ äàííûõ
nexttok();
while(tok!=tk_closebrace){
htok=tok;
if(typev==pointer){
if(tok==tk_string){
i=addpoststring(DS);
nexttok();
}
else if(tok==tk_number||tok==tk_minus||tok==tk_undefofs){
if(tok==tk_undefofs){
tok=tk_number;
strcpy(name,itok.name);
// AddUndefOff(1,itok.name);
}
// else if((itok.flag&f_reloc)!=0)AddReloc();
i=doconstdwordmath();
}
else{
numexpected();
nexttok();
}
if(postnumflag&f_reloc)AddReloc();
if(htok==tk_undefofs)AddUndefOff(3,name);
if(am32==FALSE)outwordd(i);
else outdwordd(i);
}
else{
switch(tok){
case tk_apioffset: AddApiToPost(itok.number); nexttok(); break;
case tk_string:
loop+=AddVarString()/ssize-1;
break;
case tk_postnumber:
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
itok.flag=0;
goto cn2;
case tk_undefofs:
strcpy(name,itok.name);
// AddUndefOff(1,itok.name);
cn2:
tok=tk_number;
case tk_number:
case tk_minus:
if(type==tk_byte||type==tk_word||type==tk_dword)i=doconstdwordmath();
else if(type==tk_float)i=doconstfloatmath();
else if(type==tk_double)i=doconstdoublemath();
else if(type==tk_qword)i=doconstqwordmath();
else i=doconstlongmath();
// if((postnumflag&f_reloc)!=0)AddReloc();
if((postnumflag&f_reloc)!=0)AddReloc();
if(htok==tk_undefofs)AddUndefOff(3,name);
SaveDataVal(ssize,i);
break;
default:
numexpected();
nexttok();
break;
}
}
loop++;
if(tok==tk_closebrace)break;
expecting(tk_camma);
}
if(elements!=0){
for(;loop<elements;loop++)SaveDataVal(ssize,aligner);
}
loop=loop*ssize;
nexttok();
break;
default:
// printf("tok=%d\n",tok);
numexpected(); nexttok(); break;
}
return loop;
}
void AddPostData(unsigned int loop)
{
if(dynamic_flag==0){
unsigned int longpostsize=loop+postsize;
if(am32==FALSE&&longpostsize>0xFFFFL)tobigpost();
else postsize=longpostsize;
}
}
void labelindata()
{
//idrec *varrec;
FindOff((unsigned char *)itok.name,DS);
tok=tk_number;
itok.number=outptrdata;
itok.segm=DS;
string[0]=0;
if(FixUp)itok.flag=f_reloc;
/*varrec=*/addtotree(itok.name);
/*varrec->count=*/FindOff((unsigned char *)itok.name,DS);
nexttok();
nexttok();
}
void globalvar() /* both initialized and unitialized combined */
{
long size,loop,i,elements,ssize;
char done=0,typev;
char var_name[IDLENGTH];
int type=itok.rm,typebak; //òèï ïåðåìåííîé
unsigned int flag,fflag=itok.flag,dynamic;
unsigned int npointr=itok.npointr;
int count;
idrec *varrec;
size=typesize(type); //ðàçìåð ïåðåìåííîé
if(FixUp)fflag|=f_reloc;
typebak=type;
while(tok!=tk_eof&&done==0){
int nnpointr=0;
typev=variable;
ssize=size;
flag=fflag;
type=typebak;
// printf("type=%d\n",type);
if(tok==tk_far){
flag|=f_far;
nexttok();
}
while(tok==tk_mult){ //óêàçàòåëü
npointr++;
nexttok();
}
if(tok==tk_openbracket){
nexttok();
while(tok==tk_mult){ //óêàçàòåëü íà ïðîöåäóðó
nnpointr++;
nexttok();
}
}
if(npointr){
if((flag&f_far)!=0||am32!=FALSE)ssize=4;
else ssize=2;
typev=pointer;
type=am32==FALSE?tk_word:tk_dword;
}
// printf("tok=%d %s\n",tok,itok.name);
switch(tok){
case tk_id:
case tk_ID:
if(tok2==tk_openbracket||nnpointr){
if(npointr)type=am32==FALSE?tk_word:tk_dword;
declare_procedure(flag,type,nnpointr);
break;
}
strcpy(var_name,itok.name); //èìÿ ïåðåìåííîé
elements=1;
nexttok();
if(tok==tk_openblock){ //[
nexttok();
if(tok==tk_closeblock){//íåèçâåñòíîå ÷èñëî ýëåìåíòîâ
elements=0;
nexttok();
}
else{
CheckMinusNum();
if(tok!=tk_number){
numexpected();
nexttok();
}
else{
elements=doconstlongmath(); //÷èñëî ýëåìåíòîâ
expecting(tk_closeblock);
}
}
}
if(type==tk_void){
preerror("type 'void' not use for declare variables");
break;
}
dynamic=FALSE;
if(tok==tk_assign||(notpost==TRUE&&dynamic_flag==0)){ //= èíèöèàëèçèðîâàíàÿ ïåðåìåííàÿ
if((flag&f_extern))preerror("extern variable do not initialize at declare");
i=tok;
itok.type=tp_gvar;// 11.07.05 21:56 tp_ucnovn;
SetNewTok(type,typev);
if(useStartup==TRUE&&i!=tk_assign&&SaveStartUp(size*elements,var_name)!=FALSE){
if(elements==0)ZeroMassiv(); //îøèáêà
tok=i;
break;
}
if(alignword&&ssize&&(!dynamic_flag))alignersize+=AlignCD(DS,ssize);
itok.number=dynamic_flag==0?outptrdata:0;
itok.segm=(comfile==file_rom&&modelmem==TINY?CS:DS);
itok.flag=flag;
// itok.post=dynamic;
itok.size=elements*ssize;
itok.rm=(am32==FALSE?rm_d16:rm_d32);
itok.npointr=(unsigned short)npointr;
varrec=addtotree(var_name);
if((count=FindOff((unsigned char *)var_name,DS))==0){
if(dynamic_flag)dynamic=DYNAMIC_VAR;
}
else if(dynamic_flag)dynamic=USED_DIN_VAR;
if(i!=tk_assign){
if(elements==0)ZeroMassiv();
else if(notpost==TRUE){
for(loop=0;loop<elements;loop++)SaveDataVal(ssize,aligner);
loop=loop*ssize;
varrec->recsize=loop;
datasize+=loop;
}
tok=i;
break;
}
if(dynamic){
varrec->sbuf=dynamic_var();
varrec->recpost=dynamic;
}
else{
loop=initglobalvar(type,elements,ssize,typev);
varrec->recsize=loop;
datasize+=loop;
}
varrec->count=count;
}
else{
if(elements==0){
ZeroMassiv();
break;
}
if(CheckUseAsUndef((unsigned char *)var_name)==0&&dynamic_flag)dynamic=TRUE;
switch(tok){ //íåèíèöèàëèçèðîâàííûå
default: expected(';');
case tk_semicolon: done=1;// ;
case tk_camma: //, post global type
itok.type=tp_postvar;//11.07.05 21:57 tp_ucnovn;
SetNewTok(type,typev);
if((flag&f_extern)==0&&useStartup==TRUE&&dynamic==0){
if(SaveStartUp(ssize*elements,var_name)!=FALSE){
nexttok();
break;
}
}
if((flag&f_extern)==0&&alignword&&dynamic==0){ //âûðîâíÿòü íà ÷åòíûé àäðåñ
if(ssize==2){
if(postsize%2==1)postsize++;
}
else if(ssize==4&&postsize%4!=0)postsize+=4-(postsize%4);
}
count=FindOff((unsigned char *)var_name,VARPOST);
itok.post=dynamic+1;
itok.segm=DS;
loop=elements*ssize;
itok.number=(flag&f_extern)==0?postsize:externnum++;
itok.flag=flag;
itok.size=loop;
itok.rm=(am32==FALSE?rm_d16:rm_d32);
itok.npointr=(unsigned short)npointr;
varrec=addtotree(var_name);
varrec->count=count;
if((flag&f_extern)==0)AddPostData(loop);
nexttok();
break;
}
}
break;
case tk_undefproc:
if(tok2==tk_openbracket||nnpointr){
if(npointr)type=am32==FALSE?tk_word:tk_dword;
declare_procedure(flag,type,nnpointr);
break;
}
case tk_proc:
case tk_floatvar:
case tk_dwordvar:
case tk_longvar:
case tk_charvar:
case tk_intvar:
case tk_bytevar:
case tk_pointer:
case tk_wordvar: idalreadydefined(); nexttok(); break;
default: expected(';');
case tk_semicolon: done=1;
case tk_camma: nexttok(); break;
}
npointr=0;
}
dopoststrings();
}
void SetNewTok(int type,int typev)
{
switch(typev){
case variable:
if(type>=tk_char&&type<=tk_double)tok=type+(tk_charvar-tk_char);
break;
case pointer:
// if(type>=tk_void&&type<=tk_float){
tok=tk_pointer;
itok.type=(unsigned short)type;
// }
break;
}
}
int SaveStartUp(int size,char *var_name)
{
int i=0;
if((startStartup+size)<=endStartup){
if(alignword){ //âûðîâíÿòü íà ÷åòíûé àäðåñ
if(size==2){
if(startStartup%2==1)i=1;
}
else if(size==4&&startStartup%4!=0)i=4-(startStartup%4);
}
if((startStartup+size+i)<=endStartup){
startStartup+=i;
itok.number=startStartup;
itok.segm=DS;
itok.flag=0;
itok.post=0;
itok.rm=(am32==FALSE?rm_d16:rm_d32);
itok.type=tp_ucnovn;
addtotree(var_name);
startStartup+=size;
return TRUE;
}
}
return FALSE;
}
/* ======= ñòàðò çàãîëîâêà ïðîöåäóðû ======== */
void setuprm()
{
itok.rm=returntype=(itok.rm==tokens?am32==FALSE?tk_word:tk_dword:itok.rm);
if(itok.npointr)itok.rm=returntype=(am32==FALSE?tk_word:tk_dword);
}
void eaxToFloat(int reg=AX)
{
int next=1;
CheckMinusNum();
if(itok2.type==tp_opperand){ //ñîñòàâíîå
doeaxfloatmath(tk_reg32,reg);
next=0;
}
else{
switch(tok){
case tk_number:
if(itok.rm==tk_double)itok.fnumber=itok.dnumber;
else if(itok.rm!=tk_float){
float temp=itok.number;
*(float *)&itok.number=temp;
}
op66(r32);
op(0xb8+reg); // MOV EAX,#
outdword(itok.number);
break;
case tk_floatvar:
if(reg==AX&&itok.rm==rm_d16&&itok.sib==CODE16){
op66(r32);
outseg(&itok,1);
op(0xA1);
outword((unsigned int)itok.number);
}
else{
CheckAllMassiv(bufrm,4,&strinf);
op66(r32);
outseg(&itok,2);
op(0x8B);
op(itok.rm+reg*8);
outaddress(&itok);
}
break;
default:
if(doeaxfloatmath(tk_reg32,reg)!=tk_reg32&&reg!=AX){
if(!am32)Leave();
op66(r32);
op(0x89);
op(0xc0+reg);
}
next=0;
}
}
if(next)nexttok();
}
void CalcRegPar(int reg,int def,char **ofsstr)
{
char signflag=0;
int razr;
unsigned char oinline=useinline;
useinline=0;
// if(*ofsstr)puts(*ofsstr);
if(tok!=tk_camma){
if(tok==tk_openbracket){
nexttok();
if(tok>=tk_char&&tok<=tk_double)def=tok;
nexttok();
expectingoperand(tk_closebracket);
}
if(tok>=tk_char&&tok<=tk_double){
def=tok;
getoperand();
}
if(tok==tk_string){
op(0xB8+reg);
if(am32==FALSE)outword(addpoststring());
else outdword(addpoststring());
nexttok();
razr=(am32==FALSE?r16:r32);
}
else if(tok==tk_floatvar)eaxToFloat(reg);
else{
switch(def){
case tk_int: signflag=1;
case tk_word:
if(reg==AX)do_e_axmath(signflag,r16,ofsstr);
else getintoreg(reg,r16,signflag,ofsstr);
razr=r16;
break;
case tk_char: signflag=1;
case tk_byte:
if(reg==AX)doalmath(signflag,ofsstr);
else{
getintobeg(reg,ofsstr);
dobegmath(reg);
}
razr=r8;
break;
case tk_long: signflag=1;
case tk_dword:
if(reg==AX)do_e_axmath(signflag,r32,ofsstr);
else getintoreg(reg,r32,signflag,ofsstr);
razr=r32;
break;
case tk_float:
eaxToFloat(reg);
razr=r32;
break;
case tk_qword:
getintoreg64(reg);
doregmath64(reg);
razr=r64;
break;
case tokens:
razr=(am32==FALSE?r16:r32);
if(reg==AX)do_e_axmath(0,razr,ofsstr);
else getintoreg(reg,razr,signflag,ofsstr);
break;
}
}
AddRegistr(razr,reg);
// printf("%08X\n",reg);
}
useinline=oinline;
}
int GetTypeParam(char c)
{
switch(c){
case 'B': return tk_byte;
case 'W': return tk_word;
case 'D': return tk_dword;
case 'C': return tk_char;
case 'I': return tk_int;
case 'L': return tk_long;
case 'F': return tk_float;
case 'A': return tk_multipoint;
case 'Q': return tk_qword;
case 'E': return tk_double;
case 'S': return tk_fpust;
case 'T': return tk_struct;
case 'U': return tokens;
default:
extraparam();
// printf("%c\n",c);
return 0;
}
}
void doregparams()
{
int i=0;
char *ofsstr=NULL;
int razr;
int retreg;
ClearRegister();
if(tok!=tk_openbracket)expected('(');
while(tok2==tk_camma){
nexttok();
i++;
}
ofsstr=GetLecsem(tk_camma,tk_closebracket);
getoperand();
if(tok!=tk_closebracket){
if(strlen(param)!=0){
int def;
char *oparam=BackString(param);
for(;;){
while(tok==tk_camma){
if(ofsstr)free(ofsstr);
ofsstr=GetLecsem(tk_camma,tk_closebracket);
getoperand();
}
if((def=GetTypeParam(oparam[i++]))==0){
nexttok();
break;
}
if(def==tk_qword){
int c1,c2;
c1=oparam[i++]-0x30;
c2=oparam[i++]-0x30;
retreg=c1|(c2*256);
// printf("%08X\n",retreg);
}
else retreg=oparam[i++]-0x30;
if(ofsstr){
if((razr=getrazr(def))!=r64){
int retr;
if((retr=CheckIDZReg(ofsstr,retreg,razr))!=NOINREG){
GetEndLex(tk_camma,tk_closebracket);
if(retr!=SKIPREG)GenRegToReg(retreg,retr,razr);
nexttok();
goto endparam;
}
}
}
if(def==tk_fpust)float2stack(retreg);
else CalcRegPar(retreg,def,&ofsstr);
endparam:
if(ofsstr&&razr!=r64){
IDZToReg(ofsstr,retreg,razr);
free(ofsstr);
ofsstr=NULL;
}
if(tok!=tk_camma){
if(tok!=tk_closebracket)expected(')');
if(oparam[i]!=0)missingpar();
break;
}
}
free(oparam);
}
else{
char regpar[6]={AX,BX,CX,DX,DI,SI};
for(;i<6;i++){
if(tok==tk_camma){
if(ofsstr)free(ofsstr);
ofsstr=GetLecsem(tk_camma,tk_closebracket);
getoperand();
if(tok==tk_camma)continue;
}
retreg=regpar[i];
if(ofsstr&&tok!=tk_camma){
razr=(am32==FALSE?r16:r32);
int retr;
if((retr=CheckIDZReg(ofsstr,retreg,razr))!=NOINREG){
GetEndLex(tk_camma,tk_closebracket);
if(retr!=SKIPREG)GenRegToReg(retreg,retr,razr);
nexttok();
goto endparam1;
}
}
CalcRegPar(retreg,tokens,&ofsstr);
endparam1:
if(ofsstr){
IDZToReg(ofsstr,retreg,razr);
free(ofsstr);
ofsstr=NULL;
}
if(tok!=tk_camma){
if(tok!=tk_closebracket)expected(')');
break;
}
}
}
setzeroflag=FALSE;
}
if(ofsstr)free(ofsstr);
}
int CheckUses()
{
int i;
int regs=0;
int bracket=FALSE;
memset((SAVEREG *)psavereg,0,sizeof(SAVEREG));
if(tok==tk_openbracket){
if(stricmp(itok2.name,"uses")==0){
bracket=TRUE;
nexttok();
}
else return 0;
}
if(stricmp(itok.name,"uses")==0){
nexttok();
while(tok==tk_reg32||tok==tk_reg||tok==tk_beg){
i=r32;
switch(tok){
case tk_beg:
if(itok.number>3)itok.number-=4;
i=(am32+1)*2;
break;
case tk_reg:
if(!am32)i=r16;
break;
}
regs=regs|(1<<itok.number);
psavereg->reg[itok.number]=i;
i=1;
if((am32&&i==r16)||(am32==0&&i==r32))i=2;
psavereg->size+=i;
nexttok();
if(tok==tk_camma)nexttok();
}
if(strcmp(itok.name,"allregs")==0){
psavereg->size=1;
psavereg->all=1;
regs=dEAX|dEBX|dECX|dEDX|dEBP|dEDI|dESI;
nexttok();
}
}
if(bracket)expecting(tk_closebracket);
return regs;
}
void Enter()
{
if(ESPloc==FALSE||am32==FALSE){
op(0x55); //push bp
outword(0xe589);//mov bp,sp
}
}
void setproc(int defflag)
{
char *bstring;
unsigned char oinline,ooptimizespeed;
ITOK otok;
unsigned int i;
int regs=0;
unsigned char oESPloc=ESPloc;
int startline=linenumber;
unsigned int oregidx;
clearregstat();
addESP=inlineflag=0;
oinline=useinline;
ooptimizespeed=optimizespeed;
oregidx=*(unsigned int *)&idxregs;
current_proc_type=itok.flag;
if(itok.flag&f_extern)notexternfun(); //new 18.04.07 12:20
// printf("%s tok=%d flag=%08X\n",itok.name,tok,itok.flag);
tok=lastcommand=tk_proc;
itok.number=outptr;
if(itok.segm<NOT_DYNAMIC)itok.segm=DYNAMIC_SET;
setuprm();
// printf("rm=%d %s\n",itok.rm,itok.name);
if(defflag){ //ðàíåå óæå áûëè âûçîâû
// updatecall(updatetree(),(unsigned int)itok.number,0);
regs=itok.post;
if(updatecall(updatetree(),(unsigned int)itok.number,0)==-1&&
strcmp(itok.name,mesmain)==0/*&&jumptomain!=CALL_NONE*/){
itok.number=outptr=outptr-(jumptomain==CALL_SHORT?2:am32==FALSE?3:5);
if(dbg){
KillLastLine();
KillLastLine();
AddLine();
}
updatetree();
}
}
else{ //èíà÷å äîáàâèòü â äåðåâî
string[0]=0;
itok.type=tp_ucnovn;
addtotree(itok.name);
}
// puts(itok.name);
if((i=FindOff((unsigned char *)itok.name,CS))!=0){
itok.rec->count=i;
}
bstring=BackString((char *)string);
otok=itok;
if(strcmp(mesmain,otok.name)==0){
if(startuptomain==TRUE&&comfile==file_com)doprestuff();
if(numdomain!=0){
for(i=0;i<numdomain;i++){
strcpy(itok.name,domain+i*IDLENGTH);
tok=tk_ID;
searchvar(itok.name,0);
switch(tok){
case tk_ID:
case tk_id:
tobedefined(am32==FALSE?CALL_NEAR:CALL_32,tk_void);
(postbuf+posts-1)->loc=outptr+1;
callloc0(); /* produce CALL [#] */
break;
case tk_declare:
tok=tk_undefproc;
updatetree();
case tk_undefproc:
addacall(itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32!=FALSE?CALL_32:CALL_NEAR)));
callloc0(); /* produce CALL [#] */
break;
case tk_proc:
if(itok.flag&f_far)op(0x0e); //push cs
if(itok.segm<NOT_DYNAMIC){
addacall(itok.number,(unsigned char)(am32!=FALSE?CALL_32:CALL_NEAR));
itok.number=0;
}
callloc(itok.number);
break;
default:
preerror("impossible type for startup function");
break;
}
}
numdomain=0;
free(domain);
}
}
nextexpecting2(tk_openbracket);
startblock();
if(searchteg&&(!(current_proc_type&f_static))&&(current_proc_type&f_typeproc)!=tp_pascal)AddThis();
if(tok!=tk_closebracket){
if((current_proc_type&f_typeproc)!=tp_fastcall){
declareparams();
if(otok.type==tp_declare&&defflag&&strcmp(bstring,param)!=0){
// printf("old=%s new=%s\n",bstring,param);
redeclare(otok.name);
}
// if(bstring[0]!=0&&bstring[0]!='A'&&strcmp(bstring,param)!=0)redeclare();
}
else{
declareparamreg();
}
if(bstring)free(bstring);
bstring=BackString((char *)param);
}
else if((current_proc_type&f_typeproc)!=tp_fastcall&&bstring[0]!=0){
if(bstring[0]!='V'&&bstring[0]!='A'){
redeclare(otok.name);
// puts(bstring);
}
}
strcpy((char *)string,bstring);
itok=otok;
tok=tk_proc;
updatetree();
if(searchteg&&(!(current_proc_type&f_static))&&(current_proc_type&f_typeproc)==tp_pascal)AddThis();
nexttok();
blockproc=TRUE;
// printf("tok=%d\n",tok);
if(tok==tk_inline){
inlineflag=1;
nexttok();
}
else if(paramsize)Enter(); // PUSH BP MOV BP,SP
if(tok==tk_colon&&(current_proc_type&fs_constructor)!=0){
do{
AddBackBuf(inptr2,cha2);
}while(tok==tk_camma);
nexttok();
}
regs|=CheckUses();
CorrectParamVar();
if(tok!=tk_openbrace)declarelocals(0,inlineflag);
#ifdef OPTVARCONST
ClearLVIC();
#endif
// numblocks++; //íà ýòîì ìåñòå äëÿ ðàíåãî îïðåäåëåíèÿ ::var
expecting(tk_openbrace);
declarelocals(1,inlineflag);
retproc=FALSE;
if(paramsize||localsize/*||(lstructlist!=NULL)*/){
initBP=1;
if(inlineflag)warninline();
}
#ifdef __NEWLEX__
doblockstart(otok.name);
#endif
doblock2(); // do proc
if(current_proc_type&fs_destructor){
elementteg *bazael=searchteg->baza;
for(i=0;i<searchteg->numoper;i++){
if((bazael+i)->tok==tk_baseclass)CallDestructor((structteg *)(bazael+i)->rec);
}
}
i=numreturn;
setreturn();
if(inlineflag==0&&retproc==FALSE&&(i||(lastcommand!=tk_goto&&lastcommand!=tk_GOTO)))leaveproc();
endblock();
initBP=0;
strcpy((char *)string,bstring);
itok=otok;
tok=tk_proc;
itok.size=outptr-procedure_start;
itok.rec->recpost=regs;
// printf("reg=%08X set=%s\n",regs,itok.name);
#ifdef OPTVARCONST
if(inlineflag)itok.flag|=f_useidx;
#endif
updatetree();
if(mapfile)mapfun(startline);
i=linenumber;
linenumber=startline;
killlocals();
linenumber=i;
free(bstring);
optimizespeed=ooptimizespeed;
useinline=oinline;
*(unsigned int *)&idxregs=oregidx;
if(searchteg)searchteg=NULL;
blockproc=FALSE;
ESPloc=oESPloc;
nexttok();
}
void insertproc(/*int sizepar*/)
{
unsigned char oinline,ooptimizespeed;
struct treelocalrec *otlr;
struct structteg *olteglist;
//struct idrec *olstructlist;
struct idrec *rec;
unsigned int oparamsize;
unsigned int olocalsize;
unsigned char oinsertmode;
unsigned int onumblocks; //íîìåð âëîæåííîãî áëîêà
unsigned int osizestack;
RETLIST *olistreturn;
unsigned int onumreturn;
int oinlineflag;
SAVEREG *osavr;
unsigned int oaddESP=addESP;
addESP=0;
clearregstat();
osavr=psavereg;
psavereg=(SAVEREG*)MALLOC(sizeof(SAVEREG));
oinsertmode=insertmode;
insertmode=TRUE; //ôëàã ðåæèìà âñòàâêè
oinline=useinline;
ooptimizespeed=optimizespeed;
current_proc_type=itok.flag;
rec=itok.rec;
otlr=tlr;
olteglist=ltegtree;
// olstructlist=lstructlist;
oinlineflag=inlineflag;
osizestack=sizestack;
sizestack=0;
tlr=NULL;
ltegtree=NULL;
// lstructlist=0;
oparamsize=paramsize;
olocalsize=localsize;
onumblocks=numblocks;
olistreturn=listreturn;
onumreturn=numreturn;
paramsize=0;
localsize=0;
numblocks=0; //íîìåð âëîæåííîãî áëîêà
listreturn=NULL;
numreturn=0;
inlineflag=0;
nextexpecting2(tk_openbracket);
if(tok!=tk_closebracket){
if((current_proc_type&f_typeproc)!=tp_fastcall)declareparams();
else declareparamreg();
}
CorrectParamVar();
nexttok();
if(tok==tk_inline){
nexttok();
inlineflag=1;
expecting(tk_openbrace);
}
else{
if((current_proc_type&f_typeproc)!=tp_fastcall&&paramsize>0)Enter(); // PUSH BP MOV BP,SP
rec->recpost|=CheckUses();
if(tok!=tk_openbrace)declarelocals(0);
expecting(tk_openbrace);
declarelocals(1);
}
retproc=FALSE;
#ifdef OPTVARCONST
ClearLVIC();
#endif
startblock();
doblock2();
sizestack=osizestack; // do proc
setreturn();
endblock();
RestoreSaveReg();
if(inlineflag==0&&(localsize||paramsize)&&(ESPloc==FALSE||am32==FALSE))Leave();
killlocals(/*0*/);
optimizespeed=ooptimizespeed;
useinline=oinline;
paramsize=oparamsize;
localsize=olocalsize;
tlr=otlr;
ltegtree=olteglist;
// lstructlist=olstructlist;
insertmode=oinsertmode;
numblocks=onumblocks;
listreturn=olistreturn;
numreturn=onumreturn;
inlineflag=oinlineflag;
free(psavereg);
psavereg=osavr;
addESP=oaddESP;
// nexttok();
// printf("tok=%d\n",tok);
}
void AddTypeVar(int type,int pos)
{
switch(type){
case tk_char:
param[pos]='C';
break;
case tk_byte:
param[pos]='B';
break;
case tk_int:
param[pos]='I';
break;
case tk_word:
param[pos]='W';
break;
case tk_long:
param[pos]='L';
break;
case tk_dword:
param[pos]='D';
break;
case tk_float:
param[pos]='F';
break;
case tk_qword:
param[pos]='Q';
break;
case tk_double:
param[pos]='E';
break;
}
}
void declareparamreg() /* declare procedure parameters */
{
int i=0,num=1;
unsigned char j=0;
do{
if(tok>=tk_char&&tok<=tk_double){
AddTypeVar(tok,i++);
nexttok();
j=1;
}
else{
switch(tok){
case tk_beg:
if(j==0)param[i++]='B';
param[i++]=(char)(itok.number+0x30);
j=0;
break;
case tk_reg:
if(j==0)param[i++]='W';
param[i++]=(char)(itok.number+0x30);
j=0;
break;
case tk_reg32:
if(j==0)param[i++]='D';
param[i++]=(char)(itok.number+0x30);
j=0;
break;
case tk_reg64:
param[i++]='Q';
param[i++]=(char)((itok.number&255)+0x30);
param[i++]=(char)((itok.number/256)+0x30);
j=0;
break;
case tk_fpust:
param[i++]='S';
param[i++]=(char)(itok.number+0x30);
j=0;
break;
case tk_closebracket:
if(j==0)goto endproc;
default: edpip(num);
}
nexttok();
if(tok==tk_camma){
if(j!=0){
edpip(num);
param[i++]='0';
j=0;
}
nexttok();
}
}
num++;
}while(tok!=tk_closebracket);
endproc:
if(j!=0){
edpip(num-1);
param[i++]='0';
}
param[i]=0;
}
void AddMultiPoint(int pos)
{
param[pos]='A';
nexttok();
if(tok!=tk_closebracket)SwTok(tk_closebracket);
}
void declareparamstack() /* declare procedure parameters */
{
int i=0,num=1;
unsigned char j=0;
/*
1 - îáúÿâëåí òèï
2 - áûëà çàïÿòàÿ
3 - áûëà òî÷êà ñ çàïÿòîé
4 -
5 - áûë èäåíòèôèêàòîð
6 - òèï void
*/
int typevar=tk_multipoint;
structteg *tteg=NULL;
int size;
do{
if(tok==tk_struct)nexttok();
if(tok>=tk_char&&tok<=tk_double){
if(j>3||j==1)edpip(num);
j=1;
typevar=tok;
nexttok();
}
else if((tteg=FindTeg(TRUE))!=NULL){
size=Align(tteg->size,(am32+1)*2);
// printf("%s size=%u\n",itok.name,size);
j=1;
typevar=tk_struct;
nexttok();
}
while(tok==tk_mult){
param[i++]='*';
nexttok();
}
if(tok==tk_camma){
if(j==1){
if(typevar==tk_struct)i+=sprintf(&param[i],"T%u",size);
else AddTypeVar(typevar,i++);
}
else if(j!=5)edpip(num);
j=2;
num++;
}
else if(tok==tk_semicolon){
if(j==1){
if(typevar==tk_struct)i+=sprintf(&param[i],"T%u",size);
else AddTypeVar(typevar,i++);
}
else if(j!=5)edpip(num);
j=3;
num++;
}
else if(tok==tk_multipoint){
AddMultiPoint(i++);
break;
}
else if(tok==tk_closebracket){
if(j==0)param[i++]='A';
else if(j==1){
if(typevar==tk_struct)i+=sprintf(&param[i],"T%u",size);
else AddTypeVar(typevar,i++);
}
else if(j<4)edpip(num);
break;
}
else if(tok==tk_void){
if(j!=0)edpip(num);
param[i++]='V';
j=6;
}
else if(tok==tk_beg||tok==tk_reg||tok==tk_reg32||tok==tk_reg64||tok==tk_fpust){
if(j==1){
if(typevar==tk_struct)i+=sprintf(&param[i],"T%u",size);
else AddTypeVar(typevar,i++);
}
else if(j<4){
switch(tok){
case tk_beg: param[i++]='B'; break;
case tk_reg: param[i++]='W'; break;
case tk_reg32: param[i++]='D'; break;
case tk_fpust: param[i++]='S'; break;
case tk_reg64:
param[i++]='Q';
param[i++]=(char)((itok.number&255)+0x30);
itok.number/=256;
break;
}
}
else edpip(num);
param[i++]=(char)(itok.number+0x30);
j=5;
}
else{
if(j==1||j==2){
if(typevar==tk_struct)i+=sprintf(&param[i],"T%u",size);
else AddTypeVar(typevar,i++);
}
else edpip(num);
j=5;
}
nexttok();
}while(tok!=tk_eof);
param[i]=0;
// puts(param);
}
void CorrectParamVar()
{
unsigned int addnum;
int fspin;
struct localrec *ptr;
if(paramsize==0)return;
if(insertmode)addnum=0; //ret-address
else addnum=2;
if(ESPloc==FALSE||am32==FALSE)addnum+=2; //EBP
if((current_proc_type&f_far))addnum+=2;// move over seg on stack
if(am32)addnum*=2;
if((current_proc_type&f_typeproc)==tp_cdecl||(current_proc_type&f_typeproc)==tp_stdcall)fspin=FALSE;
else fspin=TRUE;
treelocalrec *ntlr=tlr;
while(ntlr&&ntlr->level>1)ntlr=ntlr->next;
for(ptr=ntlr->lrec;;ptr=ptr->rec.next){
if(ptr->rec.type==tp_paramvar){
if(fspin)ptr->rec.recnumber=paramsize-ptr->rec.recnumber-Align(ptr->rec.recsize,am32==FALSE?2:4);
ptr->rec.recnumber+=addnum;
}
if(ptr->rec.next==NULL)break;
}
}
void declareparams() /* declare procedure parameters */
{
int paramtok,sparamtok,i=0,type;
char flag=33;
int numpointr;
localrec *lrec;
structteg *tteg=NULL,*nteg;
do{
if(flag!=33)nexttok();
flag=1;
if(tok==tk_multipoint){
AddMultiPoint(i++);
break;
}
if(tok==tk_void){
param[i++]='V';
nexttok();
if(tok!=tk_closebracket)SwTok(tk_closebracket);
break;
}
if(tok>=tk_char&&tok<=tk_double){
type=tok;
SetNewTok(tok,variable);
paramtok=tok;
}
else if(tok==tk_beg||tok==tk_reg||tok==tk_reg32||tok==tk_reg64||tok==tk_fpust)flag=3;
else{
if(tok==tk_struct)nexttok();
if((tteg=FindTeg(TRUE))!=NULL)paramtok=tk_struct;
else{
datatype_expected();
flag=0;
nexttok();
}
}
if(flag){
do{
numpointr=0;
skipfind=TRUE;
if(flag!=3)nexttok();
while(tok==tk_mult){
nexttok();
numpointr++;
param[i++]='*';
}
if(tok==tk_id||tok==tk_ID){ //ïðîâåðèòü íà òèïû îïðåäåëåííûå ÷åðåç define
skipfind=FALSE;
int otok=tok;
searchtree(&ptok,&otok,string);
if(otok>=tk_char&&otok<=tk_double){
tok=otok;
itok=ptok;
}
skipfind=TRUE;
}
if(tok==tk_struct){
nexttok();
if((tteg=FindTeg(TRUE))!=NULL){
paramtok=tk_struct;
nexttok();
}
else{
edpip();
nexttok();
goto endparam1;
}
}
else {
if((nteg=FindTeg(TRUE))!=NULL){
tteg=nteg;
paramtok=tk_struct;
nexttok();
}
else{
if(tok>=tk_char&&tok<=tk_double){
type=tok;
SetNewTok(tok,variable);
paramtok=tok;
nexttok();
while(tok==tk_mult){
nexttok();
numpointr++;
param[i++]='*';
}
flag=2;
}
skipfind=FALSE;
if(tok==tk_beg||tok==tk_reg||tok==tk_reg32||tok==tk_reg64||tok==tk_fpust){
if(flag==2)AddTypeVar(type,i++);
else{
switch(tok){
case tk_beg: param[i++]='B'; break;
case tk_reg: param[i++]='W'; break;
case tk_reg32: param[i++]='D'; break;
case tk_fpust: param[i++]='S'; break;
case tk_reg64:
param[i++]='Q';
param[i++]=(char)((itok.number&255)+0x30);
itok.number/=256;
break;
}
}
param[i++]=(unsigned char)(itok.number+0x30);
flag=1;
goto endparam1;
}
}
}
sparamtok=paramtok;
if(tok==tk_multipoint){
AddMultiPoint(i++);
break;
}
if(tok!=tk_ID&&tok!=tk_id){
idalreadydefined();
break;
}
int lsize;
if(am32)lsize=4;
else{
lsize=2;
if(sparamtok>=tk_longvar&&sparamtok<=tk_floatvar&&numpointr==0)
lsize+=2;//add 2 more bytes
}
if((sparamtok==tk_qwordvar||sparamtok==tk_doublevar)&&numpointr==0)lsize=8;
AddTypeVar(type,i++);
if(sparamtok==tk_struct){
//idrec *newrec,*trec;
lsize=Align(tteg->size,(am32+1)*2);
i+=sprintf(&param[i],"T%u",lsize);
// newrec=(struct idrec *)MALLOC(sizeof(struct idrec));
// if(lstructlist==NULL)lstructlist=newrec;
// else{
// trec=lstructlist;
// while(trec->left!=NULL)trec=trec->left;
// trec->left=newrec;
// }
// newrec->right=newrec->left=NULL;
lrec=addlocalvar(itok.name,tk_structvar,paramsize);
lrec->rec.newid=(char *)tteg;
lrec->rec.flag=tteg->flag;
lrec->rec.recrm=1;
lrec->rec.recpost=LOCAL;
goto endparam;
}
lrec=addlocalvar(itok.name,sparamtok,paramsize);
lrec->rec.npointr=(unsigned short)numpointr;
endparam:
lrec->rec.type=tp_paramvar;
lrec->rec.recsize=lsize;
paramsize+=lsize;
endparam1:
nexttok();
}while(tok==tk_camma);
}
}while(tok==tk_semicolon);
param[i]=0;
// puts(param);
}
void CharToBackBuf(char c)
{
if(SizeBackBuf==0){
MaxSizeBackBuf=STRLEN;
BackTextBlock=(char *)MALLOC(STRLEN);
}
else if(SizeBackBuf==MaxSizeBackBuf){
MaxSizeBackBuf+=STRLEN;
BackTextBlock=(char *)REALLOC(BackTextBlock,MaxSizeBackBuf);
}
BackTextBlock[SizeBackBuf++]=c;
}
void AddBackBuf(int oinptr,char ocha)
//ñîçäàòü ëèñòèíã íà÷àëüíîé èíèöèàëèçàöèè ëîñàëüíûõ ïåðåìåííûõ
{
int numblock=0;
unsigned char save;
char bcha;
inptr=oinptr;
cha=ocha;
for(;;){
save=TRUE;
switch(cha){
case '(':
case '{':
case '[':
numblock++;
break;
case ')':
case '}':
case ']':
numblock--;
if(numblock<0)return;
break;
case ',':
if(numblock>0)break;
tok=tk_camma;
goto endp;
case ';':
case 26:
tok=tk_semicolon;
endp:
CharToBackBuf(';');
nextchar();
inptr2=inptr;
cha2=cha;
return;
case '/': //îòñëåäèòü êîììåíòàðèè
nextchar();
if(cha=='*'){
do{
nextchar();
if(cha=='*'){
nextchar();
if(cha=='/'){
save=FALSE;
break;
}
}
}while(cha!=26);
}
else if(cha=='/'){
do{
nextchar();
}while(cha!=13&&cha!=26);
}
else CharToBackBuf('/');
break;
case '"':
case '\'':
bcha=cha;
do{
CharToBackBuf(cha);
nextchar();
if(cha=='\\'){
CharToBackBuf(cha);
nextchar();
CharToBackBuf(cha);
nextchar();
}
}while(cha!=bcha);
break;
}
if(save)CharToBackBuf(cha);
nextchar();
}
}
void RunBackText()
{
ITOK oitok,ostructadr;
SINFO ostr;
unsigned char *oldinput;
unsigned int oldinptr,oldendinptr;
unsigned char bcha;
int otok,otok2;
char *ostartline;
char *ostring,*obufrm;
COM_MOD *ocurmod;
ostring=BackString((char *)string);
oldinput=input; //ñîõð íåêîòîð ïåðåìåíûå
oldinptr=inptr2;
ostructadr=structadr;
bcha=cha2;
oldendinptr=endinptr;
otok=tok;
otok2=tok2;
oitok=itok;
ostr=strinf;
strinf.bufstr=NULL;
obufrm=bufrm;
bufrm=NULL;
ocurmod=cur_mod;
cur_mod=NULL;
input=(unsigned char *)BackTextBlock;
inptr2=1;
cha2=input[0];
tok=tk_openbrace;
SizeBackBuf=0;
ostartline=startline;
startline=(char*)input;
endinptr=strlen((char *)input);
endinput=startline+endinptr;
doblock();
endoffile=0;
startline=ostartline;
strinf=ostr;
free(input);
input=oldinput;
inptr2=oldinptr;
cha2=bcha;
endinptr=oldendinptr;
tok=otok;
itok=oitok;
if(bufrm)free(bufrm);
bufrm=obufrm;
tok2=otok2;
strcpy((char *)string,ostring);
if(strinf.bufstr)free(strinf.bufstr);
structadr=ostructadr;
free(ostring);
cur_mod=ocurmod;
}
int PushLocInit(int ofs)
{
ITOK oitok,ostructadr,wtok;
SINFO ostr;
unsigned char *oldinput;
unsigned int oldinptr,oldendinptr;
unsigned char bcha;
int otok,otok2;
char *ostartline;
char *ostring,*obufrm;
int retcode=FALSE;
// if(bufrm)puts(bufrm);
ostring=BackString((char *)string);
oldinput=input; //ñîõð íåêîòîð ïåðåìåíûå
oldinptr=inptr2;
ostructadr=structadr;
bcha=cha2;
oldendinptr=endinptr;
otok=tok;
otok2=tok2;
oitok=itok;
ostr=strinf;
strinf.bufstr=NULL;
obufrm=bufrm;
bufrm=NULL;
input=(unsigned char *)BackTextBlock;
inptr2=ofs;
ostartline=startline;
cha2=input[inptr2++];
endinptr=strlen((char *)input);
startline=(char *)input+ofs;
endinput=startline+endinptr;
nexttok();
wtok=itok;
nexttok();
nexttok();
if((retcode=Push(&wtok))!=FALSE){
retcode=TRUE;
for(inptr2=ofs;;inptr2++){
cha2=input[inptr2];
input[inptr2]=' ';
if(cha2==';'||cha2==0)break;
}
}
endoffile=0;
startline=ostartline;
strinf=ostr;
input=oldinput;
inptr2=oldinptr;
cha2=bcha;
endinptr=oldendinptr;
tok=otok;
itok=oitok;
if(bufrm)free(bufrm);
bufrm=obufrm;
tok2=otok2;
strcpy((char *)string,ostring);
if(strinf.bufstr)free(strinf.bufstr);
structadr=ostructadr;
free(ostring);
return retcode;
}
int pushinit(int localline,unsigned int ofs)
{
int oline=linenumber;
COM_MOD *bcur_mod;
int retcode;
linenum2=localline;
bcur_mod=cur_mod;
cur_mod=NULL;
retcode=PushLocInit(ofs);
cur_mod=bcur_mod;
linenumber=linenum2=oline;
return retcode;
}
int PossiblePush()
{
int retcode=FALSE;
nexttok();
switch(tok){
case tk_dwordvar:
case tk_longvar:
case tk_reg32:
if(am32==FALSE)break;
case tk_postnumber:
case tk_string:
case tk_intvar:
case tk_wordvar:
case tk_reg:
if(tok2==tk_semicolon||tok2==tk_camma)retcode=TRUE;
break;
case tk_undefofs:
tok=tk_number;
goto chnum;
case tk_minus:
if(tok2!=tk_number)break;
nexttok();
case tk_number:
chnum:
doconstlongmath();
if(tok==tk_semicolon||tok==tk_camma)retcode=TRUE;
break;
}
//// New 20.07.07 22:01
if(bufrm){
free(bufrm);
bufrm=NULL;
}
if(strinf.bufstr){
free(strinf.bufstr);
strinf.bufstr=NULL;
}
////////////////////////////
return retcode;
}
#define MAXLOCVAR 128
void declarelocals(int mode,int finline) /* declare locals */
/*-----------------01.06.02 15:12-------------------
mode = 0 if local vars prior {
mode = 1 if local vars after {
--------------------------------------------------*/
{
unsigned int size,ssize,localtok;
int binptr;
int flag=0;
char bcha;
int slocaltok;
int numpointr,type;
unsigned int loop;
static int localline;
static int numinit;
static int maxlocvar;
static LILV *lilv=NULL;
static int headerinit;
if(localsize==0)localline=0;
if(lilv==NULL){
numinit=0;
lilv=(LILV *)MALLOC(sizeof(LILV)*MAXLOCVAR);
maxlocvar=MAXLOCVAR;
if(paramsize&&(!finline))headerinit=TRUE;
else headerinit=FALSE;
}
dynamic_flag=0;
do{
while(tok==tk_semicolon)nexttok();
if(tok==tk_static){
flag|=f_static;
nexttok();
}
size=0;
switch(tok){
case tk_union:
loop=dounion(0,flag);
goto locstruct;
case tk_struct:
loop=LocalStruct(flag,&localline);
locstruct:
(lilv+numinit)->size=-loop;
break;
case tk_int: localtok=tk_intvar; size=2; break;
case tk_word: localtok=tk_wordvar; size=2; break;
case tk_char: localtok=tk_charvar; size=1; break;
case tk_byte: localtok=tk_bytevar; size=1; break;
case tk_long: localtok=tk_longvar; size=4; break;
case tk_dword: localtok=tk_dwordvar; size=4; break;
case tk_float: localtok=tk_floatvar; size=4; break;
case tk_qword: localtok=tk_qwordvar; size=8; break;
case tk_double: localtok=tk_doublevar; size=8; break;
default:
if((tok>=tk_bits&&tok<=tk_doublevar)||tok==tk_pointer||tok==tk_proc
||tok==tk_declare||tok==tk_undefproc||tok==tk_structvar||
(FindTeg(FALSE)==NULL&&FindTeg(TRUE)==NULL)){
if(mode==0){
(lilv+numinit)->size=0;
datatype_expected();
nexttok();
}
else{
if(localsize){
if(!finline){
numpointr=0;
if(SizeBackBuf){
BackTextBlock[SizeBackBuf]=0;
for(type=numinit-1,numpointr=0;type>=0;type--){//îïð ÷èñëî èíèö. ïåðåìåííûõ â êîíöå
if((lilv+type)->size<=0)break;
numpointr+=(lilv+type)->size;
}
type++; //÷èñëî îñòàâøèõñÿ ïåðåìåííûõ
ssize=type;
}
size=localsize;
if(lilv->size<=0&&optimizespeed==0&&chip>1){
size-=numpointr;
if(headerinit)outptr-=3; /* remove PUSH BP and MOV BP,SP */
op(0xC8); /* ENTER */
outword(size); /* # of locals */
op(0x00); /* level = 0 */
flag=0;
type=0;
headerinit=TRUE;
size=numpointr;
}
else{
if(headerinit==FALSE){
Enter();
headerinit=TRUE;
}
flag=1;
}
if(SizeBackBuf){
if(lilv->size>0){ //åñòü èíèö ïåðåìåííûå â íà÷àëå
for(loop=0;loop<numinit;loop++){
// printf("size%d=%d %s\n",loop,(lilv+loop)->size,BackTextBlock);
if((lilv+loop)->size<=0)break;
if(pushinit(localline,(lilv+loop)->ofs)==FALSE)break;
(lilv+loop)->rec->fuse|=INITVAR;
size-=Align((lilv+loop)->size,(am32==FALSE?2:4));
type--;
}
}
if(size){
binptr=size-numpointr;
if(binptr){
if(!optimizespeed&&type<3&&(type*(am32+1)*2)>=binptr)for(;type!=0;type--)op(0x50+ECX);
else{
if(binptr<128){
outword(0xEC83);
op(binptr);
}
else{
outword(0xEC81);
if(am32==FALSE)outword(binptr);
else outdword((unsigned long)binptr);
}
}
}
if(numpointr){
for(;ssize<numinit;ssize++){
// printf("size%d=%d %s\n",loop,(lilv+loop)->size,BackTextBlock);
if(pushinit(localline,(lilv+ssize)->ofs)==FALSE)break;
(lilv+ssize)->rec->fuse|=INITVAR;
}
}
}
}
else if(flag){
if(localsize<128){
outword(0xEC83);
op(localsize);
}
else{
outword(0xEC81);
if(am32==FALSE)outword(localsize);
else outdword((unsigned long)localsize);
}
}
}
else{ //finline
if(SizeBackBuf!=0){
free(BackTextBlock);
SizeBackBuf=0;
}
}
}
if(psavereg->size){
if(psavereg->all){
op(0x60);
addESP+=am32==FALSE?16:32;
}
else{
for(int i=0;i<8;i++){
if(psavereg->reg[i]){
op66(psavereg->reg[i]);
op(0x50+i);
addESP+=am32==FALSE?2:4;
}
}
}
if(ESPloc&&am32&&(itok.type==tp_localvar||itok.type==tp_paramvar))itok.number+=addESP;
}
// printf("numinit=%d firstinit=%d\n%s\n",numinit,firstinit,BackTextBlock);
if(SizeBackBuf!=0){
CharToBackBuf('}');
CharToBackBuf(0);
int oline=linenumber;
linenum2=localline;
COM_MOD *bcur_mod;
bcur_mod=cur_mod;
cur_mod=NULL;
RunBackText();
cur_mod=bcur_mod;
linenumber=linenum2=oline;
}
if(lilv){
free(lilv);
lilv=NULL;
}
return;
}
}
else{
loop=LocalStruct(flag,&localline);
(lilv+numinit)->size=-loop;
}
break;
}
if(size!=0){
do{
binptr=inptr2;
bcha=cha2;
skipfind=TRUE; //çàïðåòèòü èñêàòü â ãëîáàëüíîì äåðåâå
nexttok();
if(tok==tk_static){
flag|=f_static;
binptr=inptr2;
bcha=cha2;
nexttok();
}
slocaltok=localtok;
ssize=size;
numpointr=0;
type=tp_localvar;
while(tok==tk_mult){
binptr=inptr2;
bcha=cha2;
nexttok();
numpointr++;
}
if(tok!=tk_ID&&tok!=tk_id)idalreadydefined();
else{
long numcopyvar;
numcopyvar=1;
localrec *lrec=addlocalvar(itok.name,slocaltok,(flag&f_static)==0?localsize:postsize);
loop=ssize;
if(numpointr)loop=am32==TRUE?4:2;
skipfind=FALSE; //ðàçðåøèòü ïîèñê â ãëîáàëüíîì äåðåâå
if(tok2==tk_openblock){//[
nexttok();
nexttok();
CheckMinusNum();
if(tok!=tk_number){
numexpected();
nexttok();
}
else numcopyvar=doconstlongmath();
loop=numcopyvar*ssize;
if(tok!=tk_closeblock)expected(']');
}
lrec->rec.recsize=loop;
if(!mode){
nexttok();
}
if(flag&f_static){
if(tok==tk_assign||(mode&&tok2==tk_assign)){
if(mode)nexttok();
if(numpointr){
type=tk_char+slocaltok-tk_charvar;
slocaltok=tk_pointer;
}
lrec->rec.rectok=slocaltok;
lrec->rec.recnumber=0;
lrec->rec.recpost=DYNAMIC_VAR;
lrec->rec.line=linenumber;
lrec->rec.file=currentfileinfo;
lrec->rec.count=0;
// lptr->rec.type=(unsigned short)type;
lrec->rec.npointr=(unsigned short)numpointr;
lrec->rec.sbuf=dynamic_var();
lrec->rec.recsib=type;
lrec->rec.type=tp_gvar;
// if(strcmp(lrec->rec.recid,"nnil")==0)crec=&lrec->rec;
}
else{
lrec->rec.type=tp_postvar;
AddPostData(loop);
if(mode)nexttok();
}
}
else{
lrec->rec.type=tp_localvar;
lrec->rec.npointr=(unsigned short)numpointr;
localsize+=loop;
if(mode)nexttok();
(lilv+numinit)->size=-loop;
if(tok==tk_assign){
if(localline==0)localline=linenumber;
if(numcopyvar!=1){
int i=binptr;
while(input[i]!='[')i++;
i++;
input[i]='0';
i++;
for ( int j=1;j!=0;i++){
switch(input[i]){
case '[':
j++;
break;
case ']':
j--;
break;
}
if(j!=0)input[i]= ' ';
}
}
else{
switch(slocaltok){
case tk_floatvar:
case tk_doublevar:
case tk_qwordvar:
// (lilv+numinit)->ofs=-1;
break;
default:
if(PossiblePush()){
(lilv+numinit)->size=loop;
(lilv+numinit)->rec=lrec;
}
break;
}
}
(lilv+numinit)->ofs=SizeBackBuf;
AddBackBuf(binptr,bcha);
// if(bufrm)puts(bufrm);
}
numinit++;
if(numinit==maxlocvar){
maxlocvar+=MAXLOCVAR;
lilv=(LILV *)REALLOC(lilv,maxlocvar*sizeof(LILV));
}
lrec->rec.recnumber=-lrec->rec.recnumber-Align(loop,(am32==FALSE?2:4));
}
}
if(localsize)localsize=Align(localsize,(am32==FALSE?2:4));
}while(tok==tk_camma);
seminext();
}
else{
numinit++;
if(numinit==maxlocvar){
maxlocvar+=MAXLOCVAR;
lilv=(LILV *)REALLOC(lilv,maxlocvar*sizeof(LILV));
}
}
flag=0;
// printf("tok=%d %s\n",tok,BackTextBlock);
}while(tok!=tk_openbrace&&tok!=tk_eof);
}
int CheckDeclareProc()
{
unsigned int i=inptr2-1;
while(input[i]!='('){
i++;
if(i>=endinptr){
unexpectedeof();
break;
}
}
lab1:
i++;
for(int j=1;j!=0;i++){
char c=input[i];
if(c=='(')j++;
else if(c==')')j--;
if(i>=endinptr){
unexpectedeof();
break;
}
}
for(;;i++){
if(input[i]=='(')goto lab1;
if(input[i]>' ')break;
if(i>=endinptr){
unexpectedeof();
break;
}
}
for(;;i++){
if(input[i]==';'||input[i]==',')return TRUE; //îáúÿâëåíèå ïðîöåäóðû
if(input[i]>' ')break;
if(i>=endinptr){
unexpectedeof();
break;
}
}
return FALSE;
}
void IsUses(idrec *rec)
{
int i;
if(tok==tk_openbracket&&stricmp(itok2.name,"uses")==0){
nexttok();
i=0;
nexttok();
while(tok==tk_reg32||tok==tk_reg||tok==tk_beg){
if(tok==tk_beg&&itok.number>3)itok.number-=4;
i=i|(1<<itok.number);
nexttok();
if(tok==tk_camma)nexttok();
}
if(strcmp(itok.name,"allregs")==0){
i=256;
nexttok();
}
rec->recpost=0xFF^i;
expecting(tk_closebracket);
}
}
void declare_procedure(int oflag,int orm,int npointr)
{
int i,next=TRUE,j;
char pname[IDLENGTH];
idrec *rec;
strcpy(pname,itok.name);
param[0]=0;
nexttok();
if(npointr)expecting(tk_closebracket);
expecting(tk_openbracket);
if((oflag&f_typeproc)==tp_fastcall)declareparamreg();
else declareparamstack();
if(tok2==tk_assign)nexttok();
itok.post=1;
if(npointr){
itok.segm=DS;
itok.type=tk_proc;
itok.sib=am32==FALSE?rm_d16:rm_d32;
i=2;
if(am32||(oflag&f_far))i=4;
if(tok==tk_assign||(notpost==TRUE&&dynamic_flag==0)){ //= èíèöèàëèçèðîâàíàÿ ïåðåìåííàÿ
if((oflag&f_extern))preerror("extern variable do not initialize at declare");
if(alignword&&(!dynamic_flag))alignersize+=AlignCD(DS,i);
FindOff((unsigned char *)pname,DS);
itok.number=outptrdata;
if(tok!=tk_assign){
if(dbg&2)AddDataLine(i);
outword(0);
if(i==4)outword(0);
}
else{
ITOK oitok;
oitok=itok;
initglobalvar(tk_word,1,i,variable);
itok=oitok;
next=FALSE;
}
itok.post=0;
datasize+=i;
}
else{
if((oflag&f_extern)==0){
itok.number=postsize;
AddPostData(i);
}
else itok.number=externnum++;
}
j=tok;
tok=tk_pointer;
}
else{
tok=tk_declare;
itok.type=tp_declare;
itok.number=(oflag&f_extern)!=0?externnum++:secondcallnum++;
itok.segm=NOT_DYNAMIC;
itok.post=0;
}
itok.npointr=(unsigned short)npointr;
itok.rm=orm;
itok.flag=oflag;
if(itok.rm==tokens)itok.rm=(am32==0?tk_word:tk_dword);
// printf("rm=%d %s\n",itok.rm,itok.name);
strcpy((char *)string,param);
rec=addtotree(pname);
if(next)nexttok();
else tok=j;
IsUses(rec);
}
void define_procedure()
{
if(dynamic_flag)dynamic_proc();
else{
itok.segm=NOT_DYNAMIC;
if(AlignProc!=FALSE)AlignCD(CS,alignproc);
procedure_start=outptr;
if(dbg)AddLine();
// itok.flag&=~f_static; 26.08.05 00:09
setproc((tok==tk_id||tok==tk_ID)?0:1);
dopoststrings();
}
}
void interruptproc()
{
char *bstring;
ITOK otok;
inlineflag=0;
procedure_start=outptr;
returntype=tk_void;
current_proc_type=f_interrupt;
localsize=paramsize=0;
nexttok();
// FindOff((unsigned char *)itok.name,CS);
itok.number=outptr;
itok.segm=NOT_DYNAMIC;
itok.post=0;
itok.rm=tk_void;
itok.flag=0;
if(tok==tk_ID||tok==tk_id){
tok=tk_interruptproc;
itok.type=tp_ucnovn;
addtotree((char *)string);
}
else if(tok==tk_undefproc){
tok=tk_interruptproc;
long hold=updatetree();
updatecall((unsigned int)hold,(unsigned int)outptr,0);
}
else idalreadydefined();
itok.rec->count=FindOff((unsigned char *)itok.name,CS);
bstring=BackString((char *)string);
otok=itok;
nextexpecting2(tk_openbracket);
expecting(tk_closebracket);
if(tok==tk_inline){
inlineflag=1;
nexttok();
}
else if(tok!=tk_openbrace)declarelocals(0);
expecting(tk_openbrace);
declarelocals(1);
startblock();
doblock2(); /* do proc */
endblock();
if(retproc==FALSE){
if(inlineflag==0)leaveproc();
else if(localsize>0)Leave();
}
initBP=0;
strcpy((char *)string,bstring);
itok=otok;
tok=tk_interruptproc;
itok.size=outptr-procedure_start;
updatetree();
free(bstring);
killlocals();
nexttok();
dopoststrings();
}
int skipstring(int pos,unsigned char term)
{
unsigned char c;
do{
pos++;
c=input[pos];
if(c==0x5C){
pos++;
continue;
// c=input[pos+1];
}
}while(c!=term);
return pos;
}
int skipcomment(int pos)
{
if(input[pos+1]=='*'){
pos+=2;
for(;;pos++){
if(input[pos]==13){
linenumber++;
}
else if(input[pos]=='*'){
pos++;
if(input[pos]=='/')break;
}
if((unsigned int)pos>=endinptr){
unexpectedeof();
break;
}
}
}
else if(input[pos+1]=='/'){
pos+=2;
for(;;pos++){
if(input[pos]==13){
linenumber++;
break;
}
if(input[pos]==10)break;
}
}
return pos;
}
int swapparam()
{
int i,ns,j,lastofs;
int linep,linebak;
char c,ochar;
unsigned char *bufpar;
int numpar=0;
unsigned char *oldinput;
paraminfo *pi;
if(tok!=tk_openbracket){
expected('(');
do{
nexttok();
}while(tok2!=tk_semicolon&&tok!=tk_eof);
return 0;
}
pi=(paraminfo *)MALLOC(128*sizeof(paraminfo));
do{
inptr2--;
}while(input[inptr2]!='(');
inptr2++;
pi->ofspar=inptr2;
pi->type[0]=0;
linep=linenumber;
for(i=inptr2,ns=1;ns>0;i++){ //ïîèñê êîíöà ïàðàìåòðîâ
switch(input[i]){
case '(': ns++; break;
case ')': ns--; break;
case ',':
if(ns==1){
if(numpar==127)preerror("To many parametrs in function");
numpar++;
(pi+numpar)->ofspar=i+1;
(pi+numpar)->type[0]=0;
}
break;
case '/':
i=skipcomment(i);
break;
case '"':
case 0x27:
i=skipstring(i,input[i]);
break;
case 13:
linenumber++;
break;
}
if((unsigned int)i>=endinptr){
unexpectedeof();
break;
}
}
for(j=0,ns=0;param[j]!=0;j++,ns++){//ïåðåâåðíóòü çàäåêëàðèðóåìûå ïàðàìåòðû
lastofs=0;
ochar=c=param[j];
(pi+ns)->type[0]=c;
while(c=='*'){
j++;
ochar=c=param[j];
(pi+ns)->type[++lastofs]=c;
}
if(c=='A'){
if(ns){
while(ns<=numpar){
(pi+ns)->type[0]='U';
(pi+ns)->type[1]=0;
ns++;
}
break;
}
}
if(ochar=='T'){
do{
j++;
lastofs++;
c=param[j];
(pi+ns)->type[lastofs]=c;
}while(isdigit(c));
(pi+ns)->type[lastofs]=0;
j--;
continue;
}
c=param[j+1];
if(c>='0'&&c<='7'){
(pi+ns)->type[1]=c;
j++;
lastofs++;
if(ochar=='Q'){
(pi+ns)->type[2]=param[j+1];
j++;
lastofs++;
}
}
(pi+ns)->type[++lastofs]=0;
}
ns--;
for(j=0;ns>=0;ns--){
lastofs=0;
c=(pi+ns)->type[lastofs++];
while(c!=0){
param[j++]=c;
c=(pi+ns)->type[lastofs++];
}
}
param[j]=0;
// puts(param);
// if(crec)printf("start0 swapparams num=%08X\n",crec->recnumber);
bufpar=(unsigned char *)MALLOC(i-inptr2+2);
// printf("crec=%08X size=%d bufpar=%08X size=%d\n",crec,sizeof(idrec),bufpar,i-inptr2+2);
inptr2=i;
ochar=input[inptr2];
inptr2++;
i--;
lastofs=0;
for(;;){
j=(pi+numpar)->ofspar;//[numpar];
for(ns=0;(j+ns)!=i;ns++){
bufpar[lastofs++]=input[j+ns];
}
i=j-1;
numpar--;
if(numpar<0)break;
bufpar[lastofs++]=',';
}
bufpar[lastofs++]=')';
*(short *)&bufpar[lastofs++]=';';
free(pi);
oldinput=input; //ñîõð íåêîòîð ïåðåìåíûå
// puts((char *)(input+inptr));
// printf("cur_mod=%08X input=%08X\n",cur_mod,input);
ns=inptr2;
j=endinptr;
input=bufpar;
// puts((char *)bufpar);
inptr2=1;
cha2=input[0];
endinptr=lastofs;
tok=tk_openbracket;
if(bufrm!=NULL){
free(bufrm);
bufrm=NULL;
}
if(strinf.bufstr!=NULL){
free(strinf.bufstr);
strinf.bufstr=NULL;
}
linebak=linenumber;
linenumber=linep;
i=doparams();
endoffile=0;
input=oldinput;
inptr2=ns;
cha2=ochar;
endinptr=j;
linenumber=linebak;
// printf("cur_mod=%08X input=%08X\n",cur_mod,input);
free(bufpar);
// puts((char *)input);
return i;
}
int getrazr(int type)
{
switch(type){
case tk_char:
case tk_byte:
return r8;
case tk_word:
case tk_int:
return r16;
case tk_long:
case tk_dword:
case tk_float:
return r32;
case tk_qword:
case tk_double:
return r64;
}
if(am32)return r32;
return r16;
}
int doparams() /* do stack procedure parameter pushing */
{
char done=0,next;
int vartype;
int stackpar=0;
int i;
int jj=0;
char *bparam; //áóôåð äëÿ äåêëàðèðóåìûõ ïàðàìåòðîâ
int ip=-1; //íîìåð ïàðàìåòðà
char *ofsstr=NULL;
int useAX=FALSE;
int retreg=AX;
unsigned char oaddstack=addstack;
unsigned char oinline=useinline;
useinline=0;
int structsize;
struct idrec *ptrs;
addstack=FALSE;
if(am32!=FALSE)jj=2;
bparam=BackString(param);
if(param[0]!=0)ip=0;
ofsstr=GetLecsem(tk_camma,tk_closebracket);
expectingoperand(tk_openbracket);
ClearRegister();
if(tok!=tk_closebracket){
while(tok!=tk_eof&&done==0){
useAX=FALSE;
retreg=AX;
i=0;
next=1;
if(ip!=-1){
if(bparam[ip]=='*'){
while(bparam[ip]=='*')ip++;
ip++;
vartype=(am32==FALSE?tk_word:tk_dword);
}
else{
if((vartype=GetTypeParam(bparam[ip++]))==0)ip=-1;
else{
int c=bparam[ip];
if(vartype==tk_struct){
structsize=0;
while(isdigit(c)){
c-='0';
structsize=structsize*10+c;
ip++;
c=param[ip];
}
}
else if(c>='0'&&c<='7'){
ip++;
c-=0x30;
if(vartype==tk_fpust)float2stack(c);
else{
if(vartype==tk_qword){
c|=(bparam[ip]-0x30)*256;
ip++;
}
CalcRegPar(c,vartype,&ofsstr);
}
goto endparam;
}
}
}
if(vartype==tk_multipoint){
vartype=tokens;
ip--;
}
}
if(tok==tk_string){
if(chip<2||(optimizespeed&&(chip==5||chip==6))){
op(0xB8);
if(am32!=FALSE)outdword(addpoststring());
else outword(addpoststring()); // MOV AX,imm16
op(0x50);
useAX=TRUE;
ClearReg(EAX); //íàäî äîáàâèòü îïòèìèçàöèþ ðåãèñòðîâ à ïîêà òàê
} /* PUSH AX */
else{
op(0x68); /* PUSH imm16 */
if(am32!=FALSE)outdword(addpoststring());
else outword(addpoststring());
if(cpu<2)cpu=2;
}
stackpar+=2+jj;
addESP+=2+jj;
nexttok();
}
else{
if(tok>=tk_char&&tok<=tk_double){
vartype=tok;
getoperand();
}
else if(tok==tk_openbracket){
nexttok();
if(tok>=tk_char&&tok<=tk_double)vartype=tok;
nexttok();
expectingoperand(tk_closebracket);
}
else{
if(ip==-1||vartype==tokens){
switch(tok){
case tk_longvar: vartype=tk_long; break;
case tk_floatvar: vartype=tk_float; break;
case tk_dwordvar: vartype=tk_dword; break;
case tk_doublevar: vartype=tk_double; break;
case tk_qwordvar: vartype=tk_qword; break;
case tk_number:
vartype=(itok.rm==tk_float?tk_float:(am32==FALSE?tk_word:tk_dword));
break;
case tk_reg32: vartype=tk_dword; break;
case tk_reg64: vartype=tk_qword; break;
case tk_minus:
if(tok2==tk_number){
vartype=itok2.rm==tk_float?tk_float:(am32==FALSE?tk_word:tk_dword);
break;
}
default: vartype=(am32==FALSE?tk_word:tk_dword); break;
}
}
}
if(tok==tk_minus&&tok2==tk_number&&vartype!=tk_float){ //ïðîâåðêà îòðèöàòåëüíîãî ÷èñëà
nexttok();
itok.lnumber=-itok.lnumber;
}
int razr;
if(ofsstr){
razr=getrazr(vartype);
int retr;
if((retr=CheckIDZReg(ofsstr,AX,razr))!=NOINREG){
// printf("reg=%d\n",retr);
GetEndLex(tk_camma,tk_closebracket);
if(razr==r8)razr=am32==0?r16:r32;
if(retr==SKIPREG)retreg=AX;
else retreg=retr;
op66(razr);
op(0x50+retreg);
useAX=TRUE;
stackpar+=razr;
addESP+=razr;
goto endparam1;
}
// printf("reg=%d\n",retr);
}
razr=r32;
if(itok2.type==tp_opperand||tok==tk_minus){ //ñîñòàâíîå
switch(vartype){
case tk_struct:
i=structsize/((am32+1)*2);
do_e_axmath(0,r32,&ofsstr);
ClearReg(AX);
if(am32){
i--;
itok.number=structsize;
for(;i>0;i--){
itok.number-=4;
outword(0x70FF);
op(itok.number);
}
outword(0x30FF);
}
else{
ClearReg(BX);
warningreg(regs[1][BX]);
outword(0xC389);
i--;
itok.number=structsize;
for(;i>0;i--){
itok.number-=2;
outword(0x77FF);
op(itok.number);
}
outword(0x37FF);
}
stackpar+=structsize;
addESP+=structsize;
break;
case tk_char: i=1;
case tk_byte:
stackpar+=jj;
doalmath((char)i,&ofsstr);
addESP+=2+jj;
break;
case tk_int: i=1;
case tk_word:
if(am32==FALSE)razr=r16;
stackpar+=jj;
goto blokl;
case tk_long: i=1;
case tk_dword:
if(cpu<3)cpu=3;
stackpar+=2;
blokl:
if(chip>=2&&(!(optimizespeed&&(chip==5||chip==6)))&&(tok==tk_number
||tok==tk_undefofs||tok==tk_postnumber)){
int otok=tok;
ITOK oitok=itok;
tok=tk_number;
if(OnlyNumber(i)){
op66(razr);
if(otok==tk_number&&(postnumflag&f_reloc)==0&&short_ok(itok.number,razr==r16?FALSE:TRUE)!=0){
op(0x6A); // PUSH 8 extend to 32 bit
op((unsigned int)itok.number);
}
else{
op(0x68); // PUSH const
if(otok==tk_undefofs)AddUndefOff(0,oitok.name);
else if(otok==tk_postnumber)(oitok.flag&f_extern)==0?setwordpost(&oitok):setwordext(&oitok.number);
else if((postnumflag&f_reloc)!=0)AddReloc();
if(razr==r16)outword(itok.number);
else outdword(itok.number);
}
addESP+=razr==r16?2:4;
goto nopush;
}
tok=otok;
}
do_e_axmath(i,razr,&ofsstr);
addESP+=razr==r16?2:4;
op66(razr);
break;
case tk_double:
if(doeaxfloatmath(tk_stackstart,0,4)!=tk_stackstart){
op66(r32);
op(0x50+EDX); // PUSH EDX
op66(r32);
op(0x50); //push eax
useAX=TRUE;
}
if(cpu<3)cpu=3;
stackpar+=6;
addESP+=8;
goto nopush;
case tk_float:
if(doeaxfloatmath(tk_stackstart)!=tk_stackstart){
op66(r32);
if(!am32){
op(0x89); // mov ssdword[bp+2]=eax
op(0x46);
op(2);
Leave();
}
else{
op(0x50); //push eax
useAX=TRUE;
}
}
if(cpu<3)cpu=3;
stackpar+=2;
addESP+=4;
goto nopush;
case tk_qwordvar:
i=EAX|(EDX*256);
getintoreg64(i);
doregmath64(i);
op66(r32);
op(0x50+EDX); // PUSH EDX
op66(r32);
next=0;
if(cpu<3)cpu=3;
stackpar+=6;
addESP+=8;
break;
default: goto deflt;
}
op(0x50);/* PUSH AX or EAX */
useAX=TRUE;
nopush:
stackpar+=2;
}
else{ //îäèíî÷íîå
// next=1;
// printf("vartype=%d\n",vartype);
if(vartype==tk_struct){
// printf("tok=%d %s\n",tok,itok.name);
i=structsize/((am32+1)*2);
switch(tok){
case tk_structvar:
ptrs=itok.rec;
if(ptrs->recpost==LOCAL){
if(ESPloc&&am32){
itok.rm=rm_mod10|rm_sib;
itok.sib=0x24;
itok.number+=addESP;
}
else{
itok.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
}
itok.segm=SS;
itok.post=0;
compressoffset(&itok);
}
else{
itok.segm=DS;
itok.rm=(am32==FALSE?rm_d16:rm_d32); //óñòàíîâêè ïî óìîë÷àíèþ
itok.post=ptrs->recpost;
if(i>1&&am32){
outseg(&itok,1);
op(0xB8);
outaddress(&itok);
ClearReg(AX);
i--;
itok.number=structsize;
for(;i>0;i--){
itok.number-=4;
outword(0x70FF);
op(itok.number);
}
outword(0x30FF);
break;
}
}
itok.sib=(am32==FALSE?CODE16:CODE32);
itok.flag=ptrs->flag;
itok.number+=structsize;
for(;i>0;i--){
itok.number-=(am32+1)*2;
outseg(&itok,2);
op(0xFF); // PUSH [dword]
op(0x30+itok.rm);
outaddress(&itok);
}
break;
case tk_rmnumber:
itok.number+=structsize;
for(;i>0;i--){
itok.number-=(am32+1)*2;
outseg(&itok,2);
op(0xFF); // PUSH [dword]
op(0x30+itok.rm);
outaddress(&itok);
}
break;
case tk_undefofs:
itok.rm=(am32==FALSE?rm_d16:rm_d32); //óñòàíîâêè ïî óìîë÷àíèþ
case tk_postnumber:
if(i>1&&am32){
if(tok!=tk_undefofs)outseg(&itok,1);
op(0xB8);
if(tok==tk_undefofs){
AddUndefOff(0,(char *)string);
outdword(itok.number);
}
else outaddress(&itok);
ClearReg(AX);
i--;
itok.number=structsize;
for(;i>0;i--){
itok.number-=4;
outword(0x70FF);
op(itok.number);
}
outword(0x30FF);
break;
}
itok.number+=structsize;
for(;i>0;i--){
itok.number-=(am32+1)*2;
if(tok!=tk_undefofs)outseg(&itok,2);
op(0xFF); // PUSH [dword]
op(0x30+itok.rm);
if(tok==tk_undefofs){
AddUndefOff(0,(char *)string);
outdword(itok.number);
}
else outaddress(&itok);
}
break;
case tk_reg32:
i--;
itok.rm=structsize;
for(;i>0;i--){
itok.rm-=4;
op(0xFF);
op(0x70+itok.number);
op(itok.rm);
}
op(0xFF);
op(0x30+itok.number);
break;
default:
// preerror("for parametr function required structure");
do_e_axmath(0,r32,&ofsstr);
ClearReg(AX);
if(am32){
i--;
itok.number=structsize;
for(;i>0;i--){
itok.number-=4;
outword(0x70FF);
op(itok.number);
}
outword(0x30FF);
}
else{
ClearReg(BX);
warningreg(regs[1][BX]);
outword(0xC389);
i--;
itok.number=structsize;
for(;i>0;i--){
itok.number-=2;
outword(0x77FF);
op(itok.number);
}
outword(0x37FF);
}
break;
}
stackpar+=structsize;
addESP+=structsize;
}
else if(vartype<tk_long){
#ifdef OPTVARCONST
CheckConstVar3(&tok,&itok,razr);
#endif
switch(tok){
case tk_reg:
op(0x50+(unsigned int)itok.number);
break;
case tk_beg:
if(vartype==tk_int||vartype==tk_word)goto deflt;
if(itok.number<AH){
op(0x50+(unsigned int)itok.number);
break;
}
op(0x88);
op(0xC0+(unsigned int)itok.number*8);
op(0x50);
useAX=TRUE;
break;
case tk_seg:
if(am32)goto deflt;
if((unsigned int)itok.number<FS)op(0x06+(unsigned int)itok.number*8);
else{
op(0xF); op(0x80+(unsigned int)itok.number*8);
if((unsigned int)itok.number<=GS)if(cpu<3)cpu=3;
}
break;
case tk_longvar:
case tk_dwordvar:
// if(am32==FALSE)goto deflt;
i=2;
case tk_intvar:
case tk_wordvar:
i+=2;
CheckAllMassiv(bufrm,i,&strinf);
outseg(&itok,2);
op(0xFF); /* PUSH [word] */
op(0x30+itok.rm);
outaddress(&itok);
break;
case tk_number:
if(chip>=2/*&&(!(optimizespeed&&(chip==5||chip==6)))*/){ //28.03.07 19:04
if((itok.flag&f_reloc)==0&&short_ok(itok.number)){
op(0x6A); /* PUSH const */
op((unsigned int)itok.number);
}
else{
op(0x68); /* PUSH const */
if((itok.flag&f_reloc)!=0)AddReloc();
if(am32==FALSE)outword((unsigned int)itok.number);
else outdword(itok.number);
}
if(cpu<2)cpu=2;
}
else{
MovRegNum(r16,itok.flag&f_reloc,itok.number,EAX);
op(0x50);
}
break;
case tk_apioffset:
op(0x68); // PUSH const
AddApiToPost(itok.number);
break;
case tk_postnumber:
case tk_undefofs:
if(chip>=2&&(!(optimizespeed&&(chip==5||chip==6)))){
op(0x68); // PUSH const
if(tok==tk_undefofs)AddUndefOff(0,(char *)string);
else (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
if(am32==FALSE)outword((unsigned int)itok.number);
else outdword(itok.number);
break;
}
default:
deflt:
//if(tok==tk_new)puts("monovar default");
switch(vartype){
case tk_int: i=1;
case tk_word: do_e_axmath(i,r16,&ofsstr); break;
case tk_char: i=1;
case tk_byte: doalmath((char)i,&ofsstr); break;
default: beep(); break;
}
op(0x50); /* PUSH AX */
useAX=TRUE;
next=0;
break;
}
stackpar+=2+jj;
addESP+=2+jj;
}
else if(vartype<tk_qword){
#ifdef OPTVARCONST
CheckConstVar3(&tok,&itok,razr);
#endif
// printf("tok=%d %s\n",tok,itok.name);
switch(tok){ // long or dword or float
case tk_reg32:
op66(r32);
op(0x50+(unsigned int)itok.number);
break;
case tk_floatvar:
if(vartype==tk_float)goto pushmem;
case tk_qwordvar:
case tk_dwordvar:
case tk_longvar:
if(optimizespeed&&(chip==5||chip==6))goto def;
pushmem:
CheckAllMassiv(bufrm,4,&strinf);
op66(r32);
outseg(&itok,2);
op(0xFF); // PUSH [dword]
op(0x30+itok.rm);
// printf("push rm=%08X sib=%08X post=%u num=%08X rec=%08X flag=%08X %s\n",itok.rm,itok.sib,itok.post,itok.number,itok.rec,itok.flag,itok.name);
outaddress(&itok);
break;
case tk_number:
if(optimizespeed&&(chip==5||chip==6))goto def;
if(vartype==tk_float){
itok.number=doconstfloatmath();
next=0;
}
else if(itok.rm==tk_double)itok.fnumber=itok.dnumber;
op66(r32);
if((itok.flag&f_reloc)==0&&short_ok(itok.number,TRUE)!=0){
op(0x6A); // PUSH 8 extend to 32 bit
op((unsigned int)itok.number);
}
else{
op(0x68); // PUSH const
if((itok.flag&f_reloc)!=0)AddReloc();
outdword(itok.number);
}
break;
case tk_apioffset:
op66(r32);
op(0x68); // PUSH const
AddApiToPost(itok.number);
break;
case tk_postnumber:
case tk_undefofs:
if(optimizespeed&&(chip==5||chip==6))goto def;
op66(r32);
op(0x68); // PUSH const
if(tok==tk_undefofs)AddUndefOff(0,(char *)string);
else (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
outdword(itok.number);
break;
default:
def:
if(vartype==tk_float)doeaxfloatmath(tk_stackstart);
else{
if(vartype==tk_long)i=1;
// printf("tok=%d rm=%08X %s\n",tok,itok.rm,itok.name);
if(tok==tk_rmnumber&&am32&&bufrm==NULL&&strinf.bufstr==NULL&&
((itok.rm&7)!=4)&&((itok.rm&7)!=5)&&
((itok.rm&rm_mod11)==rm_mod00)&&itok.number==0){
op66(r32);
op(0x50+(itok.rm&7)); // PUSH rm reg
break;
}
do_e_axmath(i,r32,&ofsstr);
op66(r32);
op(0x50); // PUSH EAX
useAX=TRUE;
}
next=0;
break;
}
stackpar+=4;
addESP+=4;
if(cpu<3)cpu=3;
}
else{ //qword or double
#ifdef OPTVARCONST
CheckConstVar3(&tok,&itok,razr);
#endif
switch(tok){
case tk_reg64:
op66(r32);
op(0x50+(unsigned int)itok.number/256);
op66(r32);
op(0x50+(unsigned int)itok.number&255);
break;
case tk_doublevar:
case tk_qwordvar:
itok.number+=4;
compressoffset(&itok);
CheckAllMassiv(bufrm,8,&strinf);
for(i=0;i<2;i++){
op66(r32);
outseg(&itok,2);
op(0xFF); // PUSH [dword]
op(0x30+itok.rm);
outaddress(&itok);
if(i==1)break;
itok.number-=4;
compressoffset(&itok);
}
break;
case tk_reg32:
op66(r32);
outword(0x6A); // PUSH 8 extend to 32 bit
op66(r32);
op(0x50+(unsigned int)itok.number);
break;
case tk_number:
long long lnumber;
lnumber=itok.lnumber;
itok.lnumber=lnumber>>32;
for(i=0;i<2;i++){
op66(r32);
if((i==0||(itok.flag&f_reloc)==0)&&short_ok(itok.number,TRUE)!=0){
op(0x6A); // PUSH 8 extend to 32 bit
op((unsigned int)itok.number);
}
else{
op(0x68); // PUSH const
if(i==1&&(itok.flag&f_reloc)!=0)AddReloc();
outdword(itok.number);
}
if(i==1)break;
itok.number=lnumber;
}
break;
case tk_postnumber:
case tk_undefofs:
op66(r32);
outword(0x6A); // PUSH 8 extend to 32 bit
op66(r32);
op(0x68); // PUSH const
if(tok==tk_undefofs)AddUndefOff(0,(char *)string);
else (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
outdword(itok.number);
break;
default:
if(vartype==tk_double)doeaxfloatmath(tk_stackstart,0,4);
else{
op66(r32);
outword(0x6A);
do_e_axmath(0,r32,&ofsstr);
op66(r32);
op(0x50); // PUSH EAX
useAX=TRUE;
}
next=0;
break;
}
stackpar+=8;
addESP+=8;
if(cpu<3)cpu=3;
}
endparam1:
if(next)nexttok();
}
}
endparam:
if(ofsstr){
if(useAX)IDZToReg(ofsstr,retreg,getrazr(vartype));
free(ofsstr);
ofsstr=NULL;
}
if(tok==tk_camma){
ofsstr=GetLecsem(tk_camma,tk_closebracket);
getoperand();
}
else if(tok==tk_closebracket)done=1;
else{
expected(')');
done=1;
}
}
}
if(ofsstr){
if(useAX)IDZToReg(ofsstr,retreg,getrazr(vartype));
free(ofsstr);
}
if(ip!=-1&&bparam[ip]!=0&&bparam[ip]!='A'&&bparam[ip]!='V')missingpar();
free(bparam);
setzeroflag=FALSE;
addstack=oaddstack;
useinline=oinline;
return stackpar;
}
void CheckDir()
{
do{
switch(itok.number){
case d_ifdef:
case d_ifndef:
case d_endif:
case d_else:
case d_if:
case d_elif:
inptr2=inptr;
cha2=cha;
linenum2=linenumber;
directive();
inptr=inptr2;
cha=cha2;
break;
default:
FastTok(0);
break;
}
if(tok==tk_eof)break;
}while(tok==tk_question);
}
char *dynamic_var()
{
int start,size;
char *bstring;
int use_extract=FALSE;
#define TBUFSIZE 2048
#define MTBUFSIZE TBUFSIZE-IDLENGTH
int curbsize;
COM_MOD *ocur_mod;
bstring=(char *)MALLOC(TBUFSIZE);
curbsize=TBUFSIZE;
size=0;
if(tok2==tk_extract)use_extract=TRUE;
do{
start=inptr2-1;
ocur_mod=cur_mod;
if(size>(curbsize-IDLENGTH)){
curbsize+=TBUFSIZE;
bstring=(char *)REALLOC(bstring,curbsize);
}
nexttok();
if(tok==tk_openbrace){
bstring[size]='{';
size++;
do{
start=inptr2-1;
ocur_mod=cur_mod;
if(size>(curbsize-IDLENGTH)){
curbsize+=TBUFSIZE;
bstring=(char *)REALLOC(bstring,curbsize);
}
nexttok();
if(tok==tk_number){
switch(itok.rm){
case tk_double:
case tk_float:
sprintf(itok.name,"%e",itok.dnumber);
break;
case tk_qword:
sprintf(itok.name,"0x%X%08X",itok.lnumber>>16,itok.number);
break;
default:
sprintf(itok.name,"0x%X",itok.number);
break;
}
}
if(itok.name[0]!=0){
strcpy(bstring+size,itok.name);
size+=strlen(itok.name);
}
else{
if(cur_mod!=ocur_mod){
start=inptr2-2;
if(start<0)start=0;
}
strncpy(bstring+size,(char *)(input+start),inptr2-1-start);
size+=inptr2-1-start;
}
}while(tok!=tk_closebrace&&tok!=tk_eof);
if(tok!=tk_eof)continue;
}
if(tok==tk_number){
switch(itok.rm){
case tk_double:
case tk_float:
sprintf(itok.name,"%e",itok.dnumber);
break;
case tk_qword:
sprintf(itok.name,"0x%X%08X",itok.lnumber>>16,itok.number);
break;
default:
sprintf(itok.name,"0x%X",itok.number);
break;
}
}
if(itok.name[0]!=0){
strcpy(bstring+size,itok.name);
size+=strlen(itok.name);
}
else{
if(cur_mod!=ocur_mod){
start=inptr2-2;
if(start<0)start=0;
}
strncpy(bstring+size,(char *)(input+start),inptr2-1-start);
size+=inptr2-1-start;
}
if(tok==tk_eof){
unexpectedeof();
return NULL;
}
if(tok==tk_camma&&use_extract==FALSE)break;
}while(tok!=tk_semicolon);
// size++;
bstring[size]=0;
return bstring;
}
int SkipBlock()
{
for(int i=1;i!=0;){
FastTok(0);
if(tok==tk_question)CheckDir();
switch(tok){
case tk_eof: unexpectedeof(); return FALSE;
case tk_openbrace: i++; break;
case tk_closebrace: i--; break;
}
}
return TRUE;
}
int SkipParam()
{
for(int i=1;i!=0;){
FastTok(0);
if(tok==tk_question)CheckDir();
switch(tok){
case tk_openbracket: i++; break;
case tk_closebracket: i--; break;
case tk_eof: unexpectedeof(); return FALSE;
}
}
return TRUE;
}
int SkipLocalVar()
{
while(tok!=tk_openbrace&&tok!=tk_eof){
if(tok==tk_question){
CheckDir();
continue;
}
if(tok==tk_id&&(strcmp(itok.name,"struct")==0||strcmp(itok.name,"union")==0)){
do{
FastTok(0);
if(tok==tk_eof){
unexpectedeof();
return FALSE;
}
}while(tok!=tk_semicolon&&tok!=tk_openbrace);
if(tok==tk_openbrace){
FastTok(0);
if(!SkipBlock())return FALSE;
}
}
FastTok(1);
}
return TRUE;
}
SAVEPAR *SRparam(int save,SAVEPAR *par) //save or restore global param compiler
{
if(save){
par=(SAVEPAR *)MALLOC(sizeof(SAVEPAR));
par->ooptimizespeed=optimizespeed;
par->owarning= warning;
par->odbg= dbg;
par->odosstring= dosstring;
par->ouseinline= useinline;
par->oam32= am32;
par->oalignword= alignword;
par->oAlignCycle= AlignCycle;
par->oidasm= idasm; //àññ
par->ooptnumber= optnumber;
par->odivexpand= divexpand;
par->ooptstr= optstr; //îï
par->ochip= chip;
par->oaligncycle= aligncycle;
par->ouselea= uselea;
par->oregoverstack= regoverstack;
return par;
}
if(par){
optimizespeed=par->ooptimizespeed;
warning= par->owarning;
dbg= par->odbg;
dosstring= par->odosstring;
useinline= par->ouseinline;
am32= par->oam32;
alignword= par->oalignword;
AlignCycle= par->oAlignCycle;
idasm= par->oidasm; //àññ
optnumber= par->ooptnumber;
divexpand= par->odivexpand;
optstr= par->ooptstr; //îï
chip= par->ochip;
aligncycle= par->oaligncycle;
uselea = par->ouselea;
regoverstack= par->oregoverstack;
free(par);
}
return NULL;
}
void dynamic_proc()
{
int dtok,start,size,line;
ITOK otok;
char *bstring;
idrec *ptr;
_PROCINFO_ *pinfo;
if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
dtok=tok;
otok=itok;
line=linenum2;
switch(tok){
case tk_id:
case tk_ID:
string[0]=0;
case tk_undefproc:
case tk_declare:
break;
default: idalreadydefined(); break;
}
if(itok.flag&f_export)preerror("'_export' not use in dynamic functions");
bstring=BackString((char *)string);
start=inptr2-1;
pinfo=(_PROCINFO_ *)MALLOC(sizeof(_PROCINFO_));
if(itok.flag&f_classproc)pinfo->classteg=searchteg;
else pinfo->classteg=NULL;
pinfo->warn=warning;
pinfo->speed=optimizespeed;
pinfo->lst=(dbg&2)>>1;
pinfo->typestring=dosstring;
pinfo->inlinest=useinline;
pinfo->code32=am32;
pinfo->align=alignword;
pinfo->acycle=AlignCycle;
pinfo->idasm=idasm;
pinfo->opnum=optnumber;
pinfo->de=divexpand;
pinfo->ostring=optstr;
pinfo->chip=chip;
pinfo->sizeacycle=aligncycle;
pinfo->uselea=uselea;
pinfo->regoverstack=regoverstack;
nexttok();
if(dtok==tk_id||dtok==tk_ID){
param[0]=0;
if(tok2!=tk_closebracket&&(otok.flag&f_typeproc)==tp_fastcall){
nexttok(); //ïàðàìåòðû ðåãèñòðîâîé ïðîöåäóðû
declareparamreg();
free(bstring);
bstring=BackString((char *)param);
nexttok();
inptr=inptr2;
cha=cha2;
linenumber=linenum2;
}
}
else{
inptr=inptr2;
cha=cha2;
if(!SkipParam()){
free(bstring);
return;
}
FastTok(1);
}
if(tok==tk_semicolon)preerror("error declare dynamic function");
if((!SkipLocalVar())||(!SkipBlock())){
free(bstring);
return;
}
size=inptr-start+1;
inptr2=inptr;
cha2=cha;
linenum2=linenumber;
linenumber=line;
itok=otok;
strcpy((char *)string,bstring);
free(bstring);
bstring=(char *)MALLOC(size+1);
strncpy(bstring,(char *)(input+start),size);
bstring[size-1]=';';
bstring[size]=0;
// printf("tok=%d %s\n%s\n",dtok,itok.name,bstring);
itok.size=0;
tok=tk_proc;
itok.segm=DYNAMIC;
if(dtok==tk_id||dtok==tk_ID){
int i;
itok.number=secondcallnum++;
itok.type=tp_ucnovn;
if((i=FindUseName(itok.name))!=0)itok.segm=DYNAMIC_USED;
ptr=addtotree(itok.name);
if(i){
ptr->count=i;
ptr=itok.rec;
AddDynamicList(ptr);
}
}
else{
if(dtok==tk_undefproc)itok.segm=DYNAMIC_USED;
updatetree();
ptr=itok.rec;
//11.08.04 23:38
strcpy(ptr->recid,itok.name);
if(dtok==tk_undefproc&&(itok.flag&f_classproc))AddDynamicList(ptr);
}
ptr->line=linenumber;
ptr->file=currentfileinfo;
pinfo->buf=bstring;
ptr->pinfo=pinfo;
// ptr->sbuf=bstring;
// linenumber=linenum2;
if(searchteg)searchteg=NULL;
nexttok();
}
/* ======= procedure handling ends here ======== */
int macros(int expectedreturn)
{
int dynamicindex,actualreturn;
ITOK otok;
int orettype;
unsigned int oproctype;
int otok2;
unsigned int typep;
int snum=0;
actualreturn=(am32==FALSE?tk_word:tk_dword);
switch(tok){
case tk_ID:
case tk_id:
dynamicindex=NOT_DYNAMIC;
break;
case tk_proc:
case tk_undefproc:
case tk_declare:
dynamicindex=itok.segm;
actualreturn=itok.rm;
break;
default:
idalreadydefined();
return expectedreturn;
}
typep=itok.flag;
otok=itok;
if(tok==tk_ID)param[0]=0;
else strcpy(param,(char *)string);
nexttok();
orettype=returntype;
returntype=actualreturn; //01.08.04 14:45
oproctype=current_proc_type;
if(dynamicindex==NOT_DYNAMIC)doregparams();
else{
switch(typep&f_typeproc){
case tp_cdecl:
case tp_stdcall:
snum=swapparam();
break;
case tp_pascal:
snum=doparams();
break;
case tp_fastcall:
doregparams();
break;
}
}
itok=otok;
otok2=tok2;
if(dynamicindex==NOT_DYNAMIC){
if((actualreturn=includeit(0))==-1){
char holdstr[IDLENGTH+16];
sprintf(holdstr,"unknown macro '%s'",itok.name);
preerror(holdstr);
}
}
else insert_dynamic(TRUE);
if(actualreturn!=tk_void&&expectedreturn!=tk_ID)convert_returnvalue(expectedreturn,actualreturn);
returntype=orettype;
current_proc_type=oproctype;
if(snum!=0){
if(typep&f_retproc)warningdestroyflags();
CorrectStack(snum);
}
tok2=otok2;
return actualreturn;
}
int updatecall(unsigned int which,unsigned int where,unsigned int top)
/* update output with newly defined location, but only for addresses after
and including top. return the number of addresses updated.
which - àäðåñ ïðîöåäóðû
where - òåêóùèé àäðåñ*/
{
unsigned int count=0;
long hold;
int updates=0;
while(count<posts){
if(((postbuf+count)->type>=CALL_SHORT&&(postbuf+count)->type<=CONTINUE_32)&&
(postbuf+count)->num==which&&(postbuf+count)->loc>=top){
hold=(long)where-(long)(postbuf+count)->loc;
if((postbuf+count)->type>=CALL_NEAR&&(postbuf+count)->type<=CONTINUE_NEAR){ //NEAR
hold-=2;
*(unsigned short *)&output[(postbuf+count)->loc]=(unsigned short)hold;
}
else if((postbuf+count)->type>=CALL_32&&(postbuf+count)->type<=CONTINUE_32){//32-BIT
hold-=4;
*(unsigned long *)&output[(postbuf+count)->loc]=(unsigned long)hold;
}
else{ //SHORT
hold--; // CALL_SHORT
if(short_ok(hold))output[(postbuf+count)->loc]=(unsigned char)hold;
else{
if((postbuf+count)->type==BREAK_SHORT)preerror3("BREAK distance too large, use break",(postbuf+count)->line);
else if((postbuf+count)->type==CONTINUE_SHORT)preerror3("CONTINUE distance too large, use continue",(postbuf+count)->line);
else preerror3(shorterr,(postbuf+count)->line,(postbuf+count)->file);
}
}
if(hold<127){
if((postbuf+count)->type==JMP_NEAR||(postbuf+count)->type==JMP_32)warningjmp("GOTO",(postbuf+count)->line,(postbuf+count)->file);
if((postbuf+count)->type==BREAK_NEAR||(postbuf+count)->type==BREAK_32)warningjmp("BREAK",(postbuf+count)->line);
if((postbuf+count)->type==CONTINUE_NEAR||(postbuf+count)->type==CONTINUE_32)warningjmp("CONTINUE",(postbuf+count)->line);
}
killpost(count);
updates++;
}
else count++;
}
if(updates==1&&hold==0)return -1;
return(updates);
}
void define_locallabel()
{
FindOff(string,CS);
updatecall((unsigned int)updatelocalvar((char *)string,tk_number,outptr),outptr,procedure_start);
nextexpecting2(tk_colon);
RestoreStack();
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
}
void addacall(unsigned int idnum,unsigned char callkind)
{
CheckPosts();
(postbuf+posts)->num=idnum;
(postbuf+posts)->loc=outptr+1;
(postbuf+posts)->type=callkind;
(postbuf+posts)->line=(unsigned short)linenumber;
(postbuf+posts)->file=(unsigned short)currentfileinfo;
posts++;
}
unsigned int dofrom() // returns number of bytes read from FROM file
{
int filehandle;
long filesize;
if(tok!=tk_string){
stringexpected();
return(0);
}
filehandle=open((char *)string3,O_BINARY|O_RDONLY);
if(filehandle==-1){
unableopenfile((char *)string3);
return(0);
}
if((filesize=getfilelen(filehandle))==-1L){
preerror("Unable to determine FROM file size");
close(filehandle);
return(0);
}
if(am32==FALSE&&filesize>=0xFFFFL){
preerror("FROM file too large");
close(filehandle);
return(0);
}
LoadData(filesize,filehandle);
return filesize;
}
unsigned int doextract() // returns number of bytes EXTRACTed
{
unsigned int sizetoread;
int filehandle;
long filesize,startpos;
if(tok!=tk_string){
stringexpected();
return(0);
}
filehandle=open((char *)string3,O_BINARY|O_RDONLY);
if(filehandle==-1){
unableopenfile((char *)string3);
return(0);
}
nexttok();
expecting(tk_camma);
if(tok!=tk_number){
numexpected();
return(0);
}
startpos=doconstlongmath();
expecting(tk_camma);
if(tok!=tk_number){
numexpected();
return(0);
}
sizetoread=doconstlongmath();
if((filesize=getfilelen(filehandle))==-1L){
preerror("Unable to determine EXTRACT file size");
close(filehandle);
return(0);
}
if(filesize<=startpos){
preerror("EXTRACT offset exceeds the length of the file");
close(filehandle);
return(0);
}
if(sizetoread==0)sizetoread=filesize-startpos;
if(am32==FALSE&&sizetoread>=0xFFFFL){
preerror("Block to EXTRACT exceeds 64K");
close(filehandle);
return(0);
}
lseek(filehandle,startpos,0); // error checking required on this
LoadData(sizetoread,filehandle);
return sizetoread;
}
void LoadData(unsigned int size,int filehandle)
{
if(splitdata){
while(((unsigned long)size+(unsigned long)outptrdata)>=outdatasize){
if(CheckDataSize()==0)break;
}
if((unsigned int)read(filehandle,outputdata+outptrdata,size)!=size)errorreadingfile((char *)string3);
outptrdata+=size;
}
else{
while(((unsigned long)size+(unsigned long)outptr)>=outptrsize){
if(CheckCodeSize()==0)break;
}
if((unsigned int)read(filehandle,output+outptr,size)!=size)errorreadingfile((char *)string3);
outptr+=size;
outptrdata=outptr;
}
close(filehandle);
}
void op66(int ctok)
{
if((am32==FALSE&&ctok==r32)||(am32!=FALSE&&ctok==r16)){
if(cpu<3)cpu=3;
op(0x66);
}
}
int op67(int ctok)
{
if((am32==FALSE&&ctok==r32)||(am32!=FALSE&&ctok==r16)){
if(cpu<3)cpu=3;
op(0x67);
return TRUE;
}
return FALSE;
}
void outseg(ITOK *outtok,unsigned int locadd)
{
int rmm1;
rmm1=outtok->rm&7;
if(outtok->sib!=CODE16){
if(am32==FALSE)op(0x67);
if(rmm1==4)locadd++;
}
else if(am32!=FALSE)op(0x67);
switch(outtok->segm){
case ES: op(0x26); break;
case CS: op(0x2E); break;
case FS: op(0x64);
if(cpu<3)cpu=3;
break;
case GS: op(0x65);
if(cpu<3)cpu=3;
break;
case SS:
if(outtok->sib==CODE16){
if(rmm1!=2&&rmm1!=3&&!(rmm1==6&&outtok->rm!=6))op(0x36);
}
else{
if(rmm1==4){
rmm1=outtok->sib&7;
if(rmm1!=4){
if(rmm1==5){
if(outtok->rm==4)op(0x36);
break;
}
op(0x36);
}
}
else if(rmm1==5){
if(outtok->rm==5)op(0x36);
else break;
}
else op(0x36);
}
break;
case DS:
if(outtok->sib==CODE16){
if(rmm1==2||rmm1==3||(rmm1==6&&outtok->rm!=6))op(0x3E);
}
else{
if(rmm1==4){
rmm1=outtok->sib&7;
if(rmm1==4||(rmm1==5&&outtok->rm!=4))op(0x3e);
}
else if(rmm1==5&&outtok->rm!=5)op(0x3e);
}
}
CheckPosts();
if(outtok->post!=0&&outtok->post!=UNDEF_OFSET){
if((outtok->flag&f_extern)){
(postbuf+posts)->type=EXT_VAR;
(postbuf+posts)->num=outtok->number&0xFFFF;
outtok->number>>=16;
}
else if(outtok->post==USED_DIN_VAR){
(postbuf+posts)->type=(unsigned short)(am32==0?DIN_VAR:DIN_VAR32);
// printf("Add tok=%d %08X sib=%d %s\n",outtok->rec->rectok,outtok->rec->right,outtok->rec->recsib,outtok->rec->recid);
if(outtok->rec->rectok==tk_structvar&&outtok->rec->recsib==tp_gvar){
(postbuf+posts)->num=(int)outtok->rec;//02.09.05 17:10 ->right;
}
else (postbuf+posts)->num=(int)outtok->rec;
}
// else if((outtok->flag&f_dataseg))(postbuf+posts)->type=(unsigned short)(am32==0?DATABLOCK_VAR:DATABLOCK_VAR32);
else (postbuf+posts)->type=(unsigned short)(am32==0?POST_VAR:POST_VAR32);
(postbuf+posts)->loc=outptr+locadd;
posts++;
}
else if(outtok->flag&f_reloc){
(postbuf+posts)->type=(unsigned short)(am32==0?FIX_VAR:FIX_VAR32);
(postbuf+posts)->loc=outptr+locadd;
posts++;
}
}
int addpoststring(int segm,int len,int term) /* add a string to the post queue */
{
int i;
int returnvalue;
if((returnvalue=FindDublString(segm,len,term))!=-1)return returnvalue;
CheckPosts();
(postbuf+posts)->type=(unsigned short)(am32==FALSE?POST_STRING:POST_STRING32);
(postbuf+posts)->loc=(segm==CS?outptr:outptrdata);
(postbuf+posts)->num=segm;
posts++;
returnvalue=poststrptr;
if((int)(len+poststrptr+1)>=sbufstr){
sbufstr+=SIZEBUF;
bufstr=(char *)REALLOC(bufstr,sbufstr);
}
for(i=0;i<len;i++,poststrptr++)bufstr[poststrptr]=string[i];
switch(term&3){
case zero_term:
if(term&s_unicod){
poststrptr++;
bufstr[poststrptr]=0;
}
bufstr[poststrptr]=0;
poststrptr++;
break;
case dos_term:
if(term&s_unicod){
bufstr[poststrptr]=0;
poststrptr++;
}
bufstr[poststrptr]='$';
poststrptr++;
break;
}
return(returnvalue);
}
int FindDublString(int segm,unsigned int len,int term)
{
STRING_LIST ins,outs;
void *nextstr=liststring,*prevstr=NULL;
ins.len=len;
ins.next=NULL;
ins.type=term;
/* if(splitdata){ //ðàçäåëåíûå äàíûå è êîä
ins.plase=0;
ins.ofs=outptrdata;
}
else{*/
ins.plase=POST_STRING;
ins.ofs=poststrptr;
// }
while(nextstr!=NULL){
memcpy(&outs,nextstr,sizeof(STRING_LIST));
if(term==outs.type&&len<=outs.len){
char *instr,*outstr;
outstr=(char *)nextstr+sizeof(STRING_LIST)+outs.len-1;
instr=(char *)string+len-1;
char c;
int i,j;
for(i=len,j=outs.len;i!=0;j--,i--,instr--,outstr--){
c=*instr;
if(c!=*outstr)break;
}
if(i==0){ //íàéäåíà ñòðîêà
if(!optstr)return -1;
warningstring();
if(outs.plase==0){ //óæå â ôàéëå
AddReloc(DS);
return outs.ofs+j;
}
CheckPosts();
(postbuf+posts)->type=(unsigned short)(am32==FALSE?POST_STRING:POST_STRING32);
(postbuf+posts)->loc=(segm==CS?outptr:outptrdata);
(postbuf+posts)->num=segm;
posts++;
return outs.ofs+j;
}
}
prevstr=nextstr;
nextstr=outs.next;
}
outs.next=(void *)MALLOC(sizeof(STRING_LIST)+len);
memcpy(outs.next,&ins,sizeof(STRING_LIST));
if(len!=0)memcpy((char *)outs.next+sizeof(STRING_LIST),&string,len);
if(prevstr!=NULL)memcpy(prevstr,&outs,sizeof(STRING_LIST));
else liststring=outs.next;
return -1;
}
void killpost(unsigned int poz)
{
posts--;
memcpy((postinfo *)(postbuf+poz),(postinfo *)(postbuf+posts),sizeof(postinfo));
}
void dopoststrings()
{
unsigned int addvalue,i;
if(poststrptr==0)return;
if(splitdata){
addvalue=outptrdata;
if((outptrdata+poststrptr)>=outdatasize)CheckDataSize();
}
else{
addvalue=outptr;
if((outptr+poststrptr)>=outptrsize)CheckCodeSize();
}
datasize+=poststrptr;
if(dbg&2)AddDataNullLine(3);
memcpy(&outputdata[outptrdata],bufstr,poststrptr);
outptrdata+=poststrptr;
if(!splitdata)outptr=outptrdata;
for(i=0;i<posts;i++){
int segm=(postbuf+i)->num;
if((postbuf+i)->type==POST_STRING){
if(segm==CS)*(unsigned short *)&output[(postbuf+i)->loc]+=(unsigned short)addvalue;
else *(unsigned short *)&outputdata[(postbuf+i)->loc]+=(unsigned short)addvalue;
if(splitdata&&modelmem==TINY)(postbuf+i)->type=(unsigned short)DATABLOCK_VAR;
else if(FixUp==FALSE)killpost(i--);
else (postbuf+i)->type=(unsigned short)(segm==DS?FIX_VAR:FIX_CODE);
}
else if((postbuf+i)->type==POST_STRING32){
if(segm==CS)*(unsigned int *)&output[(postbuf+i)->loc]+=addvalue;
else *(unsigned int *)&outputdata[(postbuf+i)->loc]+=addvalue;
if(splitdata&&modelmem==TINY)(postbuf+i)->type=(unsigned short)DATABLOCK_VAR32;
else if(FixUp==FALSE)killpost(i--);
else (postbuf+i)->type=(unsigned short)(segm==DS?FIX_VAR32:FIX_CODE32);
}
}
poststrptr=0; /* reset the poststrptr */
STRING_LIST ins;
void *nextstr=liststring;
while(nextstr!=NULL){
memcpy(&ins,nextstr,sizeof(STRING_LIST));
if(ins.plase!=0){
ins.plase=0;
ins.ofs+=addvalue;
memcpy(nextstr,&ins,sizeof(STRING_LIST));
}
nextstr=ins.next;
}
if(dbg&2)AddCodeNullLine();
}
void insertcode() // force code procedure at specified location
{
nexttok();
testInitVar(FALSE);
if((itok.flag&f_extern)!=0){
notexternfun();
return;
}
int tproc=itok.flag&f_typeproc;
setuprm();
switch(tok){
case tk_undefproc:
case tk_declare:
tok=tk_proc;
itok.number=outptr;
updatecall((unsigned int)updatetree(),(unsigned int)itok.number,0);
if(tproc==tp_fastcall){
if(includeit(1)==-1)thisundefined(itok.name);
}
else if(includeproc()==-1)thisundefined(itok.name);
break;
case tk_id:
case tk_ID:
tok=tk_proc;
itok.number=outptr;
string[0]=0;
itok.type=tp_ucnovn;
addtotree(itok.name);
if(tproc==tp_fastcall){
if(includeit(1)==-1)thisundefined(itok.name);
}
else if(includeproc()==-1)thisundefined(itok.name);
break;
case tk_proc:
if(itok.segm<NOT_DYNAMIC)insert_dynamic();
else preerror("Function already inserted in code");
break;
default: idalreadydefined(); break;
}
nextexpecting2(tk_openbracket);
while(tok!=tk_eof&&tok!=tk_closebracket)nexttok();
if(tok==tk_eof)unexpectedeof();
else nextseminext();
}
/************ some of the dynamic procedure support functions *************/
void insert_dynamic(int insert)
{
unsigned char *oinput;
int oinptr;
unsigned char ocha;
int oline;
int ofile;
char *ostartline;
int oendinptr;
structteg *osearchteg;
int oinsert;
_PROCINFO_ *pinfo;
SAVEPAR *par;
if(insert){
osearchteg=searchteg;
searchteg=NULL;
}
// printf("cur_mod=%08X\n",cur_mod);
oinsert=insert;
oinput=input;
oinptr=inptr2;
ocha=cha2;
oline=linenum2;
ofile=currentfileinfo;
(startfileinfo+currentfileinfo)->stlist=staticlist;
oendinptr=endinptr;
endoffile=0;
ostartline=startline;
idrec *ptr=itok.rec;
pinfo=ptr->pinfo;
input=(unsigned char *)pinfo->buf;
inptr2=1;
startline=(char *)input;
cha2=input[0];
endinptr=strlen((char *)input);
endinput=startline+endinptr;
linenumber=linenum2=ptr->line;
currentfileinfo=ptr->file;
staticlist=(startfileinfo+currentfileinfo)->stlist;
par=SRparam(TRUE,NULL);
warning=pinfo->warn;
optimizespeed=pinfo->speed;
dosstring=pinfo->typestring;
useinline=pinfo->inlinest;
am32=pinfo->code32;
alignword=pinfo->align;
AlignCycle=pinfo->acycle;
idasm=pinfo->idasm;
optnumber=pinfo->opnum;
divexpand=pinfo->de;
optstr=pinfo->ostring;
chip=pinfo->chip;
aligncycle=pinfo->sizeacycle;
uselea=pinfo->uselea;
regoverstack=pinfo->regoverstack;
if(pinfo->classteg!=NULL){
/*if((itok.flag&f_static)==0)*/searchteg=(structteg *)pinfo->classteg;
insert=0;
}
if(pinfo->lst)dbg|=2;
else dbg&=0xFD;
// puts(itok.name);
if(!insert){
procedure_start=outptr;
if(dbg){
if(dbg&2){
char m1[130];
//11.08.04 23:39
// if(searchteg)sprintf(m1,"%s::%s()",searchteg->name,itok.name);
// else sprintf(m1,"%s()",itok.name);
sprintf(m1,"%s()",itok.name);
AddCodeNullLine(m1);
}
else AddLine();
}
if(AlignProc)AlignCD(CS,alignproc);
// puts((char *)input);
if(pinfo->classteg==NULL)itok.flag&=~f_static;
setproc(1);
dopoststrings();
}
else insertproc();
input=oinput;
inptr2=oinptr;
cha2=ocha;
linenum2=oline;
// printf("cur_mod=%08X\n",cur_mod);
(startfileinfo+currentfileinfo)->stlist=staticlist;
currentfileinfo=ofile;
staticlist=(startfileinfo+currentfileinfo)->stlist;
endinptr=oendinptr;
endoffile=0;
startline=ostartline;
SRparam(FALSE,par);
if(oinsert)searchteg=osearchteg;
else searchteg=NULL;
// if(insert)nexttok();
// printf("tok=%d %08X\n",tok,cur_mod);
}
idrec *addtotree(char *keystring)//äîáàâèòü ñòðîêó â äåðåâî
{
struct idrec *ptr,*newptr;
int cmpresult;
//âûäåëèòü ïàìÿòü ïîä íîâóþ ïðîö
newptr=(struct idrec *)MALLOC(sizeof(struct idrec));
ptr=(itok.flag&f_static)!=0?staticlist:treestart; //íà÷àëî äåðåâà
if(ptr==NULL)((itok.flag&f_static)!=0?staticlist:treestart)=newptr;//íà÷àëî äåðåâà
else{ //ïîèñê ñòðîêè â äåðåâå
while(((cmpresult=strcmp(ptr->recid,keystring))<0&&ptr->left!=NULL)||
(cmpresult>0&&ptr->right!=NULL))ptr=(cmpresult<0?ptr->left:ptr->right);
(cmpresult<0?ptr->left:ptr->right)=newptr;
}
strcpy(newptr->recid,keystring);//ñêîïèð íàçâàíèå
newptr->newid=NULL;
if(string[0]!=0)newptr->newid=BackString((char *)string);
newptr->rectok=tok;
newptr->recnumber=itok.number;
newptr->recsegm=itok.segm;
newptr->recrm=itok.rm;
newptr->recpost=itok.post;
newptr->flag=itok.flag;
newptr->recsize=itok.size;
newptr->left=newptr->right=NULL;
newptr->sbuf=NULL;
newptr->recsib=itok.sib;
newptr->line=linenumber;
newptr->file=currentfileinfo;
newptr->count=0;
newptr->type=itok.type;
newptr->npointr=itok.npointr;
itok.rec=newptr;
return newptr;
}
long updatetree() // returns the old number value
{
struct idrec *ptr;
long hold;
ptr=itok.rec;
if(ptr==0)internalerror("address record not found when update tree");
if(ptr->newid)free(ptr->newid);
ptr->newid=NULL;
if(string[0]!=0)ptr->newid=BackString((char *)string);
ptr->rectok=tok;
hold=ptr->recnumber;
ptr->recnumber=itok.number;
ptr->recsegm=itok.segm;
ptr->recrm=itok.rm;
ptr->flag=itok.flag;
ptr->recsize=itok.size;
ptr->recsib=itok.sib;
return hold;
}
/* --------------- local variable handling starts here ----------------- */
unsigned int updatelocalvar(char *str,int tok4,unsigned int num)
{
struct localrec *ptr;
unsigned int retvalue;
treelocalrec *ntlr=tlr;
while(ntlr&&ntlr->level>1)ntlr=ntlr->next;
for(ptr=ntlr->lrec;;ptr=ptr->rec.next){
if(strcmp(ptr->rec.recid,str)==0){
retvalue=ptr->rec.recnumber;
ptr->rec.rectok=tok4;
ptr->rec.recnumber=num;
break;
}
if(ptr->rec.next==NULL)break;
}
return(retvalue);
}
localrec * addlocalvar(char *str,int tok4,unsigned int num,int addmain)
{
localrec *ptr,*newptr;
localrec *uptr;
treelocalrec *ntlr;
if(addmain){
ntlr=tlr;
while(ntlr&&ntlr->level>1)ntlr=ntlr->next;
uptr=ntlr->lrec;
}
else uptr=tlr->lrec;
newptr=(struct localrec *)MALLOC(sizeof(struct localrec));
if(uptr==NULL){
if(addmain)ntlr->lrec=newptr;
else tlr->lrec=newptr;
}
else{
ptr=uptr;
while(ptr->rec.next!=NULL)ptr=ptr->rec.next;
ptr->rec.next=newptr;
}
strcpy(newptr->rec.recid,str);
newptr->rec.rectok=tok4;
newptr->rec.recnumber=num;
newptr->rec.next=NULL;
newptr->rec.right=NULL;
newptr->rec.recsize=0;
newptr->fuse=NOTINITVAR;
newptr->rec.type=tp_ucnovn;
newptr->rec.flag=0;
newptr->rec.npointr=0;
newptr->rec.recpost=LOCAL;
newptr->li.count=0;
newptr->li.start=linenumber;
return newptr;
}
void KillTegList(structteg *tteg)
{
if(tteg){
KillTegList(tteg->left);
KillTegList(tteg->right);
if(tteg->baza)free(tteg->baza);
free(tteg);
}
}
void killlocals(/*int endp*/)
/* Clear and free the local linked list, check for any unresolved local
jump labels. */
{
/* if(endp){
dopoststrings();
for(int i=0;i<posts;i++){
// printf("%d type=%d num=%08X\n",i+1,(postbuf+i)->type,(postbuf+i)->num);
if((postbuf+i)->type==DIN_VAR||(postbuf+i)->type==DIN_VAR32){
idrec *ptr=(idrec *)(postbuf+i)->num;
// printf("sib=%d num=%08X %s\n",ptr->recsib,ptr->recnumber,ptr->recid);
if(ptr->recsib!=tp_gvar)continue;
puts("recsib=tp_gvar");
if(ptr->recpost==USED_DIN_VAR){
unsigned int otok,otok2;
ITOK oitok;
oitok=itok;
otok=tok;
otok2=tok2;
setdindata(ptr,i);
itok=oitok;
tok=otok;
tok2=otok2;
}
else{
if((postbuf+i)->type==DIN_VAR)*(unsigned short *)&output[(postbuf+i)->loc]+=(unsigned short)(ptr->recnumber);
else *(unsigned long *)&output[(postbuf+i)->loc]+=ptr->recnumber;
}
if(FixUp)(postbuf+i)->type=(unsigned short)((postbuf+i)->type==DIN_VAR?FIX_VAR:FIX_VAR32);
else killpost(i--);
}
}
dopoststrings();
}
*/
treelocalrec *ftlr,*ftlr1;
struct localrec *ptr, *ptr1;
for(ftlr=btlr;ftlr!=NULL;){
ftlr1=ftlr;
for(ptr=ftlr->lrec;ptr!=NULL;){
ptr1=ptr;
if(ptr->rec.rectok==tk_locallabel){ /* check for unresolved labels */
char holdstr[32+IDLENGTH];
sprintf(holdstr,"local jump label '%s' unresolved",ptr1->rec.recid);
preerror(holdstr);
}
// printf("type=%d post=%08X %s\n",ptr->rec.type,ptr->rec.recpost,ptr->rec.recid);
if(ptr->rec.rectok==tk_structvar){
if(ptr->rec.count==0){
warningnotused(ptr->rec.recid,5);
if(ptr->rec.type==tp_gvar)free(ptr->rec.sbuf);
}
}
else if(ptr->fuse<USEDVAR){
if(ptr->rec.type==tp_localvar||ptr->rec.type==tp_postvar||ptr->rec.type==tp_gvar)warningnotused(ptr->rec.recid,3);
else if(ptr->rec.type==tp_paramvar)warningnotused(ptr->rec.recid,4);
if(ptr->rec.type==tp_gvar)free(ptr->rec.sbuf);
}
ptr=ptr->rec.next;
if(ptr1->rec.recpost!=USED_DIN_VAR)free(ptr1);
}
ftlr=ftlr->next;
free(ftlr1);
}
btlr=NULL;
paramsize=0;
localsize=0;
KillTegList(ltegtree);
ltegtree=NULL;
}
/* ================ input procedures start ================= */
int loadinputfile(char *inpfile) //ñ÷èòûâàíèå ôàéëà â ïàìÿòü
{
unsigned long size;
int filehandle;
if((filehandle=open(inpfile,O_BINARY|O_RDONLY))==-1)return -2;
if((size=getfilelen(filehandle))==0){
badinfile(inpfile);
close(filehandle);
return(-1);
}
if(totalmodule==0){
startfileinfo=(struct FILEINFO *)MALLOC(sizeof(FILEINFO));
totalmodule=1;
currentfileinfo=0;
}
else{ //ïîèñê åìåíè ôàéëà â ñïèñêå îáðàáîòàííûõ
for(currentfileinfo=0;currentfileinfo<totalmodule;currentfileinfo++){
if(stricmp(inpfile,(startfileinfo+currentfileinfo)->filename)==0)break;
}
if(currentfileinfo!=totalmodule){
if(crif!=FALSE)return 1;
goto cont_load;
}
totalmodule++;
startfileinfo=(struct FILEINFO *)REALLOC(startfileinfo,sizeof(FILEINFO)*(totalmodule));
}
(startfileinfo+currentfileinfo)->stlist=NULL;
(startfileinfo+currentfileinfo)->filename=(char *)MALLOC(strlen(inpfile)+1);
strcpy((startfileinfo+currentfileinfo)->filename,inpfile);
(startfileinfo+currentfileinfo)->numdline=0;
//GetFileTime(filehandle,&(startfileinfo+currentfileinfo)->time); // bug
// getftime(filehandle,&(startfileinfo+currentfileinfo)->time);
cont_load:
staticlist=(startfileinfo+currentfileinfo)->stlist;
input=(unsigned char *)MALLOC(size+1);
printf("%08lX %s %lu\n",input,inpfile,size);
if((endinptr=read(filehandle,input,size))!=size){
printf("%d\n",endinptr);
errorreadingfile(inpfile);
close(filehandle);
return(-1);
}
close(filehandle);
return(0);
}
void notnegit(int notneg)
/* produce NOT .. or NEG .. */
{
int wordadd=0,i=0;
getoperand();
switch(tok){
case tk_reg: wordadd=1; op66(r16);
ClearReg(itok.number);
case tk_beg:
if(optimizespeed&&(chip==5||chip==6)){
if(wordadd==0&&itok.number==AL)outword(0xFF34);
else{
if(wordadd)op(0x83);
else op(0x80);
op(0xF0+itok.number);
op(0xFF);
}
if(notneg){
if(wordadd){
op66(r16);
op(0x40+itok.number);
}
else{
op(0xFE);
op(0xC0+itok.number);
}
}
}
else{
op(0xF6+wordadd);
op(0xD0+notneg+itok.number);
}
if(wordadd==0)ClearReg(itok.number&3);
break;
case tk_wordvar:
case tk_intvar: wordadd=1;
i=1;
case tk_bytevar:
case tk_charvar:
i++;
CheckAllMassiv(bufrm,i,&strinf);
if(wordadd)op66(r16);
outseg(&itok,2);
if((!notneg)&&optimizespeed&&(chip==5||chip==6)){
op(wordadd!=0?0x83:0x80);
op(0x30+itok.rm);
outaddress(&itok);
op(0xFF);
}
else{
op(0xF6+wordadd);
op(0x10+notneg+itok.rm);
outaddress(&itok);
}
KillVar(itok.name);
break;
case tk_reg32:
op66(r32);
if(optimizespeed&&(chip==5||chip==6)){
op(0x83);
outword(0xFFF0+itok.number);
if(notneg){
op66(r32);
op(0x40+itok.number);
}
}
else{
op(0xF7);
op(0xD0+notneg+itok.number);
}
if(cpu<3)cpu=3;
ClearReg(itok.number);
break;
case tk_reg64:
int r1,r2;
r1=itok.number&255;
r2=itok.number/256;
op66(r32);
op(0xF7);
op(0xD0+notneg+r2); // NEG reg
op66(r32);
op(0xF7);
op(0xD0+notneg+r1); // NEG reg
op66(r32);
op(0x83);
op(0xD8+r2);
op(0);
ClearReg(r1);
ClearReg(r2);
break;
case tk_longvar:
case tk_dwordvar:
CheckAllMassiv(bufrm,4,&strinf);
op66(r32);
outseg(&itok,2);
if((!notneg)&&optimizespeed&&(chip==5||chip==6)){
op(0x83);
op(0x30+itok.rm);
outaddress(&itok);
op(0xFF);
}
else{
op(0xF7);
op(0x10+notneg+itok.rm);
outaddress(&itok);
}
if(cpu<3)cpu=3;
KillVar(itok.name);
break;
case tk_qword:
itok.number+=4;
compressoffset(&itok);
for(i=0;i<2;i++){
CheckAllMassiv(bufrm,8,&strinf);
op66(r32);
outseg(&itok,2);
op(0xF7);
op(0x10+notneg+itok.rm);
outaddress(&itok);
if(i==1)break;
itok.number-=4;
compressoffset(&itok);
}
itok.number-=4;
compressoffset(&itok);
CheckAllMassiv(bufrm,8,&strinf);
op66(r32);
outseg(&itok,2);
op(0x83); op(0x18+itok.rm);
outaddress(&itok);
op(0);
KillVar(itok.name);
if(cpu<3)cpu=3;
break;
case tk_doublevar:
i=4;
case tk_floatvar:
if(notneg!=8)illegalfloat();
CheckAllMassiv(bufrm,4+i,&strinf);
outseg(&itok,2); //fld var
op(0xd9+i);
op(itok.rm);
outaddress(&itok);
outword(0xe0d9); //fchs
outseg(&itok,2);//fstp var
op(0xd9+i);
op(itok.rm+0x18);
outaddress(&itok);
fwait3();
break;
default: varexpected(0);
}
}
void setreturn()
{
if(numreturn){
unsigned int pos,dist;
//int j=0;
//restart:
for(int i=0;i<numreturn;i++){
// if(!(listreturn+i)->use)continue;
pos=(listreturn+i)->loc;
dist=outptr-pos;
if((listreturn+i)->type==tk_RETURN){
dist--;
// if(dist){
if(dist>127/*&&i>=j*/)jumperror((listreturn+i)->line,mesRETURN);
output[pos]=(unsigned char)dist;
/* }
else{
outptr-=2;
j=i;
(listreturn+i)->use=FALSE;
goto restart;
}*/
}
else{
dist-=(am32==0?2:4);
// if(dist){
if(dist<128/*&&i>=j*/)warningjmp(mesRETURN,(listreturn+i)->line,currentfileinfo);
if(am32)*(unsigned long *)&output[pos]=dist;
else*(unsigned short *)&output[pos]=(unsigned short)dist;
/* }
else{
outptr-=3;
if(am32)outptr-=2;
j=i;
(listreturn+i)->use=FALSE;
goto restart;
}*/
}
}
free(listreturn);
listreturn=NULL;
numreturn=0;
}
}
void RestoreSaveReg()
{
if(psavereg->all){
op(0x61);
addESP-=am32==FALSE?16:32;
}
else{
for(int i=7;i>=0;i--){
if(psavereg->reg[i]){
op66(psavereg->reg[i]);
op(0x58+i);
addESP-=am32==FALSE?2:4;
}
}
}
}
void AddRetList(int pos,int line,int type)
{
if(numreturn==0)listreturn=(RETLIST *)MALLOC(sizeof(RETLIST));
else listreturn=(RETLIST *)REALLOC(listreturn,sizeof(RETLIST)*(numreturn+1));
(listreturn+numreturn)->loc=pos;
(listreturn+numreturn)->line=line;
(listreturn+numreturn)->type=type;
// (listreturn+numreturn)->use=TRUE;
if(type==tk_return)jumploc0();
else outword(0x00EB); // JMP SHORT
numreturn++;
}
void RetProc()
{
if((current_proc_type&f_far)){
if((current_proc_type&f_typeproc)==tp_cdecl)retf();
else{
if(paramsize==0)retf(); /* RETF */
else{
op(0xCA);
outword(paramsize);
}
}
}
else{
if((current_proc_type&f_typeproc)==tp_cdecl)ret();
else if(current_proc_type==f_interrupt)op(0xCF);//interrupt procedure IRET
else{
if(paramsize==0)ret(); /* RET */
else{
op(0xC2);
outword(paramsize);
}
}
}
}
void doreturn(int typer) /* do return(...); */
{
char sign=0;
int line=linenumber;
char *ofsstr=NULL;
int i;
unsigned int oaddESP=addESP;
if(tok2==tk_openbracket)nexttok();
if((ofsstr=GetLecsem(tk_closebracket,tk_semicolon))){
int retreg;
int razr=getrazr(returntype);
if((retreg=CheckIDZReg(ofsstr,AX,razr))!=NOINREG){
GetEndLex(tk_closebracket,tk_semicolon);
if(razr==r16)tok=tk_reg;
else if(razr==r32)tok=tk_reg32;
else tok=tk_beg;
itok.number=retreg==SKIPREG?AX:retreg;
goto nn1;
}
}
getoperand();
if(tok!=tk_closebracket&&tok!=tk_semicolon){
nn1:
switch(returntype){
case tk_int: sign=1;
case tk_word: do_e_axmath(sign,r16,&ofsstr); break;
case tk_char: sign=1;
case tk_byte: doalmath(sign,&ofsstr); break;
case tk_long: sign=1;
case tk_dword: do_e_axmath(sign,r32,&ofsstr); break;
case tk_qword:
getintoreg64(EAX|(EDX*256));
if(itok.type!=tp_stopper&&tok!=tk_eof&&itok.type!=tp_compare)doregmath64(EAX|(EDX*256));
break;
case tk_void: retvoid(); nexttok(); break;
case tk_double:
/* if(tok2==tk_closebracket)doregmath64(EAX|(EDX*256));
else doeaxfloatmath(tk_reg64);
break;*/
case tk_fpust:
doeaxfloatmath(tk_fpust);
break;
case tk_float:
if(itok2.type==tp_stopper&&(tok==tk_floatvar||tok==tk_number)){
if(tok==tk_floatvar){
tok=tk_dwordvar;
do_e_axmath(0,r32,&ofsstr);
}
else doeaxfloatmath(tk_reg32,0,0);
}
else{
doeaxfloatmath(tk_stackstart,0,0);
op66(r32);
op(0x58); //pop eax
}
break;
// default:
// printf("returntype=%d\n",returntype);
}
}
if(tok==tk_closebracket)nexttok();
seminext();
if(ofsstr)free(ofsstr);
clearregstat();
#ifdef OPTVARCONST
ClearLVIC();
#endif
if(typer!=tokens){
i=(am32==0?2:4);
if(typer==tk_RETURN)i=1;
if(paramsize||localsize)i--;
if(insertmode||((!optimizespeed)&&paramsize&&
(current_proc_type&f_typeproc)!=tp_cdecl)||psavereg->size>i){
if(numblocks>1){ //çàìåíèòü return íà goto
AddRetList(outptr+1,line,typer);
retproc=TRUE;
return;
}
else{
setreturn();
if(insertmode)return;
}
}
}
if(numblocks==1)setreturn(); //06.09.04 22:20
if(!inlineflag)leaveproc();
else{
AutoDestructor();
RestoreStack();
RestoreSaveReg();
RetProc();
}
retproc=TRUE;
if(numblocks>1||(numblocks==1&&tok!=tk_closebrace))addESP=oaddESP;
}
int IsSaveReg()
{
if(psavereg->all)return TRUE;
for(int i=7;i>=0;i--){
if(psavereg->reg[i])return TRUE;
}
return FALSE;
}
void leaveproc()
{
AutoDestructor();
RestoreStack();
RestoreSaveReg();
if(ESPloc==FALSE||am32==FALSE){
if(localsize)Leave();
else if(paramsize)op(0x5D); /* POP BP */
else if(initBP)Leave();
}
else if(localsize){
if(short_ok(localsize,TRUE)){
outword(0xC483);
op(localsize);
}
else{
outword(0xC481);
outdword(localsize);
}
}
RetProc();
}
DLLLIST *FindDLL()
{
DLLLIST *newdll;
if(listdll!=NULL){ //ñïèñîê DLL íå ïóñò
for(newdll=listdll;stricmp(newdll->name,(char *)string)!=0;newdll=newdll->next){
if(newdll->next==NULL){ //ïîñëåäíÿÿ â ñïèñêå
newdll->next=(DLLLIST *)MALLOC(sizeof(DLLLIST));//ñîçäàòü íîâóþ
newdll=newdll->next;
newdll->next=NULL;
newdll->num=0;
newdll->list=NULL;
strcpy(newdll->name,(char *)string);
break;
}
}
}
else{
listdll=newdll=(DLLLIST *)MALLOC(sizeof(DLLLIST));
newdll->next=NULL;
newdll->num=0;
newdll->list=NULL;
strcpy(newdll->name,(char *)string);
}
return newdll;
}
void declareextern()
{
int next;
nexttok();
if(comfile==file_w32&&strcmp(itok.name,"WINAPI")==0){
nexttok();
if(tok!=tk_string)stringexpected();
DLLLIST *newdll;
newdll=FindDLL();
nextexpecting2(tk_openbrace); //îòêðûòèå ñïèñêà ïðîöåäóð
APIPROC *listapi=newdll->list;
returntype=tk_declare;
do{
if(tok==tk_enum)doenum();
else if(tok==tk_struct)InitStruct();
else{
next=TRUE;
if(testInitVar(FALSE)!=FALSE)preerror("Error declare WINAPI");
if(itok.rm==tokens)itok.rm=tk_dword;
if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
ITOK hitok=itok;
int htok=tok;
param[0]=0;
hitok.sib=hitok.size=-1;
if(tok2==tk_period){
nexttok();
if(tok2==tk_number){
nexttok();
hitok.sib=itok.number;
}
}
if(tok2==tk_at){
nexttok();
if(tok2==tk_number){
nexttok();
hitok.size=itok.number;
}
}
else{
nextexpecting2(tk_openbracket);
if((hitok.flag&f_typeproc)==tp_fastcall)declareparamreg();
else declareparamstack();
}
if(htok==tk_id||htok==tk_ID){
tok=tk_apiproc;
itok=hitok;
itok.number=secondcallnum++;
itok.segm=NOT_DYNAMIC;
itok.post=dEBX|dEDI|dESI; //05.09.04 01:36
strcpy((char *)string,param);
itok.type=tp_ucnovn;
if(newdll->num==0)listapi=(APIPROC *)MALLOC(sizeof(APIPROC)); //ïåðâàÿ â ñïèñêå
else listapi=(APIPROC *)REALLOC(listapi,sizeof(APIPROC)*(newdll->num+1));
(listapi+newdll->num)->recapi=addtotree(itok.name);
if(tok2==tk_openbracket){
next=0;
nexttok();
IsUses((listapi+newdll->num)->recapi);
}
newdll->num++;
}
else warningdefined(hitok.name);
if(next)nexttok();
seminext();
}
}while(tok!=tk_closebrace);
returntype=tokens;
newdll->list=listapi;
nexttok();
}
else{
itok.flag=f_extern;
switch(tok){
case tk_far:
case tk_cdecl:
case tk_pascal:
case tk_stdcall:
case tk_fastcall:
case tk_declare:
case tk_undefproc:
case tk_ID:
case tk_id:
case tk_float:
case tk_long:
case tk_dword:
case tk_word:
case tk_byte:
case tk_char:
case tk_int:
case tk_void:
int j;
if((j=testInitVar())==FALSE)define_procedure();
else if(j==TRUE)globalvar();
break;
case tk_struct: InitStruct(); break;
default: preerror("Error declare extern");
}
if((!fobj)&&(!sobj))preerror("extern using only for compilation obj files");
}
}
int testInitVar(int checkaldef)
{
unsigned int ffar=0;
unsigned int fexport=0;
unsigned int tproc=0;
unsigned int fretproc=0;
int rettype=tokens;
unsigned int flag=itok.flag;
unsigned int npointr=0;
if(fstatic){
flag|=f_static;
fstatic=FALSE;
}
if(tok==tk_inline){
flag=f_inline;
nexttok();
}
for(;;){
if(tok==tk_far)ffar=f_far;
else if(tok==tk_export)fexport=f_export;
else if(tok>=tk_pascal&&tok<=tk_fastcall)tproc=tok;
else if((tok>=tk_void&&tok<=tk_double)||tok==tk_fpust){
if(rettype!=tokens)unknowntype();
rettype=tok;
}
else if(tok==tk_id){
if(CheckDef())continue;
if(tok2==tk_dblcolon)goto classdecl;
if(tproc==0)tproc=(comfile==file_w32?tp_stdcall:tp_pascal); //òèï ïðîö ïî óìîë÷àíèþ
else tproc=(tproc-tk_pascal)*2;
break;
}
else if(tok==tk_ID){
if(CheckDef())continue;
if(tok2==tk_dblcolon){
classdecl:
itok.flag=(unsigned int)(flag|ffar|fexport|fretproc|f_classproc);
itok.rm=rettype;
itok.npointr=(unsigned short)npointr;
doclassproc(tproc);
return 2;
}
if(tproc==0)tproc=tp_fastcall; //òèï ïðîö ïî óìîë÷àíèþ
else tproc=(tproc-tk_pascal)*2;
break;
}
else if(tok==tk_undefproc||tok==tk_declare/*||tok==tk_apiproc*/){
flag|=itok.flag; //new 18.04.07 12:19
if(tproc==0){
if(CidOrID()==tk_ID)tproc=tp_fastcall;
else tproc=(comfile==file_w32?tp_stdcall:tp_pascal);
}
else tproc=(tproc-tk_pascal)*2; // 17.09.05 17:06
if((flag&f_extern)!=0||tproc!=(itok.flag&f_typeproc)||
ffar!=(itok.flag&f_far)||(unsigned short)npointr!=itok.npointr||
((flag&f_static)&&(itok.flag&f_static)==0)){
if(strcmp(itok.name,"main")){
if(rettype==itok.rm||(rettype==tokens&&(itok.rm==(am32==0?tk_word:tk_dword))))break;
// printf("rm=%d rmnew=%d\n",itok.rm,rettype);
if(checkaldef)redeclare(itok.name);
}
}
break;
}
else if(tok==tk_proc||tok==tk_apiproc){
if(checkaldef)idalreadydefined();
break;
}
else if((tok>=tk_bits&&tok<=tk_doublevar)||tok==tk_structvar||tok==tk_pointer){
idalreadydefined();
return 2;
}
else if(tok==tk_mult){
do{
npointr++;
nexttok();
}while(tok==tk_mult);
if(rettype==tokens)rettype=am32==FALSE?tk_word:tk_dword;
continue;
}
else if(tok==tk_openbracket){
if(tok2!=tk_mult){
unuseableinput();
return 2;
}
if(tproc!=0)tproc=(tproc-tk_pascal)*2;
itok.flag=(unsigned int)(flag|ffar|tproc|fexport|fretproc);
itok.rm=rettype;
itok.npointr=(unsigned short)npointr;
return TRUE;
}
else if((tok>=tk_overflowflag&&tok<=tk_notzeroflag)||tok==tk_minusflag||
tok==tk_plusflag)fretproc=(tok-tk_overflowflag+1)*256;
else if(tok==tk_static)flag|=f_static;
else if(tok==tk_fpust)rettype=tk_fpust;
else{
unuseableinput();
return 2;
}
nexttok();
}
itok.flag=(unsigned int)(flag|ffar|tproc|fexport|fretproc);
itok.rm=rettype;
itok.npointr=(unsigned short)npointr;
if(returntype==tk_declare&&
(tok2==tk_openbracket||tok2==tk_at||tok2==tk_period))return FALSE;
if(tok2==tk_openbracket)return CheckDeclareProc();
if(rettype==tokens){
thisundefined(itok.name);//02.09.04 20:55 was unuseableinput();
return 2;
}
return TRUE;
/*-----------------23.12.01 02:11-------------------
rerurn:
FALSE - åñëè îïðåäåëåíèå, âñòàâêà ïðîöåäóðû
TRUE - ïåðåìåííàÿ èëè îáúÿâëåíèå ïðîöåäóðû
2 - îøèáêà èëè îáðàáîòàíî - íèêàêèõ äåéñòâèé íå ïðåäïðèíèìàòü.
--------------------------------------------------*/
}
int CidOrID()
{
unsigned char cha;
unsigned char *string4=(unsigned char *)itok.name;
for(;;){
cha=*string4;
if(cha>='a'&&cha<='z')return tk_id;
if(cha==0)break;
string4++;
}
return tk_ID;
}
void unpackteg(structteg *tteg)
{
int i;
elementteg *bazael;
structteg *newteg;
int ssize,count;
idrec *newrec,*ptr;
if(alignword){ //âûðîâíÿòü íà ÷åòíûé àäðåñ
if(am32==0){
if(postsize%2==1)postsize++;
}
else if(ssize==4&&postsize%4!=0)postsize+=4-(postsize%4);
}
bazael=tteg->baza;
string[0]=0;
for(i=0;i<tteg->numoper;i++){
// printf("tok=%d %s\n",(bazael+i)->tok,(bazael+i)->name);
switch((bazael+i)->tok){
case tk_floatvar:
case tk_longvar:
case tk_dwordvar:
case tk_wordvar:
case tk_bytevar:
case tk_charvar:
case tk_intvar:
case tk_doublevar:
case tk_qwordvar:
ssize=GetVarSize((bazael+i)->tok); //ðàçìåð ïåðåìåííîé
itok.type=tp_ucnovn;
tok=(bazael+i)->tok;
count=FindOff((unsigned char *)(bazael+i)->name,VARPOST);
itok.post=1;
itok.segm=DS;
itok.number=postsize;
itok.flag=tteg->flag;
itok.size=(bazael+i)->numel*ssize;
itok.rm=(am32==FALSE?rm_d16:rm_d32);
itok.npointr=0;
newrec=addtotree((bazael+i)->name);
newrec->count=count;
break;
case tk_struct:
case tk_structvar:
strcpy(itok.name,(bazael+i)->name);
newteg=(structteg *)(bazael+i)->nteg;
newrec=(struct idrec *)MALLOC(sizeof(struct idrec));
ptr=((tteg->flag&f_static)==0?treestart:staticlist); //íà÷àëî äåðåâà
if(ptr==NULL)((tteg->flag&f_static)==0?treestart:staticlist)=newrec;//íà÷àëî äåðåâà
else{ //ïîèñê ñòðîêè â äåðåâå
while(((ssize=strcmp(ptr->recid,itok.name))<0&&ptr->left!=NULL)||(ssize>0&&ptr->right!=NULL)){
ptr=(ssize<0?ptr->left:ptr->right);
}
(ssize<0?ptr->left:ptr->right)=newrec; //ñòðîêà ìåíüøå
}
newrec->recsib=0;
strcpy(newrec->recid,itok.name);//ñêîïèð íàçâàíèå
newrec->newid=(char *)newteg;
newrec->left=NULL;
newrec->right=NULL;
newrec->rectok=tk_structvar;
newrec->flag=tteg->flag|newteg->flag;
newrec->line=linenumber;
newrec->file=currentfileinfo;
if(FixUp)newrec->flag|=f_reloc;
newrec->recrm=(bazael+i)->numel;
newrec->recsize=(bazael+i)->numel*newteg->size;
newrec->recpost=1;
count=FindOff((unsigned char *)newrec->recid,VARPOST);
newrec->count=count;
break;
default:
declareanonim();
break;
}
}
AddPostData(tteg->size);
}
void unpackteg2(structteg *tteg)
{
int i;
elementteg *bazael;
structteg *newteg;
//idrec *newrec,*trec;
localrec *lrec;
bazael=tteg->baza;
string[0]=0;
for(i=0;i<tteg->numoper;i++){
switch((bazael+i)->tok){
case tk_floatvar:
case tk_longvar:
case tk_dwordvar:
case tk_wordvar:
case tk_bytevar:
case tk_charvar:
case tk_intvar:
case tk_doublevar:
case tk_qwordvar:
lrec=addlocalvar((bazael+i)->name,(bazael+i)->tok,localsize);
lrec->rec.recsize=(bazael+i)->numel*GetVarSize((bazael+i)->tok);
lrec->rec.type=tp_localvar;
lrec->rec.npointr=0;
lrec->rec.recnumber=-lrec->rec.recnumber-Align(lrec->rec.recsize,(am32==FALSE?2:4));
break;
case tk_struct:
case tk_structvar:
newteg=(structteg *)(bazael+i)->nteg;
lrec=addlocalvar((bazael+i)->name,tk_structvar,localsize);
lrec->rec.newid=(char *)tteg;
lrec->rec.flag=tteg->flag;
lrec->rec.type=tp_localvar;
lrec->rec.recrm=(bazael+i)->numel;
lrec->rec.recsize=(bazael+i)->numel*newteg->size;
lrec->rec.recpost=LOCAL;
lrec->rec.recnumber=-lrec->rec.recnumber-Align(lrec->rec.recsize,(am32==FALSE?2:4));
break;
default:
declareanonim();
break;
}
}
localsize+=tteg->size;
localsize=Align(localsize,(am32==FALSE?2:4));
}
unsigned long dounion(int Global,int flag)
{
structteg *tteg;
int noname=FALSE;
nexttok();
if(tok==tk_openbrace)noname=TRUE;
else if((tok!=tk_id&&tok!=tk_ID)||FindTeg(Global)||(Global==FALSE&&FindTeg(TRUE))){
idalreadydefined();
SkipBlock2();
return 0;
}
if((tteg=CreatTeg(Global,TRUE,noname))!=NULL){
if(tok==tk_semicolon){
if(noname==TRUE){
if(Global)unpackteg(tteg);
else unpackteg2(tteg);
if(tteg->baza)free(tteg->baza);
free(tteg);
}
nexttok();
}
else{
if(Global)InitStruct2(flag,tteg);
else return LocalStruct2(flag,0,0,0,tteg);
}
}
else declareunion();
return 0;
}
char *BackString(char *str)
{
char *retbuf=(char *)MALLOC(strlen(str)+1);
strcpy(retbuf,str);
return retbuf;
}
void GetFileTime(int fd,struct ftime *buf)
{
/*
struct stat sb;
struct tm *tblock;
fstat(fd,&sb);
tblock=localtime(&sb.st_atime);
buf->ft_tsec=tblock->tm_sec;
buf->ft_min=tblock->tm_min;
buf->ft_hour=tblock->tm_hour;
buf->ft_day=tblock->tm_mday;
buf->ft_month=tblock->tm_mon;
buf->ft_year=tblock->tm_year-80;*/
}
void CheckPosts()
{
if(posts==maxposts){
maxposts+=MAXPOSTS;
postbuf=(postinfo *)REALLOC(postbuf,maxposts*sizeof(postinfo));
}
}
void CheckRealizable()
{
switch(tok){
case tk_case:
case tk_CASE:
case tk_default:
case tk_closebrace:
return;
}
if(tok2==tk_colon)return;
if(notunreach){
notunreach=FALSE;
return;
}
warningunreach();
// preerror("Unreachable code");
}
void AddRegistr(int razr,int reg)
{
if(razr==r8&&reg>3)reg-=4;
if(razr==r64){
stat_reg[reg&255]=1;
stat_reg[reg/256]=1;
}
else stat_reg[reg]=1;
}
void ClearRegister()
{
for(int i=0;i<8;i++)stat_reg[i]=0;
}
int GetRegister(int mode)
{
int reg=SI;
if(am32!=FALSE||mode){
if(stat_reg[AX]==0)reg=AX;
else if(stat_reg[SI]==0)reg=SI;
else if(stat_reg[DI]==0)reg=DI;
else if(stat_reg[BX]==0)reg=BX;
else if(stat_reg[CX]==0)reg=CX;
else if(stat_reg[DX]==0)reg=DX;
}
else{
if(stat_reg[SI]==0)reg=SI;
else if(stat_reg[DI]==0)reg=DI;
else if(stat_reg[BX]==0)reg=BX;
}
return reg;
}
void RegAddNum(int reg)
{
if((!structadr.post)&&optnumadd(structadr.number,reg,am32==FALSE?r16:r32,0)!=FALSE)return;
if(reg==AX)op(5);
else{
op(0x81);
op(0xC0+reg);
}
if(structadr.post)setwordpost(&structadr);
if(am32)outdword(structadr.number);
else outword(structadr.number);
}
void RestoreStack()
{
if(addstack&&sizestack){
if(short_ok(sizestack,am32)){
outword(0xC483);
op(sizestack);
}
else{
outword(0xC481);
if(am32==FALSE)outword(sizestack);
else outdword(sizestack);
}
// printf("%s(%d)> Restore %d bytes stacks.\n",startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,linenumber,sizestack);
addESP-=sizestack;
sizestack=0;
}
}
void startblock()
{
treelocalrec *nrec;
numblocks++;
// printf("start block %d\n",numblocks);
nrec=(treelocalrec*)MALLOC(sizeof(treelocalrec));
nrec->level=numblocks;
nrec->lrec=NULL;
nrec->addesp=addESP;
nrec->next=tlr;
tlr=nrec;
}
void endblock()
{
treelocalrec *orec;
// printf("end block %d\n",numblocks);
orec=tlr;
tlr=tlr->next;
if(tlr)numblocks=tlr->level;
else numblocks=0;
if(orec->lrec==NULL){
free(orec);
return;
}
orec->endline=linenumber;
orec->next=btlr;
btlr=orec;
// if(addESP!=orec->addesp)???
}
/* end of TOKC.C */