Subversion Repositories Kolibri OS

#define _REGOPT_

unsigned char optinitreg=TRUE;

	t_undef,

	t_string,

};

	razr_8h,

	razr_32

void CompareLVIC(BLVIC *bak);

BLVIC *BakLVIC();

void KillRegLec(int reg)

	KillVar(regs[0][reg]);

	if(reg<4){

		KillVar(begs[reg+4]);

}

void ClearReg(int reg)

REGEQVAR *curv,*nextv;

		free(curv);

	}

//	printf("clear reg %d\n",reg);

}

void clearregstat(int regs)

	if(optinitreg==FALSE)return;

REGEQVAR *curv,*nextv;

			while(curv){

				free(curv);

			}

		}

}

void initregstat()

	regstat=(REGISTERSTAT *)MALLOC(sizeof(REGISTERSTAT)*8);

	clearregstat();

{

		clearregstat();

	}

}

REGISTERSTAT *BakRegStat()

REGISTERSTAT *bakregstat;

	if(optinitreg==FALSE)return NULL;

#else

	(bakregstat+8)->bakvic=BakLVIC();

	memcpy(bakregstat,regstat,sizeof(REGISTERSTAT)*8);

	for(int i=0;i<8;i++){

			cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));

			(bakregstat+i)->next=cur;

				news=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));

				cur->next=news->next;

	return bakregstat;

{

	if(optinitreg==FALSE||bak==NULL)return;

	if(bak==NULL)return;

#endif

REGEQVAR *cur,*news;

		if((regstat+i)->next){

			memcpy(cur,(regstat+i)->next,sizeof(REGEQVAR));

			while(cur->next){

				memcpy(news,cur->next,sizeof(REGEQVAR));

			}

	}

{

	(regst+reg)->type=t_undef;

	while(curv){

	}

}

void AddRegVar(int reg, int razr,ITOK *itok4)

	if(optinitreg==FALSE||(itok4->flag&f_useidx)!=0)return;

	cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));

	cur->next=NULL;

		news=(regstat+reg)->next;

		news->next=cur;

}

int GetRegVar(ITOK *itok4)

	if(optinitreg==FALSE||(itok4->flag&f_useidx)!=0)return 0;

	for(int i=0;i<8;i++){

		cur=(regstat+i)->next;

			if(strcmp(itok4->name,cur->name)==0){

			cur=cur->next;

	}

}

void FreeStat(REGISTERSTAT *bak)

#ifndef OPTVARCONST

#else

	FreeLVIC((bak+8)->bakvic);

	for(int i=0;i<8;i++)ClearRegBak(i,bak);

}

void CompareRegStat(REGISTERSTAT *bak)

#ifndef OPTVARCONST

#else

	CompareLVIC((bak+8)->bakvic);

	for(int i=0;i<8;i++){

				((regstat+i)->type==t_id&&strcmp((regstat+i)->id,(bak+i)->id)!=0))ClearRegBak(i,bak);

}

int convertrazr(int *reg,int razr)

int nr;

		if(*reg<4)nr=razr_8l;

			nr=razr_8h;

		}

	else if(razr==r16)nr=razr_16;

	return nr;

{

	if(optinitreg){

}

void GenRegToReg(int regd,int regs,int razr)

	switch(razr){

			op(0x88);

			break;

		case r32:

			op(0x89);

			break;

}

int CheckIDZReg(char *name,int reg,int razr)

 name -  ¤à¥á áâப¨

{

int retreg=NOINREG;

	if(optinitreg==FALSE||razr>r32)return NOINREG;

	for(i=0;i<8;i++){

		if((regstat+i)->type==t_id){

					(regstat+i)->razr==razr_8h))){

					if(i==reg&&nr==(regstat+i)->razr){

						waralreadinit(razr==r8?begs[reg]:regs[razr/4][reg]);

						return SKIPREG;

					retreg=i;

			}

REGEQVAR *cur;

				if(strcmp(name,cur->name)==0){

						if(nr==razr_8h)reg+=4;

						return SKIPREG;

					retreg=i;

				}

			cur=cur->next;

	}

		if(razr==r8){

			if(nr==razr_8h)reg+=4;

		}

	}

}

 name -  ¤à¥á áâப¨

