mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-24 23:56:49 +03:00
1165 lines
28 KiB
C++
1165 lines
28 KiB
C++
#define _REGOPT_
|
||
|
||
|
||
|
||
#include "tok.h"
|
||
|
||
|
||
|
||
unsigned char optinitreg=TRUE;
|
||
|
||
int OptNameIDX(char *name,char *nam,int size);
|
||
|
||
int getnumber(char *buf,unsigned long *num,int *typenum=NULL);
|
||
|
||
int convertrazr(int *reg,int razr);
|
||
|
||
|
||
|
||
enum{
|
||
|
||
t_undef,
|
||
|
||
t_const,
|
||
|
||
t_string,
|
||
|
||
t_id,
|
||
|
||
};
|
||
|
||
|
||
|
||
enum{
|
||
|
||
razr_8l,
|
||
|
||
razr_8h,
|
||
|
||
razr_16,
|
||
|
||
razr_32
|
||
|
||
};
|
||
|
||
|
||
|
||
REGISTERSTAT *regstat;
|
||
|
||
|
||
|
||
#ifdef OPTVARCONST
|
||
|
||
void CompareLVIC(BLVIC *bak);
|
||
|
||
void FreeLVIC(BLVIC *bak);
|
||
|
||
BLVIC *BakLVIC();
|
||
|
||
void CopyLVIC(BLVIC *bak);
|
||
|
||
#endif
|
||
|
||
|
||
|
||
void KillRegLec(int reg)
|
||
|
||
{
|
||
|
||
KillVar(regs[0][reg]);
|
||
|
||
KillVar(regs[1][reg]);
|
||
|
||
if(reg<4){
|
||
|
||
KillVar(begs[reg]);
|
||
|
||
KillVar(begs[reg+4]);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
void ClearReg(int reg)
|
||
|
||
{
|
||
|
||
if(optinitreg==FALSE)return;
|
||
|
||
(regstat+reg)->type=t_undef;
|
||
|
||
REGEQVAR *curv,*nextv;
|
||
|
||
curv=(regstat+reg)->next;
|
||
|
||
while(curv){
|
||
|
||
nextv=curv->next;
|
||
|
||
free(curv);
|
||
|
||
curv=nextv;
|
||
|
||
}
|
||
|
||
(regstat+reg)->next=NULL;
|
||
|
||
// printf("clear reg %d\n",reg);
|
||
|
||
KillRegLec(reg);
|
||
|
||
}
|
||
|
||
|
||
|
||
void clearregstat(int regs)
|
||
|
||
{
|
||
|
||
if(optinitreg==FALSE)return;
|
||
|
||
for(int i=0;i<8;i++){
|
||
|
||
if((regs&(1<<i))==0){
|
||
|
||
(regstat+i)->type=t_undef;
|
||
|
||
REGEQVAR *curv,*nextv;
|
||
|
||
curv=(regstat+i)->next;
|
||
|
||
while(curv){
|
||
|
||
nextv=curv->next;
|
||
|
||
free(curv);
|
||
|
||
curv=nextv;
|
||
|
||
}
|
||
|
||
(regstat+i)->next=NULL;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
void initregstat()
|
||
|
||
{
|
||
|
||
regstat=(REGISTERSTAT *)MALLOC(sizeof(REGISTERSTAT)*8);
|
||
|
||
for(int i=0;i<8;i++)(regstat+i)->next=NULL;
|
||
|
||
clearregstat();
|
||
|
||
}
|
||
|
||
|
||
|
||
void deinitregstat()
|
||
|
||
{
|
||
|
||
if(regstat){
|
||
|
||
clearregstat();
|
||
|
||
free(regstat);
|
||
|
||
}
|
||
|
||
regstat=NULL;
|
||
|
||
}
|
||
|
||
|
||
|
||
REGISTERSTAT *BakRegStat()
|
||
|
||
{
|
||
|
||
REGISTERSTAT *bakregstat;
|
||
|
||
#ifndef OPTVARCONST
|
||
|
||
if(optinitreg==FALSE)return NULL;
|
||
|
||
bakregstat=(REGISTERSTAT *)MALLOC(sizeof(REGISTERSTAT)*8);
|
||
|
||
#else
|
||
|
||
bakregstat=(REGISTERSTAT *)MALLOC(sizeof(REGISTERSTAT)*8+sizeof(BLVIC *));
|
||
|
||
(bakregstat+8)->bakvic=BakLVIC();
|
||
|
||
#endif
|
||
|
||
memcpy(bakregstat,regstat,sizeof(REGISTERSTAT)*8);
|
||
|
||
REGEQVAR *cur,*news;
|
||
|
||
for(int i=0;i<8;i++){
|
||
|
||
if((bakregstat+i)->next){
|
||
|
||
cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
|
||
|
||
memcpy(cur,(bakregstat+i)->next,sizeof(REGEQVAR));
|
||
|
||
(bakregstat+i)->next=cur;
|
||
|
||
while(cur->next){
|
||
|
||
news=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
|
||
|
||
memcpy(news,cur->next,sizeof(REGEQVAR));
|
||
|
||
cur->next=news->next;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return bakregstat;
|
||
|
||
}
|
||
|
||
|
||
|
||
void CopyRegStat(REGISTERSTAT *bak)
|
||
|
||
{
|
||
|
||
#ifndef OPTVARCONST
|
||
|
||
if(optinitreg==FALSE||bak==NULL)return;
|
||
|
||
#else
|
||
|
||
if(bak==NULL)return;
|
||
|
||
CopyLVIC((bak+8)->bakvic);
|
||
|
||
#endif
|
||
|
||
memcpy(regstat,bak,sizeof(REGISTERSTAT)*8);
|
||
|
||
REGEQVAR *cur,*news;
|
||
|
||
for(int i=0;i<8;i++){
|
||
|
||
if((regstat+i)->next){
|
||
|
||
cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
|
||
|
||
memcpy(cur,(regstat+i)->next,sizeof(REGEQVAR));
|
||
|
||
(regstat+i)->next=cur;
|
||
|
||
while(cur->next){
|
||
|
||
news=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
|
||
|
||
memcpy(news,cur->next,sizeof(REGEQVAR));
|
||
|
||
cur->next=news->next;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
void ClearRegBak(int reg,REGISTERSTAT *regst)
|
||
|
||
{
|
||
|
||
REGEQVAR *curv,*nextv;
|
||
|
||
(regst+reg)->type=t_undef;
|
||
|
||
curv=(regst+reg)->next;
|
||
|
||
while(curv){
|
||
|
||
nextv=curv->next;
|
||
|
||
free(curv);
|
||
|
||
curv=nextv;
|
||
|
||
}
|
||
|
||
(regst+reg)->next=NULL;
|
||
|
||
}
|
||
|
||
|
||
|
||
void AddRegVar(int reg, int razr,ITOK *itok4)
|
||
|
||
{
|
||
|
||
if(optinitreg==FALSE||(itok4->flag&f_useidx)!=0)return;
|
||
|
||
REGEQVAR *cur,*news;
|
||
|
||
cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
|
||
|
||
cur->razr=convertrazr(®,razr);
|
||
|
||
cur->next=NULL;
|
||
|
||
strcpy(cur->name,itok4->name);
|
||
|
||
if((regstat+reg)->next==NULL)(regstat+reg)->next=cur;
|
||
|
||
else{
|
||
|
||
news=(regstat+reg)->next;
|
||
|
||
while(news->next)news=news->next;
|
||
|
||
news->next=cur;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
int GetRegVar(ITOK *itok4)
|
||
|
||
{
|
||
|
||
if(optinitreg==FALSE||(itok4->flag&f_useidx)!=0)return 0;
|
||
|
||
int retval=0;
|
||
|
||
for(int i=0;i<8;i++){
|
||
|
||
REGEQVAR *cur;
|
||
|
||
cur=(regstat+i)->next;
|
||
|
||
while(cur){
|
||
|
||
if(strcmp(itok4->name,cur->name)==0){
|
||
|
||
retval|=(1<<i);
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
cur=cur->next;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return retval;
|
||
|
||
}
|
||
|
||
|
||
|
||
void FreeStat(REGISTERSTAT *bak)
|
||
|
||
{
|
||
|
||
#ifndef OPTVARCONST
|
||
|
||
if(optinitreg==FALSE||bak==NULL)return;
|
||
|
||
#else
|
||
|
||
if(bak==NULL)return;
|
||
|
||
FreeLVIC((bak+8)->bakvic);
|
||
|
||
#endif
|
||
|
||
for(int i=0;i<8;i++)ClearRegBak(i,bak);
|
||
|
||
free(bak);
|
||
|
||
}
|
||
|
||
|
||
|
||
void CompareRegStat(REGISTERSTAT *bak)
|
||
|
||
{
|
||
|
||
#ifndef OPTVARCONST
|
||
|
||
if(optinitreg==FALSE||bak==NULL)return;
|
||
|
||
#else
|
||
|
||
if(bak==NULL)return;
|
||
|
||
CompareLVIC((bak+8)->bakvic);
|
||
|
||
#endif
|
||
|
||
for(int i=0;i<8;i++){
|
||
|
||
if((regstat+i)->type==t_undef||(regstat+i)->type!=(bak+i)->type||
|
||
|
||
((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(razr==r8){
|
||
|
||
if(*reg<4)nr=razr_8l;
|
||
|
||
else{
|
||
|
||
nr=razr_8h;
|
||
|
||
*reg-=4;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
else if(razr==r16)nr=razr_16;
|
||
|
||
else nr=razr_32;
|
||
|
||
return nr;
|
||
|
||
}
|
||
|
||
|
||
|
||
void ConstToReg(unsigned long num,int reg,int razr)
|
||
|
||
{
|
||
|
||
char buf[64];
|
||
|
||
if(optinitreg){
|
||
|
||
sprintf(buf,"%ld",num);
|
||
|
||
IDZToReg(buf,reg,razr);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
void GenRegToReg(int regd,int regs,int razr)
|
||
|
||
{
|
||
|
||
switch(razr){
|
||
|
||
case r8:
|
||
|
||
op(0x88);
|
||
|
||
op(128+64+regs*8+regd);
|
||
|
||
break;
|
||
|
||
case r16:
|
||
|
||
case r32:
|
||
|
||
op66(razr);
|
||
|
||
op(0x89);
|
||
|
||
op(128+64+regs*8+regd);
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
int CheckIDZReg(char *name,int reg,int razr)
|
||
|
||
/*
|
||
|
||
name - <20><><EFBFBD><EFBFBD><EFBFBD> <20><>ப<EFBFBD>
|
||
|
||
*/
|
||
|
||
{
|
||
|
||
int nr;
|
||
|
||
int retreg=NOINREG;
|
||
|
||
int i;
|
||
|
||
if(optinitreg==FALSE||razr>r32)return NOINREG;
|
||
|
||
nr=convertrazr(®,razr);
|
||
|
||
for(i=0;i<8;i++){
|
||
|
||
//printf("%d type=%d razr=%d %s\n",i,(regstat+i)->type,(regstat+i)->razr,(regstat+i)->id);
|
||
|
||
if((regstat+i)->type==t_id){
|
||
|
||
if((regstat+i)->razr==nr||(razr==r8&&((regstat+i)->razr==razr_8l||
|
||
|
||
(regstat+i)->razr==razr_8h))){
|
||
|
||
if(strcmp(name,(regstat+i)->id)==0){
|
||
|
||
if(i==reg&&nr==(regstat+i)->razr){
|
||
|
||
if(/*razr==r8&&*/nr==razr_8h)reg+=4;
|
||
|
||
waralreadinit(razr==r8?begs[reg]:regs[razr/4][reg]);
|
||
|
||
// printstatreg();
|
||
|
||
return SKIPREG;
|
||
|
||
}
|
||
|
||
retreg=i;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
REGEQVAR *cur;
|
||
|
||
cur=(regstat+i)->next;
|
||
|
||
while(cur){
|
||
|
||
if(cur->razr==nr||(razr==r8&&(cur->razr==razr_8l||cur->razr==razr_8h))){
|
||
|
||
if(strcmp(name,cur->name)==0){
|
||
|
||
if(i==reg&&nr==cur->razr){
|
||
|
||
if(nr==razr_8h)reg+=4;
|
||
|
||
waralreadinit(razr==r8?begs[reg]:regs[razr/4][reg]);
|
||
|
||
return SKIPREG;
|
||
|
||
}
|
||
|
||
retreg=i;
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
cur=cur->next;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
if(retreg!=NOINREG){
|
||
|
||
if(razr==r8){
|
||
|
||
if((regstat+retreg)->razr==razr_8h)retreg+=4;
|
||
|
||
if(nr==razr_8h)reg+=4;
|
||
|
||
waralreadinitreg(begs[reg],begs[retreg]);
|
||
|
||
}
|
||
|
||
else waralreadinitreg(regs[razr/4][reg],regs[razr/4][retreg]);
|
||
|
||
}
|
||
|
||
return retreg;
|
||
|
||
}
|
||
|
||
|
||
|
||
void IDZToReg(char *name,int reg,int razr)
|
||
|
||
/*
|
||
|
||
name - <20><><EFBFBD><EFBFBD><EFBFBD> <20><>ப<EFBFBD>
|
||
|
||
*/
|
||
|
||
{
|
||
|
||
int nr;
|
||
|
||
if(optinitreg==FALSE||name==NULL||razr>r32)return;
|
||
|
||
nr=convertrazr(®,razr);
|
||
|
||
ClearReg(reg);
|
||
|
||
(regstat+reg)->type=t_id;
|
||
|
||
(regstat+reg)->razr=nr;
|
||
|
||
strcpy((regstat+reg)->id,name);
|
||
|
||
KillRegLec(reg);
|
||
|
||
}
|
||
|
||
|
||
|
||
int GetRegNumber(int reg,unsigned long *num,int razr)
|
||
|
||
{
|
||
|
||
int nr;
|
||
|
||
nr=convertrazr(®,razr);
|
||
|
||
if(optinitreg!=FALSE&&razr<=r32&&(regstat+reg)->type==t_id&&
|
||
|
||
(regstat+reg)->razr==nr){
|
||
|
||
if(isdigit((regstat+reg)->id[0])){
|
||
|
||
if(getnumber((regstat+reg)->id,num))return reg;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return NOINREG;
|
||
|
||
}
|
||
|
||
|
||
|
||
int GetNumberR(int sreg,unsigned long *num,int razr,unsigned long number)
|
||
|
||
{
|
||
|
||
int nr;
|
||
|
||
int reg,rreg=NOINREG;
|
||
|
||
unsigned long dnum=0xffffffff;
|
||
|
||
unsigned long nnum;
|
||
|
||
if(optinitreg!=FALSE&&razr<=r32){
|
||
|
||
for(reg=0;reg<8;reg++){
|
||
|
||
if(reg==sreg)continue;
|
||
|
||
nr=convertrazr(®,razr);
|
||
|
||
if((regstat+reg)->type==t_id&&(regstat+reg)->razr==nr){
|
||
|
||
// printf("reg=%d %s\n",reg,(regstat+reg)->id);
|
||
|
||
if(isdigit((regstat+reg)->id[0])){
|
||
|
||
if(getnumber((regstat+reg)->id,num)){
|
||
|
||
if(*num==number)return reg;
|
||
|
||
if(*num>number&&(*num-number)<dnum){
|
||
|
||
dnum=*num-number;
|
||
|
||
nnum=*num;
|
||
|
||
rreg=reg;
|
||
|
||
}
|
||
|
||
else if((number-*num)<dnum){
|
||
|
||
dnum=number-*num;
|
||
|
||
nnum=*num;
|
||
|
||
rreg=reg;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
*num=nnum;
|
||
|
||
}
|
||
|
||
return rreg;
|
||
|
||
}
|
||
|
||
|
||
|
||
int getnumber(char *buf,unsigned long *num,int *typenum)
|
||
|
||
{
|
||
|
||
int temp2;
|
||
|
||
unsigned char *oinput;
|
||
|
||
unsigned int oinptr,oendinptr;
|
||
|
||
int retcode=FALSE;
|
||
|
||
oinptr=inptr;
|
||
|
||
oinput=input;
|
||
|
||
oendinptr=endinptr;
|
||
|
||
input = (unsigned char*)buf;
|
||
|
||
inptr=0;
|
||
|
||
endinptr=256;
|
||
|
||
*num=scannumber(typenum==NULL?&temp2:typenum);
|
||
|
||
if(cha==0)retcode=TRUE;
|
||
|
||
inptr=oinptr;
|
||
|
||
input=oinput;
|
||
|
||
endinptr=oendinptr;
|
||
|
||
return retcode;
|
||
|
||
}
|
||
|
||
|
||
|
||
char *GetLecsem(int stop1,int stop2,int type)
|
||
|
||
{
|
||
|
||
int oinptr,oinptr2;
|
||
|
||
char ocha;
|
||
|
||
int oline;
|
||
|
||
char nam[SIZEIDREG];
|
||
|
||
int i,j;
|
||
|
||
ITOK oitok;
|
||
|
||
int otok;
|
||
|
||
char c;
|
||
|
||
int pinptr;
|
||
|
||
switch(tok2){
|
||
|
||
case tk_string:
|
||
|
||
case tk_proc:
|
||
|
||
case tk_apiproc:
|
||
|
||
case tk_undefproc:
|
||
|
||
case tk_declare:
|
||
|
||
return NULL;
|
||
|
||
}
|
||
|
||
oinptr=inptr;
|
||
|
||
oinptr2=inptr=inptr2;
|
||
|
||
ocha=cha;
|
||
|
||
cha=cha2;
|
||
|
||
oline=linenumber;
|
||
|
||
otok=tok;
|
||
|
||
oitok=itok;
|
||
|
||
i=0;
|
||
|
||
do{
|
||
|
||
pinptr=inptr;
|
||
|
||
FastTok(0);
|
||
|
||
while(tok==tk_closebracket&&i){
|
||
|
||
i--;
|
||
|
||
pinptr=inptr;
|
||
|
||
FastTok(0);
|
||
|
||
}
|
||
|
||
if(tok==tk_openbracket)i++;
|
||
|
||
}while(tok!=stop1&&tok!=stop2&&tok!=tk_eof&&itok.type!=type);
|
||
|
||
if(pinptr)pinptr--;
|
||
|
||
i=0;
|
||
|
||
if(cha2>' '){
|
||
|
||
nam[0]=cha2;
|
||
|
||
i++;
|
||
|
||
}
|
||
|
||
for(j=0;i<SIZEIDREG;i++){
|
||
|
||
do{
|
||
|
||
c=input[j+oinptr2];
|
||
|
||
j++;
|
||
|
||
}while(c<=0x20);
|
||
|
||
if((oinptr2+j)>pinptr)break;
|
||
|
||
nam[i]=c;
|
||
|
||
}
|
||
|
||
inptr2=oinptr2;
|
||
|
||
inptr=oinptr;
|
||
|
||
cha=ocha;
|
||
|
||
linenumber=oline;
|
||
|
||
tok=otok;
|
||
|
||
itok=oitok;
|
||
|
||
if(i==SIZEIDREG)return NULL;
|
||
|
||
c=nam[0];
|
||
|
||
if(c==';'||c==','||c==')'||c=='}')return NULL;
|
||
|
||
nam[i]=0;
|
||
|
||
return BackString(nam);
|
||
|
||
}
|
||
|
||
|
||
|
||
void GetEndLex(int stop1,int stop2,int type)
|
||
|
||
{
|
||
|
||
int i=0;
|
||
|
||
int oscanlexmode;
|
||
|
||
if(bufrm){
|
||
|
||
free(bufrm);
|
||
|
||
bufrm=NULL;
|
||
|
||
}
|
||
|
||
if(strinf.bufstr){
|
||
|
||
free(strinf.bufstr);
|
||
|
||
strinf.bufstr=NULL;
|
||
|
||
}
|
||
|
||
oscanlexmode=scanlexmode;
|
||
|
||
scanlexmode=DEFLEX;
|
||
|
||
while(tok2!=stop1&&tok2!=stop2&&tok2!=tk_eof&&itok2.type!=type){
|
||
|
||
nexttok();
|
||
|
||
while(tok==tk_closebracket&&i){
|
||
|
||
i--;
|
||
|
||
nexttok();
|
||
|
||
}
|
||
|
||
if(tok==tk_openbracket)i++;
|
||
|
||
if(bufrm){
|
||
|
||
free(bufrm);
|
||
|
||
bufrm=NULL;
|
||
|
||
}
|
||
|
||
if(strinf.bufstr){
|
||
|
||
free(strinf.bufstr);
|
||
|
||
strinf.bufstr=NULL;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
// retoldscanmode(oscanlexmode);
|
||
|
||
scanlexmode=oscanlexmode;
|
||
|
||
// printf("tok2=%d type2=%d\n",tok2,itok2.type);
|
||
|
||
}
|
||
|
||
|
||
|
||
void IDXToReg(char *name,int size,int reg)
|
||
|
||
/*
|
||
|
||
name - <20><><EFBFBD><EFBFBD><EFBFBD> <20><>砫<EFBFBD>
|
||
|
||
size - ࠧ<><E0A0A7>୮<EFBFBD><E0ADAE><EFBFBD>
|
||
|
||
*/
|
||
|
||
{
|
||
|
||
int nr;
|
||
|
||
char nam[SIZEIDREG];
|
||
|
||
if(optinitreg==FALSE)return;
|
||
|
||
nr=(am32==0?razr_16:razr_32);
|
||
|
||
ClearReg(reg);
|
||
|
||
if(OptNameIDX(name,nam,size)==TRUE){
|
||
|
||
(regstat+reg)->type=t_id;
|
||
|
||
(regstat+reg)->razr=nr;
|
||
|
||
strcpy((regstat+reg)->id,nam);
|
||
|
||
}
|
||
|
||
KillRegLec(reg);
|
||
|
||
}
|
||
|
||
|
||
|
||
int OptNameIDX(char *name,char *nam,int size)
|
||
|
||
{
|
||
|
||
int i,j;
|
||
|
||
int maxlen=SIZEIDREG;
|
||
|
||
j=0;
|
||
|
||
if(name[j]=='&'){
|
||
|
||
size=1;
|
||
|
||
j++;
|
||
|
||
}
|
||
|
||
if(size>1)maxlen-=10;
|
||
|
||
for(i=0;;i++){
|
||
|
||
if(i==maxlen)return FALSE;
|
||
|
||
char c;
|
||
|
||
do{
|
||
|
||
c=name[j];
|
||
|
||
j++;
|
||
|
||
}while(c<=0x20&&c!=0);
|
||
|
||
if(c==0||c==';')break;
|
||
|
||
nam[i]=c;
|
||
|
||
}
|
||
|
||
nam[i]=0;
|
||
|
||
if(size>1)sprintf(nam+i,"*%d",size);
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
|
||
int CheckIDXReg(char *name,int size,int reg)
|
||
|
||
/*
|
||
|
||
name - <20><><EFBFBD><EFBFBD><EFBFBD> <20><>砫<EFBFBD>
|
||
|
||
size - ࠧ<><E0A0A7>୮<EFBFBD><E0ADAE><EFBFBD>
|
||
|
||
*/
|
||
|
||
{
|
||
|
||
int nr;
|
||
|
||
char nam[SIZEIDREG];
|
||
|
||
int retreg=NOINREG;
|
||
|
||
int i;
|
||
|
||
if(optinitreg==FALSE)return NOINREG;
|
||
|
||
nr=(am32==0?razr_16:razr_32);
|
||
|
||
if(OptNameIDX(name,nam,size)==TRUE){
|
||
|
||
for(i=0;i<8;i++){
|
||
|
||
if((regstat+i)->type==t_id&&(regstat+i)->razr==nr){
|
||
|
||
if(strcmp(nam,(regstat+i)->id)==0){
|
||
|
||
if(i==reg){
|
||
|
||
// printf("%s %s\n",nam,(regstat+i)->id);
|
||
|
||
waralreadinit(regs[am32][reg]);
|
||
|
||
return SKIPREG;
|
||
|
||
}
|
||
|
||
retreg=i;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
REGEQVAR *cur;
|
||
|
||
cur=(regstat+i)->next;
|
||
|
||
while(cur){
|
||
|
||
if(cur->razr==nr&&strcmp(nam,cur->name)==0){
|
||
|
||
if(i==reg){
|
||
|
||
waralreadinit(regs[am32][reg]);
|
||
|
||
return SKIPREG;
|
||
|
||
}
|
||
|
||
retreg=i;
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
cur=cur->next;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return retreg;
|
||
|
||
}
|
||
|
||
|
||
|
||
int RegToReg(int regd,int regs,int razr)
|
||
|
||
{
|
||
|
||
int nr,nrs;
|
||
|
||
if(optinitreg==FALSE)return NOINREG;
|
||
|
||
nrs=convertrazr(®s,razr);
|
||
|
||
nr=convertrazr(®d,razr);
|
||
|
||
if(razr==r8&&nrs!=nr&®s==regd)goto noreg;
|
||
|
||
if(nrs==nr&&(regstat+regd)->type==(regstat+regs)->type&&
|
||
|
||
(regstat+regs)->type!=t_undef&&(regstat+regd)->razr==(regstat+regs)->razr){
|
||
|
||
if(strcmp((regstat+regd)->id,(regstat+regs)->id)==0)return SKIPREG;
|
||
|
||
}
|
||
|
||
noreg:
|
||
|
||
ClearReg(regd);
|
||
|
||
memcpy((regstat+regd),(regstat+regs),sizeof(REGISTERSTAT));
|
||
|
||
REGEQVAR *cur,*news;
|
||
|
||
if((regstat+regd)->next){
|
||
|
||
cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
|
||
|
||
memcpy(cur,(regstat+regd)->next,sizeof(REGEQVAR));
|
||
|
||
(regstat+regd)->next=cur;
|
||
|
||
while(cur->next){
|
||
|
||
news=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
|
||
|
||
memcpy(news,cur->next,sizeof(REGEQVAR));
|
||
|
||
cur->next=news->next;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
(regstat+regd)->razr=nr;
|
||
|
||
return NOINREG;;
|
||
|
||
}
|
||
|
||
|
||
|
||
int RegSwapReg(int reg1,int reg2,int razr)
|
||
|
||
{
|
||
|
||
int nr,nrs;
|
||
|
||
REGISTERSTAT temp;
|
||
|
||
if(optinitreg==FALSE)return NOINREG;
|
||
|
||
nrs=convertrazr(®2,razr);
|
||
|
||
nr=convertrazr(®1,razr);
|
||
|
||
if((regstat+reg1)->type&&(regstat+reg1)->razr>nr)ClearReg(reg1);
|
||
|
||
if((regstat+reg2)->type&&(regstat+reg2)->razr>nrs)ClearReg(reg2);
|
||
|
||
if((regstat+reg1)->razr<razr_16&&nrs>=razr_16)ClearReg(reg1);
|
||
|
||
if((regstat+reg2)->razr<razr_16&&nr>=razr_16)ClearReg(reg2);
|
||
|
||
if(razr==r8&&nrs!=nr&®1==reg2)goto noreg;
|
||
|
||
if((regstat+reg1)->type==(regstat+reg2)->type&&
|
||
|
||
(regstat+reg2)->type!=r_undef&&(regstat+reg1)->razr==(regstat+reg2)->razr){
|
||
|
||
if(strcmp((regstat+reg1)->id,(regstat+reg2)->id)==0)return SKIPREG;
|
||
|
||
}
|
||
|
||
noreg:
|
||
|
||
KillRegLec(reg1);
|
||
|
||
KillRegLec(reg2);
|
||
|
||
memcpy(&temp,(regstat+reg1),sizeof(REGISTERSTAT));
|
||
|
||
memcpy((regstat+reg1),(regstat+reg2),sizeof(REGISTERSTAT));
|
||
|
||
memcpy((regstat+reg2),&temp,sizeof(REGISTERSTAT));
|
||
|
||
return NOINREG;;
|
||
|
||
}
|
||
|
||
|
||
|
||
void KillVar(char *name)
|
||
|
||
/*-----------------22.04.03 15:51-------------------
|
||
|
||
<20><><EFBFBD><EFBFBD><EFBFBD> <20><>६<EFBFBD><E0A5AC><EFBFBD><EFBFBD><EFBFBD> <20> ॣ<><E0A5A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><>
|
||
|
||
<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>樠<EFBFBD><E6A8A0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ॣ<><E0A5A3><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
--------------------------------------------------*/
|
||
|
||
{
|
||
|
||
char *pstr,*nam;
|
||
|
||
int len;
|
||
|
||
if(optinitreg==FALSE)return;
|
||
|
||
len=strlen(name);
|
||
|
||
for(int i=0;i<8;i++){
|
||
|
||
if((regstat+i)->type==t_id){
|
||
|
||
pstr=(regstat+i)->id;
|
||
|
||
for(;;){
|
||
|
||
if((nam=strstr(pstr,name))!=NULL){
|
||
|
||
char c;
|
||
|
||
c=nam[len];
|
||
|
||
if(c!='_'&&(!isalpha(c))){
|
||
|
||
if(nam!=pstr){
|
||
|
||
c=nam[-1];
|
||
|
||
if(c=='_'||isalpha(c))goto novar;
|
||
|
||
}
|
||
|
||
ClearReg(i);
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
else break;
|
||
|
||
novar:
|
||
|
||
pstr=nam+1;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
restart:
|
||
|
||
if((regstat+i)->next){
|
||
|
||
REGEQVAR *cur,*prev;
|
||
|
||
cur=(regstat+i)->next;
|
||
|
||
if(strcmp(cur->name,name)==0){
|
||
|
||
(regstat+i)->next=cur->next;
|
||
|
||
// printf("kill '%s'\n",name);
|
||
|
||
free(cur);
|
||
|
||
goto restart;
|
||
|
||
}
|
||
|
||
prev=cur;
|
||
|
||
cur=cur->next;
|
||
|
||
while(cur){
|
||
|
||
if(strcmp(cur->name,name)==0){
|
||
|
||
prev->next=cur->next;
|
||
|
||
free(cur);
|
||
|
||
cur=prev->next;
|
||
|
||
}
|
||
|
||
else{
|
||
|
||
prev=cur;
|
||
|
||
cur=cur->next;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
/*-----------------16.06.05 23:45-------------------
|
||
|
||
<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>६<EFBFBD><E0A5AC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>⠭⠬<E2A0AD>
|
||
|
||
--------------------------------------------------*/
|
||
|
||
#ifdef OPTVARCONST
|
||
|
||
|
||
|
||
BLVIC *mainvic;
|
||
|
||
unsigned char replasevar=TRUE;
|
||
|
||
//void updnum(int tok4,long long *num);
|
||
|
||
|
||
|
||
#define MAXSIZEVIC 64
|
||
|
||
int cursizevic=0;
|
||
|
||
LVIC *listvic=NULL;
|
||
|
||
|
||
|
||
void CreateMainLVIC()
|
||
|
||
{
|
||
|
||
mainvic=(BLVIC *)MALLOC(sizeof(BLVIC));
|
||
|
||
listvic=mainvic->listvic=(LVIC *)MALLOC(sizeof(LVIC)*MAXSIZEVIC);
|
||
|
||
cursizevic=mainvic->sizevic=MAXSIZEVIC;
|
||
|
||
}
|
||
|
||
|
||
|
||
void KillMainLVIC()
|
||
|
||
{
|
||
|
||
free(listvic);
|
||
|
||
free(mainvic);
|
||
|
||
listvic=NULL;
|
||
|
||
}
|
||
|
||
|
||
|
||
BLVIC *BakLVIC()
|
||
|
||
{
|
||
|
||
BLVIC *bakvic;
|
||
|
||
if(replasevar==0)return NULL;
|
||
|
||
bakvic=(BLVIC *)MALLOC(sizeof(BLVIC));
|
||
|
||
bakvic->listvic=(LVIC *)MALLOC(sizeof(LVIC)*cursizevic);
|
||
|
||
bakvic->sizevic=cursizevic;
|
||
|
||
memcpy(bakvic->listvic,listvic,sizeof(LVIC)*cursizevic);
|
||
|
||
return bakvic;
|
||
|
||
}
|
||
|
||
|
||
|
||
void CopyLVIC(BLVIC *bak)
|
||
|
||
{
|
||
|
||
if(bak==NULL)return;
|
||
|
||
if(cursizevic<bak->sizevic){
|
||
|
||
listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*bak->sizevic);
|
||
|
||
}
|
||
|
||
memcpy(listvic,bak->listvic,sizeof(LVIC)*bak->sizevic);
|
||
|
||
if(cursizevic>bak->sizevic){
|
||
|
||
for(int i=bak->sizevic;i<cursizevic;i++)(listvic+i)->rec=NULL;
|
||
|
||
}
|
||
|
||
else cursizevic=bak->sizevic;
|
||
|
||
}
|
||
|
||
|
||
|
||
void FreeLVIC(BLVIC *bak)
|
||
|
||
{
|
||
|
||
if(bak==NULL)return;
|
||
|
||
free(bak->listvic);
|
||
|
||
free(bak);
|
||
|
||
}
|
||
|
||
|
||
|
||
void CompareLVIC(BLVIC *bak)
|
||
|
||
{
|
||
|
||
LVIC *bvic;
|
||
|
||
if(bak==NULL)return;
|
||
|
||
for(int i=0;i<bak->sizevic;i++){
|
||
|
||
if((bak->listvic+i)->rec != NULL){
|
||
|
||
bvic=bak->listvic+i;
|
||
|
||
int j;
|
||
|
||
for(j=0;j<cursizevic;j++){
|
||
|
||
if((listvic+j)->rec==bvic->rec){
|
||
|
||
if((listvic+j)->lnumber!=bvic->lnumber)bvic->rec=NULL;
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
if(j==cursizevic)bvic->rec=NULL;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
void ClearLVIC()
|
||
|
||
{
|
||
|
||
memset(listvic,0,cursizevic*sizeof(LVIC));
|
||
|
||
/* printf("%s(%d)> Init table LVIC\n",
|
||
|
||
startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
|
||
|
||
linenumber);*/
|
||
|
||
}
|
||
|
||
|
||
|
||
int Const2Var(ITOK *itok4,long long num,int typenum)
|
||
|
||
{
|
||
|
||
int i;
|
||
|
||
int freevic=-1;
|
||
|
||
if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0){
|
||
|
||
if((typenum==tk_word||typenum==tk_dword)&&num<256)typenum=tk_byte;
|
||
|
||
for(i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec==itok4->rec)break;
|
||
|
||
if(freevic==-1&&(listvic+i)->rec==NULL)freevic=i;
|
||
|
||
}
|
||
|
||
if(i==cursizevic){
|
||
|
||
if(freevic==-1){
|
||
|
||
cursizevic+=MAXSIZEVIC;
|
||
|
||
listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);
|
||
|
||
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)->rec=itok4->rec;
|
||
|
||
(listvic+i)->contype=typenum;
|
||
|
||
(listvic+i)->lnumber=num;
|
||
|
||
switch(itok4->type){
|
||
|
||
case tp_localvar:
|
||
|
||
case tp_paramvar:
|
||
|
||
(listvic+i)->typevar=tp_localvar;
|
||
|
||
break;
|
||
|
||
case tp_postvar:
|
||
|
||
case tp_gvar:
|
||
|
||
(listvic+i)->typevar=tp_gvar;
|
||
|
||
break;
|
||
|
||
default:
|
||
|
||
(listvic+i)->typevar=itok4->type;
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
/* printf("%s(%d)> %s var '%s' by num=%u type=%d\n",
|
||
|
||
startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
|
||
|
||
linenumber,
|
||
|
||
freevic==-1?"Update":"Add",
|
||
|
||
itok4->name,
|
||
|
||
(listvic+i)->number,
|
||
|
||
typenum);*/
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
|
||
void Const2VarRec(LVIC *varconst)
|
||
|
||
{
|
||
|
||
int i;
|
||
|
||
int freevic=-1;
|
||
|
||
if(replasevar==0)return;
|
||
|
||
for(i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec==varconst->rec)break;
|
||
|
||
if(freevic==-1&&(listvic+i)->rec==NULL)freevic=i;
|
||
|
||
}
|
||
|
||
if(i==cursizevic){
|
||
|
||
if(freevic==-1){
|
||
|
||
cursizevic+=MAXSIZEVIC;
|
||
|
||
listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);
|
||
|
||
for(freevic=cursizevic-1;freevic>i;freevic--)(listvic+freevic)->rec=NULL;
|
||
|
||
}
|
||
|
||
else i=freevic;
|
||
|
||
}
|
||
|
||
(listvic+i)->rec=varconst->rec;
|
||
|
||
(listvic+i)->contype=varconst->contype;
|
||
|
||
(listvic+i)->lnumber=varconst->lnumber;
|
||
|
||
switch(varconst->rec->type){
|
||
|
||
case tp_localvar:
|
||
|
||
case tp_paramvar:
|
||
|
||
(listvic+i)->typevar=tp_localvar;
|
||
|
||
break;
|
||
|
||
case tp_postvar:
|
||
|
||
case tp_gvar:
|
||
|
||
(listvic+i)->typevar=tp_gvar;
|
||
|
||
break;
|
||
|
||
default:
|
||
|
||
(listvic+i)->typevar=varconst->rec->type;
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
void ClearVarByNum(ITOK *itok4)
|
||
|
||
{
|
||
|
||
if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0){
|
||
|
||
for(int i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec==itok4->rec){
|
||
|
||
(listvic+i)->rec=NULL;
|
||
|
||
/* printf("%s(%d)> Clear by constant var '%s'\n",
|
||
|
||
startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
|
||
|
||
linenumber,
|
||
|
||
itok4->name);*/
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
int UpdVarConst(ITOK *itok4,long long num,int typenum,int operand)
|
||
|
||
{
|
||
|
||
int retcode=FALSE;
|
||
|
||
int i;
|
||
|
||
if(replasevar==0||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return TRUE;
|
||
|
||
for(i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec==itok4->rec){
|
||
|
||
// printf("%s(%d)> Modif var '%s' by num=%u ",startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,linenumber,itok4->name,(listvic+i)->number);
|
||
|
||
switch(operand){
|
||
|
||
case tk_plusequals:
|
||
|
||
case tk_plusplus: operand=tk_plus; break;
|
||
|
||
case tk_minusequals:
|
||
|
||
case tk_minusminus: operand=tk_minus; break;
|
||
|
||
case tk_xorequals: operand=tk_xor; break;
|
||
|
||
case tk_andequals: operand=tk_and; break;
|
||
|
||
case tk_orequals: operand=tk_or; break;
|
||
|
||
case tk_multequals: operand=tk_mult; break;
|
||
|
||
case tk_divequals: operand=tk_div; break;
|
||
|
||
case tk_rrequals: operand=tk_rr; break;
|
||
|
||
case tk_llequals: operand=tk_ll; break;
|
||
|
||
case tk_numsign:
|
||
|
||
if((listvic+i)->contype==tk_float)(listvic+i)->number|=0x80000000;
|
||
|
||
else if((listvic+i)->contype==tk_double)(listvic+i)->lnumber|=0x8000000000000000LL;
|
||
|
||
else (listvic+i)->lnumber=-(listvic+i)->lnumber;
|
||
|
||
return TRUE;;
|
||
|
||
case tk_not:
|
||
|
||
(listvic+i)->lnumber=~(listvic+i)->lnumber;
|
||
|
||
return TRUE;;
|
||
|
||
}
|
||
|
||
switch((listvic+i)->contype){
|
||
|
||
case tk_char:
|
||
|
||
case tk_int:
|
||
|
||
case tk_long:
|
||
|
||
retcode=calclongnumber(&(listvic+i)->number,num,operand);
|
||
|
||
break;
|
||
|
||
case tk_byte:
|
||
|
||
case tk_word:
|
||
|
||
case tk_dword:
|
||
|
||
retcode=calcdwordnumber((unsigned long *)&(listvic+i)->number,num,operand);
|
||
|
||
break;
|
||
|
||
case tk_qword:
|
||
|
||
retcode=calcqwordnumber((unsigned long long *)&(listvic+i)->lnumber,num,operand);
|
||
|
||
break;
|
||
|
||
case tk_float:
|
||
|
||
retcode=calcfloatnumber(&(listvic+i)->fnumber,*(float *) &num,operand);
|
||
|
||
break;
|
||
|
||
case tk_double:
|
||
|
||
retcode=calcdoublenumber(&(listvic+i)->dnumber,*(double *) &num,operand);
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
/* if(retcode)printf("new num=%u\n",(listvic+i)->number);
|
||
|
||
else{
|
||
|
||
puts("error");
|
||
|
||
(listvic+i)->rec=NULL;
|
||
|
||
} */
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
|
||
void FreeGlobalConst()
|
||
|
||
{
|
||
|
||
if(replasevar==0)return;
|
||
|
||
for(int i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec!=NULL&&(listvic+i)->typevar!=tp_localvar){
|
||
|
||
(listvic+i)->rec=NULL;
|
||
|
||
/* printf("%s(%d)> Clear global constant var\n",
|
||
|
||
startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
|
||
|
||
linenumber);*/
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
int CheckRegToConst(int reg,ITOK *itok4,int razr)
|
||
|
||
{
|
||
|
||
unsigned long num;
|
||
|
||
int typenum;
|
||
|
||
int nr;
|
||
|
||
nr=convertrazr(®,razr);
|
||
|
||
if(replasevar&&optinitreg!=FALSE&&razr<=r32&&(regstat+reg)->type==t_id&&
|
||
|
||
(regstat+reg)->razr>=nr){
|
||
|
||
if(isdigit((regstat+reg)->id[0])){
|
||
|
||
if(getnumber((regstat+reg)->id,&num,&typenum)){
|
||
|
||
Const2Var(itok4,num,typenum);
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
|
||
|
||
int CheckUpdRegToConst(int reg,ITOK *itok4,int operand,int razr)
|
||
|
||
{
|
||
|
||
unsigned long num;
|
||
|
||
int typenum;
|
||
|
||
int nr;
|
||
|
||
nr=convertrazr(®,razr);
|
||
|
||
if(replasevar&&optinitreg!=FALSE&&razr<=r32&&(regstat+reg)->type==t_id&&
|
||
|
||
(regstat+reg)->razr>=nr){
|
||
|
||
if(isdigit((regstat+reg)->id[0])){
|
||
|
||
if(getnumber((regstat+reg)->id,&num,&typenum))return UpdVarConst(itok4,num,typenum,operand);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
|
||
|
||
int SwapVarConst(ITOK *itok2,ITOK *itok4)
|
||
|
||
{
|
||
|
||
int i;
|
||
|
||
int fir=-1,sec=-1;
|
||
|
||
LVIC tempvic;
|
||
|
||
if(replasevar==0)return TRUE;
|
||
|
||
if(itok4->rec==NULL||(itok4->flag&f_useidx)!=0)sec=-2;
|
||
|
||
if(itok2->rec==NULL||(itok2->flag&f_useidx)!=0){
|
||
|
||
if(sec==-2)return TRUE;
|
||
|
||
fir=-2;
|
||
|
||
}
|
||
|
||
for(i=0;i<cursizevic;i++){
|
||
|
||
if(sec==-1&&(listvic+i)->rec==itok4->rec)sec=i;
|
||
|
||
else if(fir==-1&&(listvic+i)->rec==itok2->rec)fir=i;
|
||
|
||
}
|
||
|
||
if(sec==-2)sec=-1;
|
||
|
||
if(fir==-2)fir=-1;
|
||
|
||
if(sec!=-1&&fir!=-1){
|
||
|
||
memcpy(&tempvic,listvic+fir,sizeof(LVIC));
|
||
|
||
memcpy(listvic+fir,listvic+sec,sizeof(LVIC));
|
||
|
||
memcpy(listvic+sec,&tempvic,sizeof(LVIC));
|
||
|
||
}
|
||
|
||
else if(sec==-1&&fir!=-1)(listvic+fir)->rec=itok4->rec;
|
||
|
||
else if(fir==-1&&sec!=-1)(listvic+sec)->rec=itok2->rec;
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
|
||
int SwapVarRegConst(int reg,ITOK *itok4,int razr)
|
||
|
||
{
|
||
|
||
int i;
|
||
|
||
int freevic=-1;
|
||
|
||
unsigned long num;
|
||
|
||
int typenum;
|
||
|
||
int nr;
|
||
|
||
int numinreg=FALSE;
|
||
|
||
nr=convertrazr(®,razr);
|
||
|
||
if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0&&optinitreg!=FALSE&&razr<=r32&&
|
||
|
||
(regstat+reg)->type==t_id&&(regstat+reg)->razr>=nr){
|
||
|
||
for(i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec==itok4->rec)break;
|
||
|
||
if(freevic==-1&&(listvic+i)->rec==NULL)freevic=i;
|
||
|
||
}
|
||
|
||
if(isdigit((regstat+reg)->id[0])){
|
||
|
||
if(getnumber((regstat+reg)->id,&num,&typenum)){ //<2F><><EFBFBD><EFBFBD><EFBFBD> <20> ॣ<><E0A5A3><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
if(i!=cursizevic)ConstToReg((listvic+i)->lnumber,reg,razr); //<2F><><EFBFBD><EFBFBD><EFBFBD> <20> ॣ<><E0A5A3><EFBFBD><EFBFBD>
|
||
|
||
else{
|
||
|
||
if(freevic==-1){
|
||
|
||
cursizevic+=MAXSIZEVIC;
|
||
|
||
listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);
|
||
|
||
for(freevic=cursizevic-1;freevic>i;freevic--)(listvic+freevic)->rec=NULL;
|
||
|
||
}
|
||
|
||
else i=freevic;
|
||
|
||
}
|
||
|
||
(listvic+i)->rec=itok4->rec; //<2F><><EFBFBD><EFBFBD><EFBFBD> <20> <20><>६<EFBFBD><E0A5AC><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
(listvic+i)->contype=typenum;
|
||
|
||
(listvic+i)->lnumber=num;
|
||
|
||
switch(itok4->type){
|
||
|
||
case tp_localvar:
|
||
|
||
case tp_paramvar:
|
||
|
||
(listvic+i)->typevar=tp_localvar;
|
||
|
||
break;
|
||
|
||
case tp_postvar:
|
||
|
||
case tp_gvar:
|
||
|
||
(listvic+i)->typevar=tp_gvar;
|
||
|
||
break;
|
||
|
||
default:
|
||
|
||
(listvic+i)->typevar=itok4->type;
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
/* printf("%s(%d)> %s var '%s' by num=%u type=%d\n",
|
||
|
||
startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
|
||
|
||
linenumber,
|
||
|
||
freevic==-1?"Update":"Add",
|
||
|
||
itok4->name,
|
||
|
||
(listvic+i)->number,
|
||
|
||
typenum);*/
|
||
|
||
}
|
||
|
||
}
|
||
|
||
else{ //<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20> ॣ<><E0A5A3><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
if(i!=cursizevic){ //<2F><><EFBFBD><EFBFBD><EFBFBD> <20> <20><>६<EFBFBD><E0A5AC><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
ConstToReg((listvic+i)->lnumber,reg,razr); //⥯<><E2A5AF><EFBFBD> <20> ॣ<><E0A5A3><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
(listvic+i)->rec=NULL; //<2F> <20><><EFBFBD>६<EFBFBD><E0A5AC><EFBFBD><EFBFBD><EFBFBD> 㦥 <20><><EFBFBD>
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
|
||
int CheckConstVar(ITOK *itok4)
|
||
|
||
{
|
||
|
||
if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return FALSE;
|
||
|
||
if(itok4->rec&&(itok4->flag&f_useidx)==0){
|
||
|
||
for(int i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec==itok4->rec){
|
||
|
||
itok4->lnumber=(listvic+i)->lnumber;
|
||
|
||
itok4->rm=(listvic+i)->contype;
|
||
|
||
itok4->flag=0;
|
||
|
||
warreplasevar(itok4->name);
|
||
|
||
return TRUE;
|
||
|
||
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
|
||
|
||
int CheckConstVar2(ITOK *itok4,long long *num,int *typenum)
|
||
|
||
{
|
||
|
||
// if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return FALSE;
|
||
|
||
if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0){
|
||
|
||
for(int i=0;i<cursizevic;i++){
|
||
|
||
if((listvic+i)->rec==itok4->rec){
|
||
|
||
*num=(listvic+i)->lnumber;
|
||
|
||
*typenum=(listvic+i)->contype;
|
||
|
||
// warreplasevar(itok4->name);
|
||
|
||
return TRUE;
|
||
|
||
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
|
||
void updnum(int tok4,long long *num)
|
||
|
||
{
|
||
|
||
switch(tok4){
|
||
|
||
case tk_charvar:
|
||
|
||
case tk_bytevar:
|
||
|
||
*num=*num&0xff;
|
||
|
||
break;
|
||
|
||
case tk_intvar:
|
||
|
||
case tk_wordvar:
|
||
|
||
*num=*num&0xffff;
|
||
|
||
break;
|
||
|
||
case tk_longvar:
|
||
|
||
case tk_dwordvar:
|
||
|
||
*num=*num&0xffffffff;
|
||
|
||
break;
|
||
|
||
|
||
|
||
}
|
||
|
||
}
|
||
|
||
*/
|
||
|
||
|
||
|
||
void CheckConstVar3(int *tok4,ITOK *itok4,int razr)
|
||
|
||
{
|
||
|
||
long long lnum;
|
||
|
||
int rm;
|
||
|
||
if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return;
|
||
|
||
if(*tok4>=tk_charvar&&*tok4<=tk_doublevar){
|
||
|
||
if((optimizespeed||itok4->type==tp_gvar||itok4->type==tp_postvar||
|
||
|
||
itok4->number>127||(int)(itok4->number)<-127)&&CheckConstVar(itok4)){
|
||
|
||
switch(*tok4){
|
||
|
||
case tk_charvar:
|
||
|
||
case tk_bytevar:
|
||
|
||
itok4->lnumber=itok4->lnumber&0xff;
|
||
|
||
break;
|
||
|
||
case tk_intvar:
|
||
|
||
case tk_wordvar:
|
||
|
||
itok4->lnumber=itok4->lnumber&0xffff;
|
||
|
||
break;
|
||
|
||
case tk_longvar:
|
||
|
||
case tk_dwordvar:
|
||
|
||
itok4->lnumber=itok4->lnumber&0xffffffff;
|
||
|
||
break;
|
||
|
||
|
||
|
||
}
|
||
|
||
// updnum(*tok4,&itok4->lnumber);
|
||
|
||
// printf("tok=%d num=%d %s\n",*tok4,itok.number,itok.name);
|
||
|
||
*tok4=tk_number;
|
||
|
||
}
|
||
|
||
else{
|
||
|
||
if(CheckConstVar2(itok4,&lnum,&rm)){
|
||
|
||
if(short_ok(lnum,razr==r32?TRUE:FALSE)){
|
||
|
||
itok4->lnumber=lnum;
|
||
|
||
itok4->rm=rm;
|
||
|
||
*tok4=tk_number;
|
||
|
||
itok4->flag=0;
|
||
|
||
warreplasevar(itok4->name);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
#endif
|
||
|