{

	if(optinitreg==FALSE||name==NULL||razr>r32)return;

	ClearReg(reg);

	(regstat+reg)->razr=nr;

	KillRegLec(reg);

{

	nr=convertrazr(®,razr);

			(regstat+reg)->razr==nr){

			if(getnumber((regstat+reg)->id,num))return reg;

	}

}

int GetNumberR(int sreg,unsigned long *num,int razr,unsigned long number)

int nr;

	if(optinitreg!=FALSE&&razr<=r32){

			if(reg==sreg)continue;

			if((regstat+reg)->type==t_id&&(regstat+reg)->razr==nr){

				if(isdigit((regstat+reg)->id[0])){

						if(*num==number)return reg;

							dnum=*num-number;

							rreg=reg;

						else if((number-*num)

							nnum=*num;

						}

				}

		}

	}

}

int getnumber(char *buf,unsigned long *num,int *typenum)

int temp2;

unsigned int oinptr,oendinptr;

	oendinptr=endinptr;

	inptr=0;

	*num=scannumber(typenum==NULL?&temp2:typenum);

	inptr=oinptr;

	endinptr=oendinptr;

}

char *GetLecsem(int stop1,int stop2,int type)

int oinptr,oinptr2;

int oline;

int i,j;

int otok;

		case tk_string:

		case tk_apiproc:

		case tk_declare:

	}

	oinptr2=inptr=inptr2;

	cha=cha2;

	otok=tok;

	i=0;

		pinptr=inptr;

		while(tok==tk_closebracket&&i){

			pinptr=inptr;

		}

	}while(tok!=stop1&&tok!=stop2&&tok!=tk_eof&&itok.type!=type);

		nam[0]=cha2;

	}

		do{

			j++;

		if((oinptr2+j)>pinptr)break;

	}

	inptr=oinptr;

	linenumber=oline;

	itok=oitok;

	c=nam[0];

	nam[i]=0;

}

void GetEndLex(int stop1,int stop2,int type)

int i=0;

		bufrm=NULL;

	if(strinf.bufstr){

		strinf.bufstr=NULL;

	oscanlexmode=scanlexmode;

	while(tok2!=stop1&&tok2!=stop2&&tok2!=tk_eof&&itok2.type!=type){

		while(tok==tk_closebracket&&i){

			nexttok();

		if(tok==tk_openbracket)i++;

		}

			free(strinf.bufstr);

		}

//	retoldscanmode(oscanlexmode);

//	printf("tok2=%d type2=%d\n",tok2,itok2.type);

/*

 size - à §¬¥à­®áâì

{

char nam[SIZEIDREG];

	nr=(am32==0?razr_16:razr_32);

	if(OptNameIDX(name,nam,size)==TRUE){

		(regstat+reg)->razr=nr;

	}

}

int i,j;

	j=0;

		size=1;

	}

	for(i=0;;i++){

		char c;

			c=name[j];

		}while(c<=0x20&&c!=0);

		nam[i]=c;

	nam[i]=0;

	return TRUE;

/*

 size - à §¬¥à­®áâì

{

char nam[SIZEIDREG];

int i;

	nr=(am32==0?razr_16:razr_32);

		for(i=0;i<8;i++){

				if(strcmp(nam,(regstat+i)->id)==0){

//					printf("%s %s\n",nam,(regstat+i)->id);

						return SKIPREG;

					retreg=i;

			}

			cur=(regstat+i)->next;

				if(cur->razr==nr&&strcmp(nam,cur->name)==0){

		 				waralreadinit(regs[am32][reg]);

					}

					break;

				cur=cur->next;

		}

	return retreg;

{

	if(optinitreg==FALSE)return NOINREG;

	nr=convertrazr(®d,razr);

	if(nrs==nr&&(regstat+regd)->type==(regstat+regs)->type&&

		if(strcmp((regstat+regd)->id,(regstat+regs)->id)==0)return SKIPREG;

noreg:

	memcpy((regstat+regd),(regstat+regs),sizeof(REGISTERSTAT));

 	if((regstat+regd)->next){

		memcpy(cur,(regstat+regd)->next,sizeof(REGEQVAR));

		while(cur->next){

			memcpy(news,cur->next,sizeof(REGEQVAR));

		}

	(regstat+regd)->razr=nr;

}

int RegSwapReg(int reg1,int reg2,int razr)

int nr,nrs;

	if(optinitreg==FALSE)return NOINREG;

	nr=convertrazr(®1,razr);

	if((regstat+reg2)->type&&(regstat+reg2)->razr>nrs)ClearReg(reg2);

	if((regstat+reg2)->razr=razr_16)ClearReg(reg2);

		if(strcmp((regstat+reg1)->id,(regstat+reg2)->id)==0)return SKIPREG;

noreg:

	KillRegLec(reg2);

	memcpy((regstat+reg1),(regstat+reg2),sizeof(REGISTERSTAT));

	return NOINREG;;

/*-----------------22.04.03 15:51-------------------

 ã¡à âì ¨­¨æ¨ «¨§ æ¨î ॣ¨áâà 

{

int len;

	len=strlen(name);

		if((regstat+i)->type==t_id){

			for(;;){

					char c;

							c=nam[-1];

						}

						break;

				}

novar:

			}

restart:

REGEQVAR *cur,*prev;

			if(strcmp(cur->name,name)==0){

//				printf("kill '%s'\n",name);

				goto restart;

			prev=cur;

					prev->next=cur->next;

					cur=prev->next;

				else{

					cur=cur->next;

			}

	}

 ‡ ¬¥­  ¯¥à¥¬¥­­ëå ª®­áâ ­â ¬¨

#ifdef OPTVARCONST

BLVIC *mainvic;

//void updnum(int tok4,long long *num);

#define MAXSIZEVIC 64

LVIC *listvic=NULL;

void CreateMainLVIC()

	mainvic=(BLVIC *)MALLOC(sizeof(BLVIC));

	cursizevic=mainvic->sizevic=MAXSIZEVIC;

{

	free(mainvic);

}

BLVIC *BakLVIC()

BLVIC *bakvic;

	bakvic=(BLVIC *)MALLOC(sizeof(BLVIC));

	bakvic->sizevic=cursizevic;

	return bakvic;

{

	if(cursizevicsizevic){

	}

	if(cursizevic>bak->sizevic){

	}

}

void FreeLVIC(BLVIC *bak)

	free(bak);

{

	if(bak==NULL)return;

		if((bak->listvic+i)->rec != NULL){

			int j;

				if((listvic+j)->rec==bvic->rec){

					break;

			}

		}

}

void ClearLVIC()

	memset(listvic,0,cursizevic*sizeof(LVIC));

		startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,

}

int Const2Var(ITOK *itok4,long long num,int typenum)

int i;

	if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0){

		for(i=0;i

		if(i==cursizevic){

				cursizevic+=MAXSIZEVIC;

				for(freevic=cursizevic-1;freevic>i;freevic--)(listvic+freevic)->rec=NULL;

			else i=freevic;

		else if((listvic+i)->contype==typenum&&(listvic+i)->lnumber==num)return FALSE;

		(listvic+i)->contype=typenum;

		switch(itok4->type){

			case tp_paramvar:

				break;

			case tp_gvar:

				break;

				(listvic+i)->typevar=itok4->type;

		}

			startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,

			freevic==-1?"Update":"Add",

			(listvic+i)->number,

	}

}

void Const2VarRec(LVIC *varconst)

int i;

	if(replasevar==0)return;

		if((listvic+i)->rec==varconst->rec)break;

	}

		if(freevic==-1){

			listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);

		}

	}

	(listvic+i)->contype=varconst->contype;

	switch(varconst->rec->type){

		case tp_paramvar:

			break;

		case tp_gvar:

			break;

			(listvic+i)->typevar=varconst->rec->type;

	}

{

		for(int i=0;i

				(listvic+i)->rec=NULL;

					startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,

					itok4->name);*/

			}

	}

{

int i;

	for(i=0;i

//			printf("%s(%d)> Modif var '%s' by num=%u ",startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,linenumber,itok4->name,(listvic+i)->number);

				case tk_plusequals:

				case tk_minusequals:

				case tk_xorequals: operand=tk_xor; break;

				case tk_orequals: operand=tk_or; break;

				case tk_divequals: operand=tk_div; break;

				case tk_llequals: operand=tk_ll; break;

					if((listvic+i)->contype==tk_float)(listvic+i)->number|=0x80000000;

					else (listvic+i)->lnumber=-(listvic+i)->lnumber;

				case tk_not:

					return TRUE;;

			switch((listvic+i)->contype){

				case tk_int:

					retcode=calclongnumber(&(listvic+i)->number,num,operand);

				case tk_byte:

				case tk_dword:

					retcode=calcqwordnumber((unsigned long long *)&(listvic+i)->lnumber,num,operand);

				case tk_float:

					break;

					retcode=calcdoublenumber(&(listvic+i)->dnumber,*(double *) &num,operand);

			}

			else{

				(listvic+i)->rec=NULL;

			break;

	}

}

void FreeGlobalConst()

	if(replasevar==0)return;

		if((listvic+i)->rec!=NULL&&(listvic+i)->typevar!=tp_localvar){

/*			printf("%s(%d)> Clear global constant var\n",

					linenumber);*/

	}

{

int typenum;

	nr=convertrazr(®,razr);

			(regstat+reg)->razr>=nr){

			if(getnumber((regstat+reg)->id,&num,&typenum)){

				return TRUE;

		}

	return FALSE;

{

int typenum;

	nr=convertrazr(®,razr);

			(regstat+reg)->razr>=nr){

			if(getnumber((regstat+reg)->id,&num,&typenum))return UpdVarConst(itok4,num,typenum,operand);

	}

}

int SwapVarConst(ITOK *itok2,ITOK *itok4)

LVIC tempvic;

	if(itok4->rec==NULL||(itok4->flag&f_useidx)!=0)sec=-2;

		if(sec==-2)return TRUE;

	}

		if(sec==-1&&(listvic+i)->rec==itok4->rec)sec=i;

	}

	if(fir==-2)fir=-1;

		memcpy(&tempvic,listvic+fir,sizeof(LVIC));

		memcpy(listvic+sec,&tempvic,sizeof(LVIC));

	else if(sec==-1&&fir!=-1)(listvic+fir)->rec=itok4->rec;

	return TRUE;

{

int freevic=-1;

int typenum;

int numinreg=FALSE;

	if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0&&optinitreg!=FALSE&&razr<=r32&&

		for(i=0;i

		if(isdigit((regstat+reg)->id[0])){

				if(i!=cursizevic)ConstToReg((listvic+i)->lnumber,reg,razr);	//­®¢ãî ¢ ॣ¨áâà

					if(freevic==-1){

						listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);

					}

				}

				(listvic+i)->contype=typenum;

				switch(itok4->type){

					case tp_paramvar:

						break;

					case tp_gvar:

						break;

						(listvic+i)->typevar=itok4->type;

				}

					startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,

					freevic==-1?"Update":"Add",

					(listvic+i)->number,

			}

		else{	//­¥â æ¨äàë ¢ ॣ¨áâà¥

				ConstToReg((listvic+i)->lnumber,reg,razr);	//⥯¥àì ¢ ॣ¨áâà¥

			}

	}

}

int CheckConstVar(ITOK *itok4)

		for(int i=0;i

				itok4->lnumber=(listvic+i)->lnumber;

				itok4->flag=0;

				return TRUE;

			}

	}

}

int CheckConstVar2(ITOK *itok4,long long *num,int *typenum)

//	if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return FALSE;

		for(int i=0;i

				*num=(listvic+i)->lnumber;

//				warreplasevar(itok4->name);

		}

	return FALSE;

void updnum(int tok4,long long *num)

	switch(tok4){

		case tk_bytevar:

			break;

		case tk_wordvar:

			break;

		case tk_dwordvar:

			break;

	}

 */

void CheckConstVar3(int *tok4,ITOK *itok4,int razr)

long long lnum;

	if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return;

		if((optimizespeed||itok4->type==tp_gvar||itok4->type==tp_postvar||