6449 lines
162 KiB
C++
6449 lines
162 KiB
C++
|
||
#define _TOKA_
|
||
|
||
#include "tok.h"
|
||
|
||
#pragma option -w-pin
|
||
|
||
#ifdef _WIN32_
|
||
#include <windows.h>
|
||
#endif
|
||
|
||
#include <unistd.h>
|
||
#include <sys/stat.h>
|
||
|
||
#include "dirlist.h"
|
||
#include "id.h"
|
||
#include "resname.h"
|
||
|
||
struct idrec *treestart=NULL;
|
||
struct idrec *definestart=NULL;
|
||
UNDEFOFF *undefoffstart=NULL;
|
||
DLLLIST *listdll=NULL;
|
||
struct structteg *tegtree=NULL; //глобальный срисок тегов
|
||
struct structteg *ltegtree=NULL; //локальный срисок тегов
|
||
//struct idrec *lstructlist=NULL; //список локальных структур
|
||
SINFO strinf={NULL};
|
||
static int notdef=TRUE;
|
||
static char precha;
|
||
int scanalltoks=TRUE;
|
||
|
||
|
||
static volatile idrec **DynamicList=NULL;
|
||
static int sizeDL; //размер списка
|
||
static volatile int countDP; //число динамических процедур в списке
|
||
static int findofset=FALSE;
|
||
#define STEPDL 128; //шаг увеличения размера списка
|
||
ITOK structadr;
|
||
|
||
|
||
char id2[ID2S][9]={
|
||
"ESCHAR","ESBYTE","ESINT","ESWORD","ESLONG","ESDWORD","ESFLOAT","ESQWORD","ESDOUBLE",
|
||
"CSCHAR","CSBYTE","CSINT","CSWORD","CSLONG","CSDWORD","CSFLOAT","CSQWORD","CSDOUBLE",
|
||
"SSCHAR","SSBYTE","SSINT","SSWORD","SSLONG","SSDWORD","SSFLOAT","SSQWORD","SSDOUBLE",
|
||
"DSCHAR","DSBYTE","DSINT","DSWORD","DSLONG","DSDWORD","DSFLOAT","DSQWORD","DSDOUBLE",
|
||
"FSCHAR","FSBYTE","FSINT","FSWORD","FSLONG","FSDWORD","FSFLOAT","FSQWORD","FSDOUBLE",
|
||
"GSCHAR","GSBYTE","GSINT","GSWORD","GSLONG","GSDWORD","GSFLOAT","GSQWORD","GSDOUBLE",};
|
||
|
||
char regs[2][8][4]={"AX","CX","DX","BX","SP","BP","SI","DI",
|
||
"EAX","ECX","EDX","EBX","ESP","EBP","ESI","EDI"};
|
||
char begs[8][3]={"AL","CL","DL","BL","AH","CH","DH","BH"};
|
||
char segs[6][3]={"ES","CS","SS","DS","FS","GS"};
|
||
|
||
char mon[12][4]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug",
|
||
"Sep","Oct","Nov","Dec"};
|
||
|
||
unsigned char cha2;
|
||
char skipfind=FALSE; /* пропуск поиска в глобальном дереве и среди
|
||
локальных переменных */
|
||
static unsigned char savestring3=FALSE; //разрешить запись в буфер string3
|
||
static int posstr3; //указатель позиции в string3
|
||
|
||
unsigned int inptr2;
|
||
unsigned int linenum2=0; //если не нуль, то идет обраьотка
|
||
char displaytokerrors; /* flag to display errors, 0 for tok2 scan */
|
||
char *bufrm=NULL;
|
||
char *startline=NULL;
|
||
char *endinput=NULL;
|
||
unsigned char skiplocals=FALSE;
|
||
int scanlexmode=STDLEX;
|
||
unsigned char bytesize=TRUE;
|
||
|
||
COM_MOD *cur_mod=NULL;
|
||
|
||
void docals(struct idrec *ptr);
|
||
void dostructvar2(int *tok4,ITOK *itok4,struct structteg *tteg,unsigned char *string4); //разбор структур на переменные и структуры
|
||
void dosizeof(ITOK *itok4); //опр значение sizeof
|
||
void ofsstr(int *tok4,ITOK *itok4);
|
||
int searchlocals(ITOK *itok4,int *tok4,unsigned char *string4);
|
||
unsigned char convert_char();
|
||
void tokscan (int *tok4,ITOK *itok4,unsigned char *string4);
|
||
int calcnum(int *ctok,ITOK *cstok,char *cstring,long *retval);
|
||
int GetDirective(char *str);
|
||
int CheckAsmName(char *name);
|
||
void tag_massiv(int *tok4,ITOK *itok4,unsigned char *string4);
|
||
int CheckResName(char *name);
|
||
void GetTypeVar(int *tok4);
|
||
int RegToRM(int number,int tok4);
|
||
elementteg *FindClassEl(structteg *searcht,unsigned char *string4,int *addofs,
|
||
structteg *subteg);
|
||
int AskUseDestr(structteg *searcht);
|
||
int SaveStruct(int size,idrec *newrec);
|
||
int CheckDefPar(char *name);
|
||
int searchtree2(idrec *fptr,ITOK *itok4,int *tok4,unsigned char *string4);
|
||
|
||
extern void blockerror();
|
||
extern void block16_32error();
|
||
extern void notstructname();
|
||
extern void badtoken();
|
||
extern void opb(unsigned long num,unsigned int ofs,unsigned int size);
|
||
extern void CorrectOfsBit(int bitofs);
|
||
extern int skipstring(int pos,unsigned char term);
|
||
extern int skipcomment(int pos);
|
||
|
||
|
||
void retoldscanmode(int mode)
|
||
{
|
||
if(mode==STDLEX&&cha2==13&&tok!=tk_endline){
|
||
cha2=cha;
|
||
}
|
||
scanlexmode=mode;
|
||
}
|
||
|
||
void CheckConvertString(char *string4)
|
||
{
|
||
if(cha=='o'){
|
||
OemToChar(string4,string4);
|
||
nextchar();
|
||
}
|
||
else if(cha=='w'){
|
||
CharToOem(string4,string4);
|
||
nextchar();
|
||
}
|
||
}
|
||
|
||
void DateToStr(char *buf)
|
||
{
|
||
// GetDateFormat(LOCALE_SYSTEM_DEFAULT,DATE_SHORTDATE|LOCALE_NOUSEROVERRIDE,NULL,NULL,buf,80);
|
||
sprintf(buf,"%2d %s %d",timeptr.tm_mday,mon[timeptr.tm_mon],timeptr.tm_year+1900);
|
||
}
|
||
|
||
void compressoffset(ITOK *thetok)
|
||
{
|
||
if(thetok->sib==CODE16){
|
||
if(thetok->rm!=rm_d16){
|
||
thetok->rm&=7;
|
||
if(thetok->number==0){
|
||
if(thetok->rm==rm_BP)thetok->rm|=rm_mod01;
|
||
}
|
||
else if((int)thetok->number<128&&(int)thetok->number>=-128)thetok->rm|=rm_mod01;
|
||
else thetok->rm|=rm_mod10;
|
||
}
|
||
}
|
||
else{
|
||
if(thetok->rm!=rm_d32&&thetok->rm!=rm_sib){
|
||
thetok->rm&=7;
|
||
if(thetok->number==0){
|
||
if(thetok->rm==5)thetok->rm|=rm_mod01;
|
||
if(thetok->rm==4&&(thetok->sib&7)==5)thetok->rm|=rm_mod01;
|
||
}
|
||
else if(thetok->number<128&&thetok->number>=-128)thetok->rm|=rm_mod01;
|
||
else thetok->rm|=rm_mod10;
|
||
}
|
||
}
|
||
}
|
||
|
||
int CalcRm16(int base,int idx)
|
||
{
|
||
int rm;
|
||
rm=0;
|
||
switch(base+idx){
|
||
case 2: rm++;
|
||
case 4: rm++;
|
||
case 6: rm++;
|
||
case 5: rm++;
|
||
case 12: rm++;
|
||
case 11: rm++;
|
||
case 10: rm++;
|
||
}
|
||
return rm;
|
||
}
|
||
|
||
void SRBackBuf(int mode) //save/restore BackTextBlock
|
||
{
|
||
static int size=0;
|
||
static char *buf;
|
||
if(mode==0){
|
||
if(SizeBackBuf){
|
||
size=SizeBackBuf;
|
||
SizeBackBuf=0;
|
||
buf=BackTextBlock;
|
||
}
|
||
}
|
||
else{
|
||
SizeBackBuf=size;
|
||
size=0;
|
||
BackTextBlock=buf;
|
||
}
|
||
}
|
||
|
||
void ExpandRm(int rm,int sib,int *zoom,int *base,int *idx)
|
||
{
|
||
int rm0;
|
||
int reg1=-1,reg2=-1;
|
||
int z=0;
|
||
rm0=rm&0x7;
|
||
if(sib==CODE16||sib==(CODE16+1)){
|
||
switch(rm0){
|
||
case 0:
|
||
reg1=BX;
|
||
reg2=SI;
|
||
break;
|
||
case 1:
|
||
reg1=BX;
|
||
reg2=DI;
|
||
break;
|
||
case 2:
|
||
reg1=BP;
|
||
reg2=SI;
|
||
break;
|
||
case 3:
|
||
reg1=BP;
|
||
reg2=DI;
|
||
break;
|
||
case 4:
|
||
reg2=SI;
|
||
break;
|
||
case 5:
|
||
reg2=DI;
|
||
break;
|
||
case 6:
|
||
if((rm&0xC0)!=0)reg1=BP;
|
||
break;
|
||
case 7:
|
||
reg1=BX;
|
||
break;
|
||
}
|
||
}
|
||
else{
|
||
if(rm0==4){
|
||
reg1=sib&7;
|
||
reg2=(sib>>3)&7;
|
||
if(reg1==5&&(rm&0xc0)==0)reg1=-1;
|
||
if(reg2==4)reg2=-1;
|
||
else z=sib>>6;
|
||
}
|
||
else{
|
||
reg1=rm0;
|
||
if(reg1==5&&(rm&0xc0)==0)reg1=-1;
|
||
}
|
||
}
|
||
*base=reg1;
|
||
*idx=reg2;
|
||
*zoom=z;
|
||
}
|
||
|
||
int CheckZoom(int size)
|
||
{
|
||
int zoom=0;
|
||
switch(size){
|
||
case 8: zoom++;
|
||
case 4: zoom++;
|
||
case 2: zoom++;
|
||
}
|
||
return zoom;
|
||
}
|
||
|
||
void calcrm(ITOK *itok4,int ttok)//обработка выражения в []
|
||
{
|
||
int idx,base,razr=0,zoom,rm=0;
|
||
long numrm=0,cnum,ocnum;
|
||
int nextscan;
|
||
ITOK cstok,dstok;
|
||
int ctok,sopenb;
|
||
unsigned char *pstring;
|
||
unsigned int flag;
|
||
unsigned int sizevar=1;
|
||
unsigned int prevtok=tk_number,operand=tk_plus;
|
||
int dsword,dsword2;
|
||
nextchar();
|
||
whitespace();//пропуск незначащих символов
|
||
if(!displaytokerrors){
|
||
for(int i=1;i!=0;){
|
||
FastTok(0,&ctok,&cstok);
|
||
switch(ctok){
|
||
case tk_closeblock: i--; break;
|
||
case tk_openblock: i++; break;
|
||
case tk_eof: i=0; break;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
dsword2=dsword=itok4->post&POINTER;
|
||
itok4->post&=NOTPOINTER;
|
||
memcpy(&dstok,itok4,sizeof(ITOK));
|
||
ExpandRm(dstok.rm,dstok.sib,&zoom,&base,&idx);
|
||
if((dstok.sib==CODE16||dstok.sib==(CODE16+1))&&dstok.rm!=rm_d16)razr=r16;
|
||
if(am32&&dstok.rm!=rm_d32){
|
||
rm=dstok.rm&0xC0;
|
||
razr=r32;
|
||
}
|
||
// printf("in idx=%d base=%d zoom=%d\n",idx,base,zoom);
|
||
pstring=(unsigned char *)MALLOC(STRLEN);
|
||
sopenb=inptr;
|
||
char bcha=cha;
|
||
SRBackBuf(0);
|
||
flag=f_useidx;//0;//cstok.flag;
|
||
if(bytesize==FALSE){
|
||
sizevar=GetVarSize(ttok);
|
||
if(dsword)sizevar=1;
|
||
if(am32)zoom=CheckZoom(sizevar);
|
||
}
|
||
if(cha=='&'){
|
||
nextchar();
|
||
whitespace();//пропуск незначащих символов
|
||
sizevar=1;
|
||
zoom=0;
|
||
}
|
||
for(;;){
|
||
nextscan=TRUE;
|
||
if(cha=='#'&&dsword)dsword=1;
|
||
tokscan(&ctok,&cstok,pstring);
|
||
whitespace();//пропуск незначащих символов
|
||
if(dsword==1)strcpy(dstok.name,cstok.name);
|
||
// printf("tok=%d num=%d %s\n",ctok,cstok.number,cstok.name);
|
||
loopsw:
|
||
switch(ctok){
|
||
case tk_reg:
|
||
if(razr==0)razr=r16;
|
||
else if(razr==r32||sizevar!=1||operand!=tk_plus)goto runblock; //16.12.04 22:39
|
||
if(cstok.number==BP||cstok.number==BX){
|
||
if(base==-1)base=cstok.number;
|
||
else goto runblock;
|
||
}
|
||
else if(cstok.number==SI||cstok.number==DI){
|
||
if(idx==-1)idx=cstok.number;
|
||
else goto runblock;
|
||
}
|
||
else goto runblock;
|
||
prevtok=tk_reg;
|
||
break;
|
||
case tk_minus:
|
||
if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
|
||
prevtok=tk_number;
|
||
ocnum=cstok.number;
|
||
goto enumb;
|
||
case tk_number:
|
||
if(operand==tk_mult&&prevtok==tk_reg32){
|
||
if(zoom==0){
|
||
prevtok=tk_number;
|
||
if(razr==0)razr=r32;
|
||
else if(razr==r16)goto runblock;
|
||
zoom=CheckZoom(cstok.number);
|
||
if(zoom)break;
|
||
}
|
||
else goto runblock;
|
||
}
|
||
prevtok=tk_number;
|
||
ocnum=cstok.number;
|
||
if(zoom==0&&razr!=r16&&(idx==-1||base==-1)){
|
||
if((zoom=CheckZoom(cstok.number))!=0){
|
||
if(cha=='*'){
|
||
nextchar();
|
||
tokscan(&ctok,&cstok,pstring);
|
||
if(ctok==tk_reg32){
|
||
if(idx!=-1)base=idx;
|
||
idx=cstok.number;
|
||
prevtok=tk_reg32;
|
||
if(razr==0)razr=r32;
|
||
break;
|
||
}
|
||
if(ctok==tk_number){
|
||
calclongnumber(&ocnum,cstok.number,tk_mult);
|
||
numrm+=ocnum;
|
||
zoom=0;
|
||
break;
|
||
}
|
||
goto runblock;
|
||
}
|
||
zoom=0;
|
||
}
|
||
}
|
||
if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
|
||
enumb:
|
||
flag^=cstok.flag;
|
||
whitespace();//пропуск незначащих символов
|
||
ocnum=cnum;
|
||
numrm+=cnum;
|
||
if(cstok.type==tp_opperand||cstok.type==tp_stopper)nextscan=FALSE;
|
||
else{
|
||
operand=tk_plus;
|
||
goto loopsw;
|
||
}
|
||
break;
|
||
case tk_reg32:
|
||
// printf("prevtok=%d operand=%d ocnum=%d idx=%d base=%d zoom=%d\n",prevtok,operand,ocnum,idx,base,zoom);
|
||
if(razr==0)razr=r32;
|
||
if(razr==r16||(operand!=tk_plus&&operand!=tk_mult)||(idx!=-1&&base!=-1))goto runblock;
|
||
if(sizevar!=1){
|
||
if(idx!=-1)goto runblock;
|
||
idx=cstok.number;
|
||
}
|
||
else if(operand==tk_mult){
|
||
if(prevtok!=tk_number)goto runblock;
|
||
zoom=CheckZoom(ocnum);
|
||
numrm-=ocnum;
|
||
if(idx!=-1)base=idx;
|
||
idx=cstok.number;
|
||
}
|
||
else if(cha=='*'){
|
||
if(idx!=-1)base=idx;
|
||
idx=cstok.number;
|
||
}
|
||
else if(base==-1)base=cstok.number;
|
||
else if(idx==-1)idx=cstok.number;
|
||
// else goto runblock;
|
||
prevtok=tk_reg32;
|
||
break;
|
||
case tk_postnumber:
|
||
if(dsword==0||sizevar!=1)goto runblock;
|
||
if((cstok.post&USED_DIN_VAR)==USED_DIN_VAR){ //динамическая переменная
|
||
if(dstok.rec!=NULL)goto runblock;
|
||
dstok.rec=cstok.rec;
|
||
}
|
||
if(operand==tk_minus)numrm-=cstok.number;
|
||
else numrm+=cstok.number;
|
||
dstok.post|=cstok.post;
|
||
prevtok=tk_number;
|
||
break;
|
||
case tk_undefofs:
|
||
if(dsword==0||sizevar!=1)goto runblock;
|
||
if(operand==tk_minus)numrm-=cstok.number;
|
||
else numrm+=cstok.number;
|
||
dstok.post|=UNDEF_OFSET;
|
||
strcpy(dstok.name,cstok.name);
|
||
flag^=cstok.flag;
|
||
prevtok=tk_number;
|
||
break;
|
||
case tk_rmnumber:
|
||
/* if(strinf.bufstr!=NULL){
|
||
free(strinf.bufstr);
|
||
strinf.bufstr=NULL;
|
||
goto runblock;
|
||
}*/
|
||
if(dsword==0||sizevar!=1)goto runblock;
|
||
if(operand==tk_minus)numrm-=cstok.number;
|
||
else numrm+=cstok.number;
|
||
dstok.post|=cstok.post;
|
||
if(dstok.sib==CODE16){
|
||
if(cstok.rm!=rm_d16){
|
||
switch(cstok.rm&7){
|
||
case 0:
|
||
if(base!=-1||idx!=-1)goto runblock;
|
||
base=BX; idx=SI; break;
|
||
case 1:
|
||
if(base!=-1||idx!=-1)goto runblock;
|
||
base=BX; idx=DI; break;
|
||
case 2:
|
||
if(base!=-1||idx!=-1)goto runblock;
|
||
base=BP; idx=SI; break;
|
||
case 3:
|
||
if(base!=-1||idx!=-1)goto runblock;
|
||
base=BP; idx=DI; break;
|
||
case 4:
|
||
if(idx!=-1)goto runblock;
|
||
idx=SI; break;
|
||
case 5:
|
||
if(idx!=-1)goto runblock;
|
||
idx=DI; break;
|
||
case 6:
|
||
if(idx!=-1)goto runblock;
|
||
base=BP; break;
|
||
case 7:
|
||
if(idx!=-1)goto runblock;
|
||
base=BX; break;
|
||
}
|
||
}
|
||
razr=r16;
|
||
}
|
||
else{
|
||
if(cstok.rm!=rm_d32){
|
||
rm=cstok.rm&0xC0;
|
||
cstok.rm&=7;
|
||
if(base==-1)base=cstok.rm;
|
||
else if(idx==-1){
|
||
idx=base;
|
||
base=cstok.rm;
|
||
}
|
||
else goto runblock;
|
||
if(base==4){
|
||
base=cstok.sib&7;
|
||
idx=(cstok.sib>>3)&7;
|
||
if(base==5&&rm==0)base=-1;
|
||
if(idx==4)idx=-1;
|
||
}
|
||
}
|
||
else dstok.flag|=cstok.flag&f_reloc;
|
||
razr=r32;
|
||
}
|
||
break;
|
||
//-----------------28.07.98 13:59-------------------
|
||
// var[i]
|
||
//--------------------------------------------------
|
||
default:
|
||
runblock:
|
||
if(dsword2){
|
||
CharToBackBuf('&');
|
||
if(strinf.bufstr){
|
||
free(strinf.bufstr);
|
||
strinf.bufstr=NULL;
|
||
}
|
||
}
|
||
AddBackBuf(sopenb,bcha);
|
||
if(bufrm){
|
||
if(strcmp(bufrm,"&this;")==0){
|
||
free(bufrm);
|
||
CharToBackBuf(0);
|
||
sprintf((char *)string3,"&%s*%d+this;",BackTextBlock,GetVarSize(ttok));
|
||
bufrm=BackString((char *)string3);
|
||
// puts((char *)string3);
|
||
goto con1;
|
||
}
|
||
else free(bufrm);
|
||
}
|
||
CharToBackBuf(';');
|
||
CharToBackBuf(0);
|
||
bufrm=(char *)REALLOC(BackTextBlock,SizeBackBuf+1);
|
||
con1:
|
||
if(cha!=']')blockerror();
|
||
tokscan(&ctok,&cstok,pstring);
|
||
if(itok4->sib>=CODE16)itok4->sib++;
|
||
SRBackBuf(1);
|
||
// if(itok4->post&POINTER)itok4->post=0;//&=NOTPOINTER;
|
||
free(pstring);
|
||
itok4->flag|=flag;
|
||
return;
|
||
//-----------------28.07.98 13:59-------------------
|
||
// end
|
||
//--------------------------------------------------
|
||
}
|
||
if(dsword==1)dsword=0;
|
||
if(nextscan){
|
||
tokscan(&ctok,&cstok,pstring);
|
||
whitespace();//пропуск незначащих символов
|
||
}
|
||
while(ctok==tk_minus){
|
||
if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
|
||
whitespace();//пропуск незначащих символов
|
||
numrm+=cnum;
|
||
flag^=cstok.flag;
|
||
if(cstok.type!=tp_opperand&&cstok.type!=tp_stopper){
|
||
operand=tk_plus;
|
||
goto loopsw;
|
||
}
|
||
}
|
||
operand=ctok;
|
||
// printf("operand tok=%d flag=%08X %s\n",ctok,cstok.flag,cstok.name);
|
||
if(ctok==tk_closeblock||ctok==tokens||ctok==tk_eof)break;
|
||
if(ctok!=tk_plus&&ctok!=tk_mult)goto runblock;
|
||
// flag|=cstok.flag;
|
||
}
|
||
// printf("out idx=%d base=%d zoom=%d\n",idx,base,zoom);
|
||
SRBackBuf(1);
|
||
if(ctok!=tk_closeblock)expected(']');
|
||
numrm*=sizevar;
|
||
dstok.number+=numrm;
|
||
if(razr==r16){
|
||
if(idx==-1&&base==-1)cstok.rm=6;
|
||
else{
|
||
cstok.rm=CalcRm16(base,idx)|rm_mod10;
|
||
dstok.sib=CODE16;
|
||
}
|
||
}
|
||
else if(razr==0){
|
||
if(dstok.number<65536&&dstok.number>-65535)cstok.rm=6;
|
||
else{
|
||
cstok.rm=5;
|
||
dstok.sib=0;
|
||
}
|
||
if(am32)cstok.rm=5;
|
||
}
|
||
else{
|
||
// printf("razr=%d sib=%08X %s\n",razr,dstok.sib,dstok.name);
|
||
if(dstok.sib>CODE32)dstok.sib-=CODE32;
|
||
else dstok.sib=0;
|
||
if(idx!=-1){
|
||
cstok.rm=4;
|
||
if(idx==4)preerror("ESP cannot be the index register");
|
||
if(base!=-1)dstok.sib=(zoom<<6)+(idx<<3)+base;
|
||
else{
|
||
dstok.sib=(zoom<<6)+(idx<<3)+5;
|
||
rm=(base==5?rm_mod10:0);
|
||
}
|
||
}
|
||
else{
|
||
if(base==4){
|
||
dstok.sib=(4<<3)+4;
|
||
cstok.rm=4;
|
||
}
|
||
else if(base==-1){
|
||
cstok.rm=rm_d32;
|
||
}
|
||
else cstok.rm=base;
|
||
}
|
||
if(base!=-1||rm!=0)cstok.rm|=rm_mod10; //корекция MOD будет позднее, а сейчас максимум
|
||
}
|
||
dstok.rm=cstok.rm;
|
||
dstok.flag|=flag;
|
||
memcpy(itok4,&dstok,sizeof(ITOK));
|
||
free(pstring);
|
||
}
|
||
|
||
int calcnum(int *ctok,ITOK *cstok,char *cstring,long *retval)
|
||
{
|
||
long value;
|
||
unsigned int flag;
|
||
if(*ctok==tk_minus){
|
||
tokscan(ctok,cstok,(unsigned char *)cstring);
|
||
if(*ctok!=tk_number)return(0);
|
||
cstok->number=-cstok->number;
|
||
}
|
||
else if(*ctok!=tk_number)return(0);
|
||
value=cstok->number;
|
||
flag=cstok->flag;
|
||
for(;;){
|
||
int otok;
|
||
tokscan(ctok,cstok,(unsigned char *)cstring);
|
||
otok=*ctok;
|
||
if(otok==tk_closeblock)break;
|
||
tokscan(ctok,cstok,(unsigned char *)cstring);
|
||
if(*ctok!=tk_number){
|
||
if(*ctok==tk_reg32&&(otok==tk_mult||otok==tk_minus)){
|
||
*ctok=(unsigned int)cstok->number;
|
||
*retval=value;
|
||
cstok->flag=flag;
|
||
return 0;
|
||
}
|
||
break;
|
||
}
|
||
if(calclongnumber(&value,cstok->number,otok)==FALSE){
|
||
if(displaytokerrors)blockerror();
|
||
break;
|
||
}
|
||
/* switch(otok){
|
||
case tk_minus: value-=cstok->number; break;
|
||
case tk_plus: value+=cstok->number; break;
|
||
case tk_xor: value^=cstok->number; break;
|
||
case tk_and: value&=cstok->number; break;
|
||
case tk_or: value|=cstok->number; break;
|
||
case tk_mod: value%=cstok->number; break;
|
||
case tk_div: value/=cstok->number; break;
|
||
case tk_mult: value*=cstok->number; break;
|
||
case tk_rr: value>>=cstok->number; break;
|
||
case tk_ll: value<<=cstok->number; break;
|
||
case tk_xorminus: value^=-cstok->number; break;
|
||
case tk_andminus: value&=-cstok->number; break;
|
||
case tk_orminus: value|=-cstok->number; break;
|
||
case tk_modminus: value%=-cstok->number; break;
|
||
case tk_divminus: value/=-cstok->number; break;
|
||
case tk_multminus: value*=-cstok->number; break;
|
||
case tk_rrminus: value>>=-cstok->number; break;
|
||
case tk_llminus: value<<=-cstok->number; break;
|
||
default: if(displaytokerrors)blockerror(); goto end;
|
||
}*/
|
||
flag^=cstok->flag;
|
||
}
|
||
//end:
|
||
cstok->flag=flag;
|
||
*retval=value;
|
||
return -1;
|
||
}
|
||
|
||
void CheckReg(int idx,int base,int *reg1,int *reg2,int razr)
|
||
{
|
||
if(razr==r32){
|
||
unsigned char lreg[16];
|
||
int i;
|
||
for(i=0;i<8;i++){
|
||
if(i==ESP||i==EBP)lreg[i]=1;
|
||
else{
|
||
if((idx!=-1&&idx==i)||(base!=-1&&base==i))lreg[i]=1;
|
||
else lreg[i]=0;
|
||
}
|
||
// printf("%c",lreg[i]+'0');
|
||
}
|
||
if(lreg[*reg1]==0)lreg[*reg1]=1;
|
||
else{
|
||
for(i=8;i!=0;i--){
|
||
if(lreg[i]==0){
|
||
lreg[i]=1;
|
||
*reg1=i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
// printf("\nreg1=%d",*reg1);
|
||
if(lreg[*reg2]!=0){
|
||
for(i=8;i!=0;i--){
|
||
if(lreg[i]==0){
|
||
*reg2=i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
// printf(" reg2=%d\n",*reg2);
|
||
}
|
||
else{
|
||
if(base!=-1){
|
||
if(base==*reg1)*reg1=SI;
|
||
else if(base==*reg2)*reg2=DI;
|
||
if(*reg1==*reg2){
|
||
if(*reg1==SI)*reg2=DI;
|
||
else *reg2=SI;
|
||
}
|
||
}
|
||
if(idx!=-1){
|
||
if(idx==SI)*reg1=DI;
|
||
else *reg1=SI;
|
||
*reg2=CX;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CheckAllMassiv(char *&buf,int sizeel,SINFO *strc,ITOK *ctok,int reg1,int reg2)
|
||
{
|
||
int zoom0,idx0,base0,newreg;
|
||
int zoom1=0,zoom2=0;
|
||
char pv=FALSE;
|
||
int razr=r32;
|
||
//printf("sib=%X\n",ctok->sib);
|
||
switch(ctok->sib){
|
||
case CODE16+2:
|
||
case CODE32+2: ctok->sib--;
|
||
case CODE16+1:
|
||
case CODE32+1: ctok->sib--;
|
||
}
|
||
if(ctok->sib==CODE16){
|
||
razr=r16;
|
||
if(am32)block16_32error();
|
||
}
|
||
if(buf==NULL&&strc->bufstr==NULL)return;
|
||
ExpandRm(ctok->rm,ctok->sib,&zoom0,&base0,&idx0);
|
||
if(base0==-1&&idx0!=-1&&zoom0==0){
|
||
base0=idx0;
|
||
idx0=-1;
|
||
}
|
||
CheckReg(idx0,base0,®1,®2,razr);
|
||
// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
|
||
if(buf!=NULL){
|
||
if(*buf=='&'){
|
||
sizeel=1;
|
||
pv=TRUE;
|
||
ctok->flag&=~f_reloc;
|
||
}
|
||
if((newreg=CheckIDXReg(buf,sizeel,reg1))!=NOINREG){
|
||
if(newreg!=SKIPREG){
|
||
if(razr==r16){
|
||
if(newreg!=BX&&newreg!=DI&&newreg!=SI&&newreg!=BP)goto noopt;
|
||
if(base0!=-1&&(newreg==BX||newreg==BP))goto noopt;
|
||
if(idx0!=-1&&(newreg==DI||newreg==SI))goto noopt;
|
||
}
|
||
waralreadinitreg(regs[am32][reg1],regs[am32][newreg]);
|
||
reg1=newreg;
|
||
}
|
||
free(buf);
|
||
buf=NULL;
|
||
}
|
||
else{
|
||
if(razr==r32){
|
||
if((zoom1=CheckZoom(sizeel))){
|
||
sizeel=1;
|
||
if((newreg=CheckIDXReg(buf,sizeel,reg1))!=NOINREG){
|
||
if(newreg!=SKIPREG){
|
||
waralreadinitreg(regs[1][reg1],regs[1][newreg]);
|
||
reg2=reg1;
|
||
reg1=newreg;
|
||
}
|
||
free(buf);
|
||
buf=NULL;
|
||
goto cont1;
|
||
}
|
||
}
|
||
}
|
||
noopt:
|
||
if(razr==r32&&idx0==-1&&base0==-1&&zoom1==0){
|
||
ITOK wtok;
|
||
wtok=*ctok;
|
||
newreg=CheckMassiv(buf,sizeel,reg1,&idx0,&base0,&wtok.number);
|
||
*ctok=wtok;
|
||
// newreg=CheckMassiv(buf,sizeel,reg1);
|
||
}
|
||
else newreg=CheckMassiv(buf,sizeel,reg1);
|
||
if(newreg!=-1){
|
||
reg2=reg1;
|
||
reg1=newreg;
|
||
}
|
||
}
|
||
}
|
||
else{
|
||
reg2=reg1;
|
||
reg1=-1;
|
||
}
|
||
cont1:
|
||
// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
|
||
if(strc->bufstr!=NULL){
|
||
sizeel=strc->size;
|
||
if((newreg=CheckIDXReg(strc->bufstr,sizeel,reg2))!=NOINREG){
|
||
if(newreg!=SKIPREG){
|
||
if(razr==r16){
|
||
if(newreg!=BX&&newreg!=DI&&newreg!=SI&&newreg!=BP)goto noopt2;
|
||
if(base0!=-1&&(newreg==BX||newreg==BP))goto noopt2;
|
||
if(idx0!=-1&&(newreg==DI||newreg==SI))goto noopt2;
|
||
}
|
||
waralreadinitreg(regs[am32][reg2],regs[am32][newreg]);
|
||
reg2=newreg;
|
||
}
|
||
free(strc->bufstr);
|
||
strc->bufstr=NULL;
|
||
}
|
||
else{
|
||
if(razr==r32&&zoom1==0){
|
||
if((zoom2=CheckZoom(sizeel))){
|
||
sizeel=1;
|
||
if((newreg=CheckIDXReg(strc->bufstr,sizeel,reg2))!=NOINREG){
|
||
if(newreg!=SKIPREG){
|
||
waralreadinitreg(regs[2][reg1],regs[2][newreg]);
|
||
reg2=newreg;
|
||
}
|
||
free(strc->bufstr);
|
||
strc->bufstr=NULL;
|
||
goto cont2;
|
||
}
|
||
}
|
||
}
|
||
noopt2:
|
||
if((newreg=CheckMassiv(strc->bufstr,sizeel,reg2))!=-1)reg2=newreg;
|
||
}
|
||
cont2:
|
||
if(reg1==-1){
|
||
reg1=reg2;
|
||
zoom1=zoom2;
|
||
reg2=-1;
|
||
zoom2=0;
|
||
}
|
||
}
|
||
else reg2=-1;
|
||
// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
|
||
if(base0==-1){
|
||
if(reg1!=-1&&zoom1==0){
|
||
base0=reg1;
|
||
reg1=reg2;
|
||
zoom1=zoom2;
|
||
reg2=-1;
|
||
zoom2=0;
|
||
}
|
||
else if(reg2!=-1&&zoom2==0){
|
||
base0=reg2;
|
||
reg2=-1;
|
||
}
|
||
}
|
||
if(idx0==-1){
|
||
if(zoom1){
|
||
zoom0=zoom1;
|
||
zoom1=0;//zoom2;
|
||
idx0=reg1;
|
||
reg1=reg2;
|
||
reg2=-1;
|
||
}
|
||
else{
|
||
if(reg1!=-1){
|
||
idx0=reg1;
|
||
reg1=reg2;
|
||
zoom1=zoom2;
|
||
reg2=-1;
|
||
zoom2=0;
|
||
}
|
||
}
|
||
}
|
||
// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
|
||
if(reg2!=-1){
|
||
if(zoom1==0&&zoom2==0){
|
||
op(3);
|
||
op(0xC0+reg1*8+reg2); //add reg1,reg2
|
||
}
|
||
else{
|
||
if(zoom1==0){
|
||
op(0x8d); //lea reg1,[reg1+reg2*zoom2]
|
||
op(reg1*8+4);
|
||
op((zoom2<<6)+(reg2<<3)+reg1);
|
||
}
|
||
else{
|
||
op(0x8d); //lea reg1,[reg2+reg1*zoom1]
|
||
op(reg1*8+4);
|
||
op((zoom1<<6)+(reg1<<3)+reg2);
|
||
zoom1=0;
|
||
}
|
||
}
|
||
ClearReg(reg1);
|
||
}
|
||
if(reg1!=-1){
|
||
if(base0!=-1){
|
||
if(zoom1==0){
|
||
op(3);
|
||
op(0xC0+reg1*8+base0); //add reg1,base0
|
||
}
|
||
else{
|
||
op(0x8d); //lea reg1,[base0+reg1*zoom1]
|
||
op(reg1*8+4);
|
||
op((zoom1<<6)+(reg1<<3)+base0);
|
||
}
|
||
}
|
||
else if(zoom1){
|
||
op(0xC1);
|
||
op(0xE0+reg1); //shl reg2,zoom2
|
||
op(zoom1);
|
||
}
|
||
base0=reg1;
|
||
}
|
||
if(razr==r32){
|
||
ctok->sib=CODE32;
|
||
if(idx0!=-1){
|
||
ctok->rm=4;
|
||
if(base0!=-1){
|
||
ctok->sib=(zoom0<<6)+(idx0<<3)+base0;
|
||
ctok->rm|=rm_mod10;
|
||
}
|
||
else ctok->sib=(zoom0<<6)+(idx0<<3)+5;
|
||
}
|
||
else{
|
||
ctok->rm=base0;
|
||
if(pv==FALSE)ctok->rm|=rm_mod10;
|
||
}
|
||
}
|
||
else{
|
||
if(base0==SI||base0==DI){
|
||
if(idx0==BX||idx0==BP||idx0==-1){
|
||
newreg=idx0;
|
||
idx0=base0;
|
||
base0=newreg;
|
||
}
|
||
else{
|
||
op(3);
|
||
op(0xC0+base0*8+idx0); //add base0,idx0
|
||
idx0=base0;
|
||
base0=-1;
|
||
}
|
||
}
|
||
if(idx0==BX||idx0==BP){
|
||
if(base0==-1){
|
||
newreg=idx0;
|
||
idx0=base0;
|
||
base0=newreg;
|
||
}
|
||
else{
|
||
op(3);
|
||
op(0xC0+base0*8+idx0); //add base0,idx0
|
||
idx0=base0;
|
||
base0=-1;
|
||
}
|
||
}
|
||
ctok->rm=CalcRm16(base0,idx0)|rm_mod10;
|
||
}
|
||
if(ctok->post==0&&(ctok->flag&f_reloc)==0)compressoffset(ctok);
|
||
}
|
||
|
||
int CheckMassiv(char *&buf,int sizeel,int treg,int *idx,int *base,long *num)
|
||
{
|
||
ITOK oitok;
|
||
SINFO ostr;
|
||
unsigned char *oldinput;
|
||
unsigned int oldinptr,oldendinptr;
|
||
unsigned char bcha;
|
||
int otok;
|
||
char *ostring;
|
||
char *ofsst;
|
||
int retcode=-1;
|
||
|
||
//07.09.04 22:45
|
||
COM_MOD *ocurmod=cur_mod;
|
||
cur_mod=NULL;
|
||
/////////////////
|
||
ostring=BackString((char *)string);
|
||
ofsst=BackString(buf);
|
||
free(buf);
|
||
buf=NULL;
|
||
oldinput=input; //сохр некотор переменые
|
||
oldinptr=inptr2;
|
||
bcha=cha2;
|
||
oldendinptr=endinptr;
|
||
otok=tok;
|
||
oitok=itok;
|
||
ostr=strinf;
|
||
strinf.bufstr=NULL;
|
||
|
||
if(idx&&*idx==-1&&*base==-1){
|
||
char *tbuf;
|
||
int i;
|
||
int idx0,base0;
|
||
long numr;
|
||
int operand;
|
||
int startptr,skipvar;
|
||
int firsttok;
|
||
i=0;
|
||
idx0=base0=-1;
|
||
numr=0;
|
||
if(*ofsst=='&')i++;
|
||
tbuf=BackString(ofsst+i);
|
||
// puts(tbuf);
|
||
input=(unsigned char *)tbuf;
|
||
inptr2=1;
|
||
cha2=input[0];
|
||
endinptr=strlen((char *)input);
|
||
operand=tk_plus;
|
||
startptr=0;
|
||
firsttok=tk_eof;
|
||
do{
|
||
skipvar=FALSE;
|
||
getoperand();
|
||
if(operand==tk_plus){
|
||
if(tok==tk_reg32){
|
||
if(itok.number!=treg){
|
||
skipvar=TRUE;
|
||
if(idx0==-1)idx0=itok.number;
|
||
else if(base0==-1)base0=itok.number;
|
||
else skipvar=FALSE;
|
||
}
|
||
else if(firsttok==tk_eof)firsttok=tk_reg32;
|
||
}
|
||
else if(tok==tk_number){
|
||
numr+=itok.number;
|
||
skipvar=TRUE;
|
||
}
|
||
else if(firsttok==tk_eof)firsttok=tok;
|
||
}
|
||
if(operand==tk_minus&&tok==tk_number){
|
||
numr-=itok.number;
|
||
skipvar=TRUE;
|
||
}
|
||
if(skipvar){
|
||
for(;startptr<inptr2-1;startptr++)input[startptr]=' ';
|
||
}
|
||
startptr=inptr2-1;
|
||
nexttok();
|
||
if(tok==tk_plus||tok==tk_minus){
|
||
if(firsttok==tk_eof){
|
||
if(tok==tk_minus)break;
|
||
for(;startptr<inptr2-1;startptr++)input[startptr]=' ';
|
||
startptr=inptr2-1;
|
||
firsttok=tok;
|
||
}
|
||
operand=tok;
|
||
}
|
||
else break;
|
||
}while(1);
|
||
// printf("%s (%u) >%s\n",(startfileinfo+currentfileinfo)->filename,linenumber,tbuf);
|
||
if(tok==tk_semicolon/*&&(idx0!=-1||base0!=-1)*/){
|
||
*idx=idx0;
|
||
*base=base0;
|
||
*num+=numr;
|
||
free(ofsst);
|
||
ofsst=tbuf;
|
||
// printf("idx0=%d base0=%d num=%d\n",idx0,base0,numr);
|
||
}
|
||
else free(tbuf);
|
||
}
|
||
|
||
input=(unsigned char *)ofsst;
|
||
inptr2=1;
|
||
cha2=input[0];
|
||
if(cha2=='&'){
|
||
inptr2=2;
|
||
cha2=input[1];
|
||
}
|
||
endinptr=strlen((char *)input);
|
||
getoperand();
|
||
if(am32&&sizeel==1&&tok==tk_reg32&&itok2.type==tp_stopper)retcode=itok.number;
|
||
else{
|
||
warningreg(regs[am32][treg]);
|
||
if((chip==7||chip==8)&&am32==FALSE&&((sizeel>1&&sizeel<6)||sizeel==8||sizeel==9)){
|
||
//избежать обращение к частному регистру
|
||
op(0x31);
|
||
op(0xC0+treg*9);
|
||
}
|
||
ofsst=NULL;
|
||
if(treg==AX)do_e_axmath(0,(am32+1)*2,&ofsst);
|
||
else getintoreg(treg,(am32+1)*2,0,&ofsst);
|
||
IDXToReg((char *)input,sizeel,treg);
|
||
}
|
||
strinf=ostr;
|
||
tok=otok;
|
||
itok=oitok;
|
||
endoffile=0;
|
||
free(input);
|
||
input=oldinput;
|
||
inptr2=oldinptr;
|
||
cur_mod=ocurmod; //07.09.04 22:45
|
||
cha2=bcha;
|
||
endinptr=oldendinptr;
|
||
otok=0;
|
||
strcpy((char *)string,ostring);
|
||
free(ostring);
|
||
if(sizeel>1)RegMulNum(treg,sizeel,(am32+1)*2,0,&otok,0);
|
||
return retcode;
|
||
}
|
||
|
||
void nextchar()
|
||
{
|
||
if(inptr<endinptr){
|
||
cha=input[inptr];
|
||
endoffile=0;
|
||
if(savestring3)string3[posstr3++]=cha;
|
||
inptr++;
|
||
precha=0;
|
||
if(inptr==endinptr&&cur_mod&&displaytokerrors){
|
||
precha=cur_mod->input[cur_mod->inptr];
|
||
// printf("cha=%02X\n",cha);
|
||
}
|
||
}
|
||
else{
|
||
if(cur_mod){
|
||
if(displaytokerrors){
|
||
inptr=cur_mod->inptr;
|
||
input=cur_mod->input;
|
||
// printf("last cha=%02X\n",input[inptr]);
|
||
|
||
if(cur_mod->numparamdef)clearregstat();
|
||
|
||
endinptr=cur_mod->endinptr;
|
||
linenumber=cur_mod->linenumber;
|
||
currentfileinfo=cur_mod->currentfileinfo;
|
||
COM_MOD *temp=cur_mod;
|
||
cur_mod=cur_mod->next;
|
||
if(temp->freze==FALSE){
|
||
if(temp->paramdef)free(temp->paramdef);
|
||
// if(debug)printf("Free curmod %08X new cur_mod %08X\n",temp,cur_mod);
|
||
free(temp);
|
||
}
|
||
// else if(debug)printf("Freze curmod %08X\n",temp);
|
||
nextchar();
|
||
// printf("%c\n",cha);
|
||
if(!cur_mod)notdef=TRUE;
|
||
}
|
||
else{
|
||
cha=cur_mod->input[cur_mod->inptr2];
|
||
cur_mod->inptr2++;
|
||
}
|
||
}
|
||
else{
|
||
cha=26;
|
||
endoffile++;
|
||
if(endoffile>2)unexpectedeof();
|
||
}
|
||
}
|
||
}
|
||
|
||
void ScanTok2()
|
||
{
|
||
inptr2=inptr;
|
||
linenum2=linenumber;
|
||
cha2=cha;
|
||
displaytokerrors=0;
|
||
tokscan(&tok2,&itok2,string2);
|
||
}
|
||
|
||
unsigned int ScanTok3()
|
||
{
|
||
unsigned int oinptr,oline,otok,rtok;
|
||
unsigned char ocha;
|
||
ITOK oitok;
|
||
ocha=cha;
|
||
oinptr=inptr;
|
||
oline=linenumber;
|
||
otok=tok;
|
||
oitok=itok;
|
||
do{
|
||
FastTok(1);
|
||
if(tok==tk_id||tok==tk_ID){
|
||
char disp=displaytokerrors;
|
||
displaytokerrors=0;
|
||
strcpy((char *)string3,itok.name);
|
||
searchtree(&itok,&tok,string3); //NEW 09.06.06 20:29
|
||
// searchtree2(definestart,&itok,&tok,string3);
|
||
displaytokerrors=disp;
|
||
}
|
||
}while(tok==tk_endline);
|
||
rtok=tok;
|
||
tok=otok;
|
||
cha=ocha;
|
||
itok=oitok;
|
||
inptr=oinptr;
|
||
linenumber=oline;
|
||
return rtok;
|
||
}
|
||
|
||
//extern idrec *crec;
|
||
|
||
void nexttok()
|
||
{
|
||
#ifdef DEBUGMODE
|
||
if(debug)puts("start nexttok");
|
||
#endif
|
||
inptr=inptr2;
|
||
linenumber=linenum2;
|
||
cha=cha2;
|
||
displaytokerrors=1;
|
||
tokscan(&tok,&itok,string); //разбор команды
|
||
// printf("input=%08X inptr=%08X tok=%d %s\n",input,inptr,tok,itok.name);
|
||
if(tok==tk_dblcolon&&numblocks){
|
||
skiplocals=TRUE;
|
||
tokscan(&tok,&itok,string); //разбор команды
|
||
}
|
||
ScanTok2();
|
||
if(tok2==tk_dblcolon&&numblocks){
|
||
skiplocals=TRUE;
|
||
tokscan(&tok2,&itok2,string2);
|
||
}
|
||
if(tok2==tk_tilda){
|
||
if(ScanTok3()==tk_number){
|
||
tok2=tk_number;
|
||
// puts("tok2=tk_tilda tok3=tk_number");
|
||
}
|
||
}
|
||
linenumber=linenum2;
|
||
// new !!! 02.04.02 20:22
|
||
if(tok==tk_int&&idasm==TRUE&&tok2==tk_number){
|
||
tok=tk_idasm;
|
||
itok.rm=a_int;
|
||
}
|
||
// new !!! 02.04.02 20:22
|
||
|
||
#ifdef DEBUGMODE
|
||
if(debug)printdebuginfo();
|
||
#endif
|
||
if(tok2==tk_number){
|
||
if(tok==tk_not){
|
||
nexttok();
|
||
if(itok.rm!=tk_float&&itok.rm!=tk_double){
|
||
if(scanlexmode==RESLEX){
|
||
if(itok.number)itok.number=0;
|
||
else itok.number=1;
|
||
}
|
||
else itok.lnumber^=-1;
|
||
}
|
||
else illegalfloat();
|
||
return;
|
||
}
|
||
if(tok==tk_tilda){
|
||
// puts("tok=tk_tilda tok2=tk_number");
|
||
nexttok();
|
||
if(itok.rm!=tk_float&&itok.rm!=tk_double)itok.lnumber=~itok.lnumber;
|
||
else illegalfloat();
|
||
return;
|
||
}
|
||
}
|
||
if(idasm==TRUE&&tok==tk_loop&&tok2!=tk_openbracket){
|
||
tok=tk_idasm;
|
||
itok.rm=a_loop;
|
||
return;
|
||
}
|
||
if(tok==tk_dollar){
|
||
if(itok2.type==tp_opperand||itok2.type==tp_stopper||tok2==tk_dollar){
|
||
tok=tk_number;
|
||
itok.number=outptr;
|
||
if(FixUp)itok.flag|=f_reloc; //new!!!
|
||
return;
|
||
}
|
||
|
||
int qq; //09.07.08 13:27 new
|
||
if((qq=CheckAsmName(itok2.name))!=-1){
|
||
tok=tk_idasm;
|
||
itok.rm=qq;
|
||
strcpy(itok.name,itok2.name);
|
||
ScanTok2();
|
||
}
|
||
|
||
}
|
||
if(tok>=tk_charvar&&tok<=tk_doublevar){
|
||
localrec *ptr;
|
||
ptr=itok.locrec;
|
||
switch(itok.type){
|
||
case tp_paramvar:
|
||
// case tp_ppointer:
|
||
// case tp_pfpointer:
|
||
if(ptr->fuse==NOTINITVAR&&tok2==tk_assign&&(!asmparam))warningnotused(itok.name,4);
|
||
goto llq;
|
||
case tp_localvar:
|
||
// case tp_lpointer:
|
||
// case tp_lfpointer:
|
||
if(ptr->fuse==NOTINITVAR&&tok2!=tk_assign){
|
||
if(asmparam)ptr->fuse|=INITVAR;
|
||
else warningusenotintvar(itok.name);
|
||
}
|
||
llq:
|
||
ptr->fuse|=(unsigned char)(tok2==tk_assign?INITVAR:USEDVAR);
|
||
break;
|
||
}
|
||
#ifdef OPTVARCONST
|
||
if(calcnumber&&CheckConstVar(&itok))tok=tk_number;
|
||
#endif
|
||
}
|
||
#ifdef OPTVARCONST
|
||
if(tok2>=tk_charvar&&tok2<=tk_doublevar){
|
||
if(calcnumber&&CheckConstVar(&itok2))tok2=tk_number;
|
||
}
|
||
#endif
|
||
if(usedirectiv==FALSE&&calcnumber==FALSE)while(tok==tk_question)directive();
|
||
//16.08.04 00:23
|
||
if(tok==tk_at&&tok2==tk_macro){
|
||
nexttok();
|
||
}
|
||
#ifdef OPTVARCONST
|
||
displaytokerrors=1;
|
||
#endif
|
||
|
||
// if(crec)printf("num=%08X\n",crec->recnumber);
|
||
|
||
}
|
||
|
||
void whitespace() //пропуск нзначащих символов
|
||
{
|
||
while(isspace(cha)||cha==255||cha==0){
|
||
if(cha==13){
|
||
linenumber++;
|
||
if((dbg&2)&&displaytokerrors&¬def)startline=(char*)(input+inptr+1);
|
||
if(scanlexmode==RESLEX||scanlexmode==DEFLEX||scanlexmode==ASMLEX)break;
|
||
}
|
||
nextchar();
|
||
}
|
||
}
|
||
|
||
unsigned char convert_char()
|
||
//Returns the value of the current character. Parses \n and \x00 etc.
|
||
//cha equals the last character used.
|
||
{
|
||
int hold=0;
|
||
int i;
|
||
unsigned char c;
|
||
if(cha!='\\'){
|
||
if(cha==13){
|
||
linenumber++;
|
||
if((dbg&2)&&displaytokerrors&¬def)startline=(char*)(input+inptr+1);
|
||
}
|
||
return(cha);
|
||
}
|
||
nextchar(); // move past '\\'
|
||
switch(cha){
|
||
case 'a': return('\a'); // what is \a anyway?
|
||
case 'b': return('\b');
|
||
case 'f': return('\f');
|
||
case 'l': return(10);
|
||
case 'n': return(13);
|
||
// case 'p': return('Ь');
|
||
case 'r': return(13);
|
||
case 't': return('\t');
|
||
case 'v': return('\v');
|
||
case 'x':
|
||
for(i=0;i<2;i++){
|
||
c=cha;
|
||
nextchar();
|
||
hold*=16;
|
||
if(isdigit(cha))hold+=cha-'0';
|
||
else if(isxdigit(cha))hold+=(cha&0x5f)-'7';
|
||
else{
|
||
// expectederror("hexadecimal digit");
|
||
if(savestring3)posstr3--;
|
||
inptr--;
|
||
cha=c;
|
||
break;
|
||
}
|
||
}
|
||
return (unsigned char)hold;
|
||
default:
|
||
if(isdigit(cha)){
|
||
hold=cha-'0';
|
||
for(i=0;i<2;i++){
|
||
c=cha;
|
||
nextchar();
|
||
if(isdigit(cha))hold=hold*10+(cha-'0');
|
||
else{
|
||
// expectederror("decimal digit");
|
||
if(savestring3)posstr3--;
|
||
inptr--;
|
||
cha=c;
|
||
break;
|
||
}
|
||
}
|
||
return (unsigned char)hold;
|
||
}
|
||
return cha;
|
||
}
|
||
}
|
||
|
||
void convert_string(unsigned char *str)
|
||
{
|
||
int k,j,i;
|
||
unsigned char c;
|
||
unsigned char hold;
|
||
for(k=0,j=0;;k++,j++){
|
||
c=str[k];
|
||
if(c=='\\'){
|
||
c=str[++k];
|
||
switch(c){
|
||
case 'a': hold='\a'; break; // what is \a anyway?
|
||
case 'b': hold='\b'; break;
|
||
case 'f': hold='\f'; break;
|
||
case 'l': hold=10; break;
|
||
case 'n': str[j++]=13; hold=10; break;
|
||
case 'r': hold=13; break;
|
||
case 't': hold='\t'; break;
|
||
case 'v': hold='\v'; break;
|
||
case 'x':
|
||
hold=0;
|
||
for(i=0;i<2;i++){
|
||
c=str[++k];
|
||
hold*=(unsigned char)16;
|
||
if(isdigit(c))hold+=(unsigned char)(c-'0');
|
||
else if(isxdigit(c))hold+=(unsigned char)((c&0x5f)-'7');
|
||
else{
|
||
k--;
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
hold=c;
|
||
if(isdigit(c)){
|
||
hold-='0';
|
||
for(i=0;i<2;i++){
|
||
c=str[++k];
|
||
if(isdigit(c))hold=(unsigned char)(hold*10+(c-'0'));
|
||
else{
|
||
k--;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
str[j]=hold;
|
||
}
|
||
else str[j]=c;
|
||
if(c==0)break;
|
||
}
|
||
}
|
||
|
||
int CheckChar2()
|
||
{
|
||
if(isalnum(cha)||cha=='_'||cha>=0x80)return TRUE;
|
||
return FALSE;
|
||
}
|
||
|
||
void GetTokString(int *tok4,ITOK *itok4,unsigned char *string4,int useunicode)
|
||
{
|
||
int strptr=0;
|
||
if(displaytokerrors){
|
||
savestring3=TRUE;
|
||
posstr3=0;
|
||
}
|
||
nextstr:
|
||
nextchar(); //строковая константа
|
||
while(cha!='\"'&&!endoffile&&strptr<STRLEN-1){
|
||
string4[strptr++]=convert_char();
|
||
if((char)cha=='n'&&string4[strptr-1]==13){//have to add char 10 for \n value
|
||
string4[strptr++]=10;
|
||
}
|
||
nextchar();
|
||
}
|
||
if(displaytokerrors){
|
||
savestring3=FALSE;
|
||
string3[posstr3-1]=0;
|
||
}
|
||
if(strptr>=(STRLEN-1)&&displaytokerrors)preerror("Maximum String Length Exceeded");
|
||
string4[strptr]=0;
|
||
*tok4=tk_string;
|
||
// itok4->number=strptr;
|
||
itok4->rm=1; //есть оригинал строки
|
||
if(cha!='\"')expected('\"');
|
||
while(cha!='\"'&&!endoffile)nextchar(); //scan until closing '\"'
|
||
nextchar();
|
||
if(dosstring)itok4->flag=dos_term;
|
||
CheckConvertString((char *)string4);
|
||
switch(cha){
|
||
case 'z':
|
||
itok4->flag=zero_term;
|
||
nextchar();
|
||
break;
|
||
case 'n':
|
||
itok4->flag=no_term;
|
||
nextchar();
|
||
break;
|
||
case '$':
|
||
itok4->flag=dos_term;
|
||
nextchar();
|
||
break;
|
||
}
|
||
CheckConvertString((char *)string4);
|
||
|
||
// 10.08.04 22:20
|
||
whitespace(); //пропуск незначащих символов
|
||
if(cha=='\"'){
|
||
if(displaytokerrors)savestring3=TRUE;
|
||
goto nextstr;
|
||
}
|
||
|
||
if(useunicode&&displaytokerrors){
|
||
char *bak;
|
||
bak=BackString((char *)string4);
|
||
strptr=MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,bak,-1,(wchar_t *)string4,STRLEN)-1;
|
||
// printf("size string=%d\n",strptr);
|
||
// if(itok4->flag==no_term)strptr--;
|
||
strptr*=2;
|
||
// string4[strptr-2]=string4[strptr-1]=0;
|
||
itok4->flag|=s_unicod;
|
||
free(bak);
|
||
}
|
||
itok4->number=strptr;
|
||
}
|
||
|
||
void tokscan(int *tok4,ITOK *itok4,unsigned char *string4)
|
||
// поиск идентификаторов, директив ...
|
||
{
|
||
int useme;
|
||
unsigned int strptr=0;
|
||
char uppercase=1,next=1;
|
||
//установки по умолчанию
|
||
#ifdef DEBUGMODE
|
||
if(debug)printf("start tokscan input=%08X inptr=%08X %c%s\n",input,inptr,cha,input+inptr);
|
||
#endif
|
||
if(am32==FALSE){
|
||
itok4->rm=rm_d16;
|
||
itok4->sib=CODE16;
|
||
}
|
||
else{
|
||
itok4->rm=rm_d32;
|
||
itok4->sib=CODE32;
|
||
}
|
||
itok4->segm=DS;
|
||
itok4->lnumber=0;
|
||
itok4->post=0;
|
||
itok4->flag=0;
|
||
itok4->size=0;
|
||
itok4->rec=NULL;
|
||
itok4->type=tp_ucnovn;
|
||
itok4->npointr=0;
|
||
itok4->name[0]=0;
|
||
whitespace(); //пропуск незначащих символов
|
||
// if(displaytokerrors)printf("%c ",cha);
|
||
if(isalpha(cha)||(cha=='_')||(cha>=0x80)){ //идентификатор
|
||
do{
|
||
string4[strptr++]=cha;
|
||
if(islower(cha))uppercase=0;
|
||
nextchar();
|
||
}while((strptr<IDLENGTH)&&(CheckChar2()==TRUE));
|
||
if(strptr>=IDLENGTH){ //длина больше 32
|
||
if(displaytokerrors)preerror("Maximum length for an identifier exceeded");
|
||
while(CheckChar2()==TRUE)nextchar(); //дочитать слово
|
||
strptr=IDLENGTH-1; //обрезать до 32
|
||
}
|
||
if(cha=='~'&&strptr<IDLENGTH-1){
|
||
string4[strptr++]=cha;
|
||
nextchar();
|
||
if(cha!='('){
|
||
inptr--;
|
||
strptr--;
|
||
cha='~';
|
||
}
|
||
}
|
||
string4[strptr]=0;
|
||
strcpy(itok4->name,(char *)string4);
|
||
// if(displaytokerrors)printf("%s (%u) >%s\n",(startfileinfo+currentfileinfo)->filename,linenumber,itok4->name);
|
||
#ifdef DEBUGMODE
|
||
if (debug)printf("ID: '%s' cur_mod=%08X prev cur_mod=%08X\n",itok4->name,cur_mod,cur_mod==NULL?0:cur_mod->next);
|
||
#endif
|
||
if(scanlexmode==RESLEX){
|
||
if(stricmp((char *)string4,"not")==0)*tok4=tk_not;
|
||
else if(stricmp((char *)string4,"or")==0)*tok4=tk_or;
|
||
else if(stricmp((char *)string4,"xor")==0)*tok4=tk_xor;
|
||
else if(stricmp((char *)string4,"and")==0)*tok4=tk_and;
|
||
else{
|
||
if(uppercase)*tok4=tk_ID;
|
||
else *tok4=tk_id;
|
||
searchtree(itok4,tok4,string4);
|
||
if(*tok4==tk_id||*tok4==tk_ID){
|
||
if((useme=CheckResName(itok4->name))!=-1){
|
||
*tok4=tk_rescommand;
|
||
itok4->number=useme;
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if(uppercase){ //верхний регистр
|
||
if(strptr==1&&string4[0]=='L'&&cha=='"'){
|
||
itok4->name[0]=0;
|
||
GetTokString(tok4,itok4,string4,TRUE);
|
||
return;
|
||
}
|
||
*tok4=tk_ID;
|
||
if(string4[1]=='S'&&strptr>=5&&strptr<=8){
|
||
for(useme=0;useme<ID2S;useme++){ //проверка на ESBYTE ...
|
||
if(strcmp((char *)string4,id2[useme])==0){
|
||
*tok4=tk_charvar+useme%DATATYPES;
|
||
itok4->segm=useme/DATATYPES;
|
||
itok4->number=0;
|
||
itok4->post=POINTER;
|
||
goto yesid;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else *tok4=tk_id;
|
||
if(strptr==2){ //длина 2 символа check for AX, CX, DX, ...
|
||
if((string4[0]&0x5f)=='S'&&(string4[1]&0x5f)=='T'){
|
||
if(cha=='('){
|
||
nextchar();
|
||
if(cha>='0'&&cha<='7'){
|
||
itok4->number=cha-'0';
|
||
nextchar();
|
||
if(cha!=')')expected(')');
|
||
nextchar();
|
||
*tok4=tk_fpust;
|
||
}
|
||
}
|
||
else{
|
||
itok4->number=0;
|
||
*tok4=tk_fpust;
|
||
}
|
||
return;
|
||
}
|
||
if(asmparam||*tok4==tk_ID){
|
||
for(useme=0;useme<8;useme++){
|
||
int i;
|
||
if(asmparam)i=stricmp((char *)string4,regs[0][useme]);
|
||
else i=strcmp((char *)string4,regs[0][useme]);
|
||
if(i==0){
|
||
*tok4=tk_reg;
|
||
itok4->number=useme;
|
||
extreg:
|
||
if(cha=='.'){
|
||
tag_massiv(tok4,itok4,string4);
|
||
goto yesid;
|
||
}
|
||
return;
|
||
}
|
||
if(asmparam)i=stricmp((char *)string4,begs[useme]);
|
||
else i=strcmp((char *)string4,begs[useme]);
|
||
if(i==0){
|
||
*tok4=tk_beg;
|
||
itok4->number=useme;
|
||
return;
|
||
}
|
||
}
|
||
if(string4[1]=='S'||(asmparam&&string4[1]=='s')){
|
||
for(useme=0;useme<6;useme++){ // check for CS, SS, ...
|
||
if(string4[0]==segs[useme][0]||(asmparam&&(string4[0]&0x5F)==segs[useme][0])){
|
||
if(cha==':'){
|
||
int oinptr=inptr;
|
||
unsigned char ocha=cha;
|
||
int oline=linenumber;
|
||
nextchar();
|
||
/* switch(cha&(asmparam==FALSE?0xFF:0x5F)){
|
||
case 'E':
|
||
case 'B':
|
||
case 'S':
|
||
case 'D':*/
|
||
tokscan(tok4,itok4,string4);
|
||
if(*tok4>=tk_bits&&*tok4<=tk_doublevar){
|
||
itok4->segm=useme;
|
||
goto yesid;
|
||
}
|
||
// }
|
||
inptr=oinptr;
|
||
cha=ocha;
|
||
linenumber=oline;
|
||
}
|
||
*tok4=tk_seg;
|
||
itok4->number=useme;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if(strptr==3&&(string4[0]=='E'||(asmparam&&string4[0]=='e'))){// check for EAX, ECX, EDX, ...
|
||
for(useme=0;useme<8;useme++){
|
||
int i;
|
||
if(asmparam)i=stricmp((char *)&string4[1],regs[0][useme]);
|
||
else i=strcmp((char *)&string4[1],regs[0][useme]);
|
||
if(i==0){
|
||
*tok4=tk_reg32;
|
||
itok4->number=useme;
|
||
extreg32:
|
||
if(cha=='.'){
|
||
tag_massiv(tok4,itok4,string4);
|
||
goto yesid;
|
||
}
|
||
if(cha==':'){
|
||
int oinptr=inptr;
|
||
unsigned char ocha=cha;
|
||
int oline=linenumber;
|
||
nextchar();
|
||
tokscan(tok4,itok4,string4);
|
||
if(*tok4==tk_reg32||*tok4==tk_reg){
|
||
itok4->number|=useme*256;
|
||
*tok4=tk_reg64;
|
||
goto yesid;
|
||
}
|
||
inptr=oinptr;
|
||
cha=ocha;
|
||
linenumber=oline;
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
if(asmparam){
|
||
if((string4[1]&0x5f)=='R'){
|
||
if(string4[2]>='0'&&string4[2]<='7'){
|
||
itok4->number=string4[2]-'0';
|
||
switch((string4[0]&0x5f)){
|
||
case 'C': *tok4=tk_controlreg; return;// check for CR0, CR1, ...
|
||
case 'D': *tok4=tk_debugreg; return;//check for DR0, DR1, ...
|
||
case 'T': *tok4=tk_testreg; return;//check for TR0, TR1, ...
|
||
default: itok4->number=0; break;
|
||
}
|
||
}
|
||
}
|
||
else if((*(short *)&string[0]&0x5f5f)==0x4d4d){
|
||
if(string4[2]>='0'&&string4[2]<='7'){
|
||
itok4->number=string4[2]-'0';
|
||
*tok4=tk_mmxreg;
|
||
return;
|
||
}
|
||
}
|
||
else if((*(short *)&string[1]&0x5f5f)==0x4d4d&&(string4[0]&0x5f)=='X'){
|
||
if(string4[3]>='0'&&string4[3]<='7'){
|
||
itok4->number=string4[3]-'0';
|
||
*tok4=tk_xmmreg;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
if(useasm==FALSE){
|
||
if((useme=FastSearch(id,idofs,2,(char *)string4))!=-1)*tok4=useme;
|
||
else if(idasm==TRUE&&(useme=CheckAsmName((char *)string4))!=-1){
|
||
*tok4=tk_idasm;
|
||
itok4->rm=useme;
|
||
return;
|
||
}
|
||
}
|
||
if(*tok4==tk_id||*tok4==tk_ID){
|
||
if(cur_mod&&cur_mod->numparamdef&&(displaytokerrors||scanalltoks)){//18.03.05 15:12
|
||
/* if(debug&&cur_mod){
|
||
printf("Find %s in %d entries curmod=%08X\n",itok4->name,cur_mod->numparamdef,cur_mod);
|
||
COM_MOD *nmod;
|
||
nmod=cur_mod;
|
||
while(nmod){
|
||
printf("\tinput=%08X inptr=%08X\n",nmod->input,nmod->inptr);
|
||
nmod=nmod->next;
|
||
}
|
||
}*/
|
||
if(CheckDefPar(itok4->name)){
|
||
tokscan(tok4,itok4,string4);
|
||
if(displaytokerrors==0){
|
||
inptr=cur_mod->inptr;
|
||
input=cur_mod->input;
|
||
endinptr=cur_mod->endinptr;
|
||
linenumber=cur_mod->linenumber;
|
||
currentfileinfo=cur_mod->currentfileinfo;
|
||
COM_MOD *temp=cur_mod;
|
||
cur_mod=cur_mod->next;
|
||
free(temp);
|
||
nextchar();
|
||
}
|
||
#ifdef DEBUGMODE
|
||
if(debug)printf("1601 tok=%d input=%08X inptr=%08X disp=%d %s %c%40s\n\t%s\n",*tok4,input,inptr,displaytokerrors,itok4->name,cha,input+inptr,""/*input*/);
|
||
#endif
|
||
return;
|
||
}
|
||
}
|
||
if(searchlocals(itok4,tok4,string4)==FALSE){//поиск среди локальных меток
|
||
//если ничего не найдено поиск в дереве переменых
|
||
searchtree(itok4,tok4,string4);
|
||
if(*tok4==tk_endline){
|
||
if(scanlexmode!=DEFLEX){
|
||
tokscan(tok4,itok4,string4);
|
||
#ifdef DEBUGMODE
|
||
if(debug)printf("1610 tok=%d input=%08X inptr=%08X disp=%d %s %c%40s\n\t%s\n",*tok4,input,inptr,displaytokerrors,itok4->name,cha,input+inptr,""/*input*/);
|
||
#endif
|
||
return;
|
||
}
|
||
*tok4=tk_macro;
|
||
}
|
||
if(*tok4==tk_number||*tok4==tk_idasm)return;
|
||
if((*tok4>=tk_bits&&*tok4<=tk_doublevar)||*tok4==tk_pointer){
|
||
if(itok4->rm==rm_d16||itok4->rm==rm_d32){
|
||
if(am32==FALSE){
|
||
itok4->rm=rm_d16;
|
||
itok4->sib=CODE16;
|
||
}
|
||
else{
|
||
itok4->rm=rm_d32;
|
||
itok4->sib=CODE32;
|
||
}
|
||
}
|
||
if(itok4->post==DYNAMIC_POST){ //преобразовать динамическую локальную в локальную
|
||
if(alignword&&*tok4!=tk_charvar&&*tok4!=tk_bytevar){ //выровнять на четный адрес
|
||
switch(*tok4){
|
||
case tk_intvar:
|
||
case tk_wordvar:
|
||
if(postsize%2==1)postsize++;
|
||
break;
|
||
default:
|
||
if(postsize%4!=0)postsize+=4-(postsize%4);
|
||
break;
|
||
}
|
||
}
|
||
idrec *ptr=itok4->rec;
|
||
itok4->post=ptr->recpost=1;
|
||
itok4->number=ptr->recnumber=postsize;
|
||
if(am32==FALSE&&(postsize+itok4->size)>0xFFFFL)tobigpost();
|
||
postsize+=itok4->size;
|
||
}
|
||
else if(itok4->post==DYNAMIC_VAR){
|
||
idrec *ptr=itok4->rec;
|
||
itok4->post=ptr->recpost=USED_DIN_VAR;
|
||
}
|
||
}
|
||
}
|
||
if(tok==tk_reg)goto extreg;
|
||
if(tok==tk_reg32)goto extreg32;
|
||
}
|
||
switch(*tok4){
|
||
int len;
|
||
case tk_dataptr: *tok4=tk_number; itok4->number=outptrdata;
|
||
if(FixUp)itok.flag|=f_reloc; //new!!!
|
||
break;
|
||
case tk_codeptr: *tok4=tk_number; itok4->number=outptr;
|
||
if(FixUp)itok.flag|=f_reloc; //new!!!
|
||
break;
|
||
case tk_postptr: *tok4=tk_number; itok4->number=postsize; break;
|
||
case tk_line: *tok4=tk_number; itok4->number=linenumber; break;
|
||
case tk_file:
|
||
*tok4=tk_string;
|
||
strcpy((char *)string4,(startfileinfo+currentfileinfo)->filename);
|
||
itok4->number=strlen((char *)string4);
|
||
break;
|
||
case tk_structvar:
|
||
struct idrec *ptrs;
|
||
ptrs=itok4->rec;
|
||
// puts(itok4->name);
|
||
dostructvar2(tok4,itok4,(structteg *)ptrs->newid,string4);
|
||
break;
|
||
case tk_sizeof:
|
||
dosizeof(itok4);
|
||
if(itok4->post)*tok4=tk_postnumber;
|
||
else *tok4=tk_number;
|
||
break;
|
||
case tk_signed:
|
||
case tk_unsigned:
|
||
case tk_int:
|
||
case tk_long:
|
||
case tk_short:
|
||
if(itok4->type!=tp_modif){
|
||
GetTypeVar(tok4);
|
||
itok4->type=tp_modif;
|
||
}
|
||
break;
|
||
case tk_ID:
|
||
// printf("%s %s %d %c\n",itok.name,string4,strptr,cha);
|
||
if(strlen(itok4->name)==1&&itok4->name[0]=='L'&&cha=='"'){
|
||
itok4->name[0]=0;
|
||
GetTokString(tok4,itok4,string4,TRUE);
|
||
return;
|
||
}
|
||
case tk_id:
|
||
if(findofset==FALSE){
|
||
struct structteg *tteg;
|
||
// if(displaytokerrors)printf("find teg %s cha=%02X\n",itok4->name,cha);
|
||
if(((tteg=FindTeg(FALSE,itok4->name))!=NULL||
|
||
(tteg=FindTeg(TRUE,itok4->name))!=NULL)&&(cha=='.'||precha=='.')){
|
||
// if(displaytokerrors)puts("finding");
|
||
dostructvar2(tok4,itok4,tteg,string4);
|
||
// printf("tok=%d\n",*tok4);
|
||
if(displaytokerrors&&(*tok4==tk_proc||*tok4==tk_declare||
|
||
*tok4==tk_undefproc)&&(itok4->flag&f_static)==0)unknownobj(itok4->name);
|
||
}
|
||
}
|
||
break;
|
||
|
||
}
|
||
if(*tok4==tk_string&&displaytokerrors){
|
||
strcpy((char *)string3,(char *)string4);
|
||
if(itok4->rm==2){
|
||
convert_string(string4);
|
||
itok4->rm--;
|
||
}
|
||
if(dosstring)itok.flag=dos_term;
|
||
}
|
||
yesid:
|
||
if((*tok4>=tk_bits&&*tok4<=tk_doublevar)||*tok4==tk_pointer){
|
||
whitespace();//пропуск незначащих символов
|
||
if(cha=='[')calcrm(itok4,*tok4);//обработка выражения в []
|
||
}
|
||
if(itok4->rm!=rm_d16&&*tok4!=tk_proc&&*tok4!=tk_undefproc&&
|
||
*tok4!=tk_apiproc&&*tok4!=tk_declare&&(!(*tok4==tk_pointer&&itok4->type==tk_proc)))
|
||
if(itok4->post==0&&(itok4->flag&f_reloc)==0){ // cannot compress if POST var
|
||
compressoffset(itok4);
|
||
}
|
||
next=0;
|
||
}
|
||
else if(isdigit(cha)){//числа
|
||
inptr--;
|
||
itok4->lnumber=scannumber(&itok4->rm);
|
||
*tok4=tk_number;
|
||
next=0;
|
||
}
|
||
else switch(cha){
|
||
case '\"':
|
||
GetTokString(tok4,itok4,string4,FALSE);
|
||
next=0;
|
||
break;
|
||
case '\'': //символьная константа может иметь более 1 символа
|
||
nextchar();
|
||
next=0;
|
||
if(scanlexmode==RESLEX){
|
||
*tok4=tk_singlquote;
|
||
break;
|
||
}
|
||
*tok4=tk_number;
|
||
itok4->number=0;
|
||
while(cha!='\''&&!endoffile){ // special character
|
||
itok4->lnumber=itok4->lnumber*256+convert_char();
|
||
nextchar();
|
||
}
|
||
if(cha!='\''){
|
||
if(displaytokerrors)expected('\'');
|
||
}
|
||
else nextchar();
|
||
next=0;
|
||
break;
|
||
case '-':
|
||
nextchar();
|
||
switch(cha){
|
||
case '=': *tok4=tk_minusequals; break; //минус равно
|
||
case '-': *tok4=tk_minusminus; break; //минус-минус
|
||
default: *tok4=tk_minus; next = 0; itok4->type=tp_opperand; break;//минус
|
||
}
|
||
break;
|
||
case '+':
|
||
nextchar();
|
||
switch(cha){
|
||
case '=': *tok4=tk_plusequals; break; //плюс равно
|
||
case '+': *tok4=tk_plusplus; break; //плюс-плюс
|
||
default: whitespace(); // spaces allowed between
|
||
if(cha=='-')*tok4=tk_minus; // optimization of + -
|
||
else{
|
||
*tok4=tk_plus; //плюс
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
break;
|
||
}
|
||
break;
|
||
case '*':
|
||
nextchar();
|
||
switch(cha){
|
||
case '=': *tok4=tk_multequals; break;
|
||
case '-': *tok4=tk_multminus; break; //умножить минус
|
||
default:
|
||
*tok4=tk_mult; //умножить
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
break;
|
||
case '/': nextchar();
|
||
switch(cha){
|
||
case '*': nextchar(); //соментарий
|
||
useme=1;
|
||
while(!endoffile&&useme>0){
|
||
whitespace();
|
||
if(cha=='*'){
|
||
nextchar();
|
||
if(cha=='/'){
|
||
nextchar();
|
||
if(cha=='/')nextchar();
|
||
else useme--;
|
||
}
|
||
continue;
|
||
}
|
||
else if(cha=='/'){
|
||
nextchar();
|
||
if(cha=='*')useme++;
|
||
else if(cha=='/'){
|
||
nextchar();
|
||
continue;
|
||
}
|
||
else continue;
|
||
}
|
||
nextchar();
|
||
}
|
||
if(endoffile){
|
||
*tok4=tk_eof;
|
||
if(useme>0&&displaytokerrors)unexpectedeof();
|
||
}
|
||
else tokscan(tok4,itok4,string4);
|
||
break;
|
||
case '/':
|
||
do{
|
||
nextchar();
|
||
}while(!endoffile&&cha!=13); //строка коментария
|
||
if(endoffile)*tok4=tk_eof;
|
||
else{
|
||
if(scanlexmode==DEFLEX)*tok4=tk_endline;
|
||
else{
|
||
whitespace();
|
||
if(cha==13)nextchar();
|
||
tokscan(tok4,itok4,string4);
|
||
}
|
||
}
|
||
break;
|
||
case '=': *tok4=tk_divequals; nextchar(); return;
|
||
default:
|
||
whitespace();
|
||
if(cha=='-'){
|
||
*tok4=tk_divminus; //деление
|
||
nextchar();
|
||
}
|
||
else *tok4=tk_div;
|
||
itok4->type=tp_opperand;
|
||
break;
|
||
}
|
||
next=0;
|
||
break;
|
||
case '%':
|
||
nextchar();
|
||
whitespace();
|
||
if(cha=='-')*tok4=tk_modminus; //остаток от деления
|
||
else{
|
||
*tok4=tk_mod;
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
break;
|
||
case '|':
|
||
nextchar();
|
||
switch(cha){
|
||
case '=': *tok4=tk_orequals; break; //OR=
|
||
case '|': *tok4=tk_oror; break; //OR-OR
|
||
default:
|
||
whitespace();
|
||
if(cha=='-')*tok4=tk_orminus; //OR-
|
||
else{
|
||
*tok4=tk_or;
|
||
if(cha==13)nextchar(); //OR
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
break;
|
||
}
|
||
break;
|
||
case '&':
|
||
nextchar();
|
||
switch(cha){
|
||
case '=': *tok4=tk_andequals; break; //AND=
|
||
case '&': *tok4=tk_andand; break;
|
||
default:
|
||
whitespace();
|
||
if(cha=='-')*tok4=tk_andminus;
|
||
else{
|
||
*tok4=tk_and;
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
break;
|
||
}
|
||
break;
|
||
case '!':
|
||
nextchar();
|
||
if(cha=='='){
|
||
*tok4=tk_notequal; //!=
|
||
itok4->type=tp_compare;
|
||
}
|
||
else{
|
||
*tok4=tk_not;
|
||
next=0;
|
||
}
|
||
break;
|
||
case '^':
|
||
nextchar();
|
||
if(cha=='=')*tok4=tk_xorequals; //XOR=
|
||
else{
|
||
whitespace();
|
||
if(cha=='-')*tok4=tk_xorminus;
|
||
else{
|
||
*tok4=tk_xor;
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
}
|
||
break;
|
||
case '=':
|
||
nextchar();
|
||
if(cha=='='){
|
||
*tok4=tk_equalto; //==
|
||
itok4->type=tp_compare;
|
||
}
|
||
else{
|
||
*tok4=tk_assign; //присвоить
|
||
next=0;
|
||
}
|
||
break;
|
||
case '>':
|
||
nextchar();
|
||
switch(cha){
|
||
case '>':
|
||
nextchar();
|
||
if(cha=='=')*tok4=tk_rrequals; //сдвиг вправо с присвоением
|
||
else{
|
||
whitespace();
|
||
if(cha=='-')*tok4 = tk_rrminus;
|
||
else{
|
||
*tok4=tk_rr; //сдвиг вправо
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
}
|
||
break;
|
||
case '<': *tok4=tk_swap; break; //обмен
|
||
case '=': *tok4=tk_greaterequal; itok4->type=tp_compare; break; //больше или равно
|
||
default: *tok4=tk_greater; next=0; itok4->type=tp_compare; break; //больше
|
||
}
|
||
break;
|
||
case '<':
|
||
nextchar();
|
||
switch(cha){
|
||
case '<':
|
||
nextchar();
|
||
if(cha=='=')*tok4=tk_llequals; //сдвиг влево с присвоением
|
||
else{
|
||
whitespace();
|
||
if(cha=='-')*tok4=tk_llminus;
|
||
else{
|
||
*tok4=tk_ll; //сдвиг влево
|
||
next=0;
|
||
}
|
||
itok4->type=tp_opperand;
|
||
}
|
||
break;
|
||
case '>': *tok4=tk_notequal; itok4->type=tp_compare; break; //!=
|
||
case '=': *tok4=tk_lessequal; itok4->type=tp_compare; break; //меньше или равно
|
||
default: *tok4=tk_less; next=0; itok4->type=tp_compare; break;//меньше
|
||
}
|
||
break;
|
||
case '#':
|
||
next=0;
|
||
nextchar();
|
||
findofset=TRUE;
|
||
tokscan(tok4,itok4,string4);
|
||
findofset=FALSE;
|
||
if((useme=GetDirective((char *)string4))!=-1){
|
||
itok4->number=useme;
|
||
*tok4=tk_question;
|
||
break;
|
||
}
|
||
if(*tok4==tk_dblcolon){
|
||
skiplocals=TRUE;
|
||
tokscan(tok4,itok4,string4);
|
||
}
|
||
/* char buf[16];
|
||
strncpy(buf,(char *)(input+inptr),15);
|
||
buf[15]=0;*/
|
||
// printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d flag=%08X %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->flag,itok4->name/*,buf*/);
|
||
// printf("skiplocals=%d skipfind=%d searchteg=%08X\n",skiplocals,skipfind,searchteg);
|
||
switch(*tok4){
|
||
case tk_structvar:
|
||
// printf("%08X %s\n",itok4->sib,itok4->name);
|
||
if((itok4->sib&1)==0){
|
||
ofsstr(tok4,itok4);
|
||
// if(displaytokerrors)printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d flag=%08X %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->flag,itok4->name/*,buf*/);
|
||
break;
|
||
}
|
||
itok4->rm=(am32==0?rm_d16:rm_d32);
|
||
case tk_struct:
|
||
*tok4=tk_number;
|
||
if(bufrm){
|
||
*tok4=tk_rmnumber;
|
||
if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
|
||
}
|
||
break;
|
||
case tk_apiproc: //!!!16.12.06 23:06
|
||
itok4->rm=tk_undefofs;
|
||
*tok4=tk_apioffset;
|
||
if(FixUp)itok4->flag|=f_reloc; //new!!! 27.06.05 22:25
|
||
strcpy((char *)string4,itok4->name);
|
||
// printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->name/*,buf*/);
|
||
break;
|
||
case tk_proc:
|
||
case tk_interruptproc:
|
||
if(cha=='.')goto structofs;
|
||
procofs:
|
||
if(itok4->segm!=NOT_DYNAMIC){
|
||
if(displaytokerrors){
|
||
idrec *ptr=itok4->rec;
|
||
itok4->segm=ptr->recsegm=DYNAMIC_USED;
|
||
}
|
||
itok4->rm=*tok4=tk_undefofs; //смещение еще не известной метки
|
||
itok4->number=0;
|
||
// if(FixUp)itok4->flag|=f_reloc; //new!!! 27.06.05 22:25
|
||
}
|
||
else{
|
||
*tok4=tk_number;
|
||
itok4->segm=CS;//(splitdata==FALSE)?DS:CS;
|
||
// if(FixUp)itok4->flag|=f_reloc;
|
||
}
|
||
if(FixUp)itok4->flag|=f_reloc; //new!!! 27.06.05 22:25
|
||
strcpy((char *)string4,itok4->name);
|
||
// printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->name/*,buf*/);
|
||
break;
|
||
case tk_id:
|
||
case tk_ID:
|
||
structofs:
|
||
struct structteg *tteg;
|
||
if(((tteg=FindTeg(FALSE,itok4->name))!=NULL||
|
||
(tteg=FindTeg(TRUE,itok4->name))!=NULL)/*&&cha=='.'*/){
|
||
dostructvar2(tok4,itok4,tteg,string4);
|
||
// printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->name/*,buf*/);
|
||
|
||
if(*tok4==tk_proc)goto procofs;//04.10.04 14:25
|
||
|
||
if(*tok4==tk_declare)goto undefofs; //24.09.04 00:33
|
||
// printf("tok=%d segm=%d %s\n",*tok4,itok4->segm,itok4->name);
|
||
if(strinf.bufstr){
|
||
*tok4=tk_rmnumber;
|
||
if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
|
||
}
|
||
else{
|
||
if(FixUp&&*tok4==tk_proc)itok4->flag|=f_reloc; //new!!!
|
||
else itok4->flag&=~f_reloc;
|
||
// else itok4->flag&=!f_reloc; 16.08.04 18:51
|
||
|
||
//30.09.04 20:22
|
||
if(itok4->post){
|
||
*tok4=tk_postnumber;
|
||
itok4->rm=tk_undefofs;
|
||
}
|
||
else
|
||
/////
|
||
|
||
*tok4=tk_number;
|
||
}
|
||
}
|
||
else{
|
||
undefofs:
|
||
itok4->rm=*tok4=tk_undefofs; //смещение еще не известной метки
|
||
itok4->number=0;
|
||
if(FixUp)itok4->flag|=f_reloc; //new!!!
|
||
}
|
||
case tk_number:
|
||
case tk_rmnumber:
|
||
break;
|
||
case tk_reg:
|
||
case tk_reg32:
|
||
itok4->rm=RegToRM(itok4->number,*tok4)/*|rm_mod10*/;
|
||
*tok4=(am32==0?tk_wordvar:tk_dwordvar);//tk_rmnumber;
|
||
itok4->number=0;
|
||
break;
|
||
default:
|
||
if(cha=='.')goto structofs;
|
||
if((*tok4>=tk_bits&&*tok4<=tk_doublevar)||tok==tk_pointer){
|
||
#ifdef OPTVARCONST
|
||
if(displaytokerrors)ClearVarByNum(itok4);
|
||
#endif
|
||
switch(itok4->type){
|
||
case tp_localvar:
|
||
case tp_paramvar:
|
||
localrec *ptr;
|
||
ptr=itok4->locrec;
|
||
ptr->fuse|=(unsigned char)(INITVAR|USEDVAR);
|
||
break;
|
||
case tk_proc:
|
||
itok4->rm=itok4->sib;
|
||
itok4->sib=am32==0?CODE16:CODE32;
|
||
break;
|
||
}
|
||
itok4->size=GetVarSize(*tok4);
|
||
if((itok4->sib==CODE16&&itok4->rm==rm_d16)||
|
||
(itok4->sib==CODE32&&itok4->rm==rm_d32)){
|
||
if(itok4->post==0){
|
||
*tok4=tk_number;
|
||
itok4->segm=DS;
|
||
if(FixUp)itok4->flag|=f_reloc;
|
||
itok4->rm=am32==FALSE?tk_word:tk_dword;
|
||
}
|
||
else{
|
||
*tok4=tk_postnumber;
|
||
itok4->rm=tk_undefofs;
|
||
}
|
||
}
|
||
else{
|
||
*tok4=tk_rmnumber;
|
||
if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
|
||
}
|
||
}
|
||
else{
|
||
itok4->rm=*tok4=tk_undefofs; //смещение еще не известной метки
|
||
itok4->number=0;
|
||
strcpy((char *)string4,itok4->name);
|
||
}
|
||
break;
|
||
}
|
||
itok4->type=tp_ofs;
|
||
// if(displaytokerrors)printf("name=%s tok=%d post=%d flag=%08X rm=%d\n",itok4->name,*tok4,itok4->post,itok4->flag,itok4->rm);
|
||
break;
|
||
case '(':
|
||
if(*(unsigned short *)&(input[inptr])==
|
||
#ifdef _WC_
|
||
')E'
|
||
#else
|
||
'E)'
|
||
#endif
|
||
||
|
||
(*(unsigned short *)&(input[inptr])==
|
||
#ifdef _WC_
|
||
')e'
|
||
#else
|
||
'e)'
|
||
#endif
|
||
)){
|
||
for(useme=0;useme<8;useme++){
|
||
int i;
|
||
if(asmparam)i=strnicmp((char *)input+inptr+2,regs[0][useme],2);
|
||
else i=strncmp((char *)input+inptr+2,regs[0][useme],2);
|
||
if(i==0){
|
||
inptr+=4;
|
||
nextchar();
|
||
itok4->number=useme;
|
||
if(am32){
|
||
*tok4=tk_reg32;
|
||
goto extreg32;
|
||
}
|
||
*tok4=tk_reg;
|
||
goto extreg;
|
||
}
|
||
}
|
||
}
|
||
*tok4=tk_openbracket;
|
||
break;
|
||
case ':':
|
||
nextchar();
|
||
if(cha!=':'){
|
||
next=0;
|
||
*tok4=tk_colon;
|
||
}
|
||
else *tok4=tk_dblcolon;
|
||
break;
|
||
case ';': itok4->type=tp_stopper; *tok4=tk_semicolon; break;
|
||
case ')': itok4->type=tp_stopper; *tok4=tk_closebracket; break;
|
||
case '{': *tok4=tk_openbrace; break;
|
||
case '}': itok4->type=tp_stopper; *tok4=tk_closebrace; break;
|
||
case '[': *tok4=tk_openblock; break;
|
||
case ']': itok4->type=tp_stopper; *tok4=tk_closeblock; break;
|
||
case ',': itok4->type=tp_stopper; *tok4=tk_camma; break;
|
||
case '.':
|
||
next=0;
|
||
nextchar();
|
||
if(cha!='.'){
|
||
*tok4=tk_period;
|
||
break;
|
||
}
|
||
nextchar();
|
||
if(cha!='.'){
|
||
badtoken();
|
||
nextchar();
|
||
tokscan(tok4,itok4,string4);
|
||
break;
|
||
}
|
||
nextchar();
|
||
*tok4=tk_multipoint;
|
||
break;
|
||
case '@': *tok4=tk_at; break;
|
||
case '$': *tok4=tk_dollar; break;
|
||
case '?':
|
||
nextchar();
|
||
tokscan(tok4,itok4,string4);
|
||
*tok4=tk_question;
|
||
itok4->number=GetDirective((char *)string4);
|
||
return;
|
||
case '~': *tok4=tk_tilda; break;
|
||
case 26: *tok4=tk_eof; return;
|
||
case 13: *tok4=tk_endline; break;
|
||
case '\\':
|
||
nextchar();
|
||
if(cha==13){
|
||
tokscan(tok4,itok4,string4);
|
||
if(*tok4==tk_endline)tokscan(tok4,itok4,string4);
|
||
return;
|
||
}
|
||
default:
|
||
badtoken();
|
||
nextchar();
|
||
tokscan(tok4,itok4,string4);
|
||
return;
|
||
}
|
||
if(next)nextchar();
|
||
#ifdef DEBUGMODE
|
||
if(debug)printf("2172 tok=%d input=%08X inptr=%08X disp=%d %s %X %s\n",*tok4,input,inptr,displaytokerrors,itok4->name,cha,input+inptr);
|
||
#endif
|
||
}
|
||
|
||
|
||
void NewMod(int numipar)
|
||
{
|
||
COM_MOD *newm;
|
||
int oline;
|
||
int numpar=0,ns,i,size,nsize;
|
||
char *buf=NULL;
|
||
newm=(COM_MOD *)MALLOC(sizeof(COM_MOD));
|
||
newm->numparamdef=numipar;
|
||
newm->freze=FALSE;
|
||
size=0;
|
||
whitespace();
|
||
if(cha=='('){
|
||
nextchar();
|
||
whitespace();
|
||
if(cha!=')'){
|
||
inptr--;
|
||
oline=linenumber;
|
||
for(i=inptr,ns=1;ns>0;i++){ //поиск параметров
|
||
switch(input[i]){
|
||
case '(': ns++; break;
|
||
case ')': ns--; break;
|
||
case ',':
|
||
if(ns==1){
|
||
numpar++;
|
||
nsize=i-inptr;
|
||
if(!buf)buf=(char *)MALLOC(nsize+1);
|
||
else buf=(char *)REALLOC(buf,size+nsize+1);
|
||
strncpy(buf+size,(char *)(input+inptr),nsize);
|
||
buf[size+nsize]=0;
|
||
strbtrim(buf+size);
|
||
// puts(buf+size);
|
||
size+=strlen(buf+size)+1;
|
||
inptr+=nsize+1;
|
||
}
|
||
break;
|
||
case '/':
|
||
i=skipcomment(i);
|
||
break;
|
||
case '"':
|
||
case 0x27:
|
||
i=skipstring(i,input[i]);
|
||
break;
|
||
}
|
||
if((unsigned int)i>=endinptr){
|
||
unexpectedeof();
|
||
break;
|
||
}
|
||
}
|
||
linenumber=oline;
|
||
numpar++;
|
||
nsize=i-inptr;
|
||
if(!buf)buf=(char *)MALLOC(nsize);
|
||
else buf=(char *)REALLOC(buf,size+nsize);
|
||
strncpy(buf+size,(char *)(input+inptr),nsize-1);
|
||
buf[size+nsize-1]=0;
|
||
strbtrim(buf+size);
|
||
// puts(buf+size);
|
||
inptr=i;
|
||
}
|
||
if(numipar>numpar)missingpar(itok.name);
|
||
else if(numipar<numpar)extraparam(itok.name);
|
||
newm->numparamdef=numpar;
|
||
}
|
||
else inptr--;
|
||
newm->input=input;
|
||
newm->inptr2=newm->inptr=inptr;
|
||
newm->endinptr=endinptr;
|
||
newm->linenumber=linenumber;
|
||
newm->currentfileinfo=currentfileinfo;
|
||
newm->paramdef=buf;
|
||
newm->next=cur_mod;
|
||
cur_mod=newm;
|
||
// if(debug)printf("New curmod %08X numpar=%d input=%08X prev curmod=%08X\n",cur_mod,numipar,input,cur_mod->next);
|
||
nextchar();
|
||
/* char *temp=buf;
|
||
for(i=0;i<numpar;i++){
|
||
nsize=strlen(temp)+1;
|
||
puts(temp);
|
||
temp+=nsize;
|
||
}*/
|
||
}
|
||
|
||
void BackMod()
|
||
{
|
||
if(cur_mod){
|
||
inptr=cur_mod->inptr;
|
||
inptr2=cur_mod->inptr2;
|
||
input=cur_mod->input;
|
||
endinptr=cur_mod->endinptr;
|
||
linenumber=cur_mod->linenumber;
|
||
currentfileinfo=cur_mod->currentfileinfo;
|
||
cur_mod=cur_mod->next;
|
||
cha2=input[inptr2];
|
||
}
|
||
}
|
||
|
||
char *FindDefPar(char *name,COM_MOD *cmod)
|
||
{
|
||
char *temp;
|
||
int i,numpar,nsize=0;
|
||
numpar=cmod->numparamdef;
|
||
temp=cmod->declareparamdef;
|
||
// if(debug)printf("check for %s\n",name);
|
||
for(i=0;i<numpar;i++){
|
||
nsize=strlen(temp)+1;
|
||
// if(debug)printf("\t%s\n",temp);
|
||
if(strcmp(name,temp)==0){
|
||
temp=cmod->paramdef;
|
||
for(;i>0;i--){
|
||
temp+=strlen(temp)+1;
|
||
}
|
||
return temp;
|
||
}
|
||
temp+=nsize;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
int CheckDefPar(char *name)
|
||
{
|
||
char *temp,*nname;
|
||
COM_MOD *fmod;
|
||
fmod=cur_mod;
|
||
nname=name;
|
||
while((temp=FindDefPar(nname,fmod))!=NULL){
|
||
nname=temp;
|
||
if(fmod->next==NULL)break;
|
||
fmod=fmod->next;
|
||
}
|
||
if(fmod==cur_mod&&temp==NULL)return FALSE;
|
||
SetNewStr(nname);
|
||
return TRUE;
|
||
}
|
||
|
||
void SetNewStr(char *name)
|
||
{
|
||
COM_MOD *fmod;
|
||
fmod=(COM_MOD *)MALLOC(sizeof(COM_MOD));
|
||
fmod->next=cur_mod;
|
||
fmod->numparamdef=0;
|
||
fmod->paramdef=NULL;
|
||
fmod->freze=FALSE;
|
||
fmod->input=input;
|
||
fmod->inptr2=fmod->inptr=inptr-1;
|
||
fmod->endinptr=endinptr;
|
||
fmod->linenumber=linenumber;
|
||
fmod->currentfileinfo=currentfileinfo;
|
||
cur_mod=fmod;
|
||
// if(debug)printf("new curmod %08X prev cur_mod=%08X old input %08X %s\n",cur_mod,cur_mod->next,input,name);
|
||
input=(unsigned char*)(name);
|
||
inptr=1;
|
||
cha=input[0];
|
||
endinptr=strlen(name)+1;
|
||
}
|
||
|
||
int searchtree2(idrec *fptr,ITOK *itok4,int *tok4,unsigned char *string4)
|
||
//поиск в дереве переменых
|
||
{
|
||
struct idrec *ptr;
|
||
int cmpresult;
|
||
for(ptr=fptr;ptr!=NULL;){
|
||
if((cmpresult=strcmp(ptr->recid,(char *)string4))==0){
|
||
if(scanlexmode==RESLEX&&ptr->rectok!=tk_number&&ptr->rectok!=tk_string)break;
|
||
itok4->lnumber=ptr->reclnumber;
|
||
itok4->rm=ptr->recrm;
|
||
*tok4=ptr->rectok;
|
||
itok4->post=ptr->recpost;
|
||
itok4->segm=ptr->recsegm;
|
||
itok4->flag|=ptr->flag;
|
||
itok4->size=ptr->recsize;
|
||
itok4->sib=ptr->recsib;
|
||
itok4->rec=ptr;
|
||
itok4->type=ptr->type;
|
||
itok4->npointr=ptr->npointr;
|
||
// if(debug)printf("Find: tok=%d\n",*tok4);
|
||
if(displaytokerrors){
|
||
ptr->count++;
|
||
// printf("%s notdoneprestuff=%d tok=%d segm=%d\n",itok4->name,notdoneprestuff,*tok4,itok4->segm);
|
||
if(notdoneprestuff==2&&*tok4==tk_proc&&itok4->segm==DYNAMIC)AddDynamicList(ptr);
|
||
}
|
||
if(*tok4==tk_macro){
|
||
// printf("tok=%d %s %s\n",*tok4,itok4->name,input);
|
||
if(dirmode==dm_if)return TRUE;
|
||
if(scanlexmode==DEFLEX||scanlexmode==DEFLEX2)*tok4=tk_id;
|
||
else if(displaytokerrors){
|
||
NewMod(itok4->size);
|
||
notdef=FALSE;
|
||
cur_mod->declareparamdef=ptr->newid;
|
||
input=(unsigned char*)(ptr->sbuf);
|
||
inptr=1;
|
||
cha=input[0];
|
||
endinptr=strlen((char *)input);
|
||
// if(debug)printf("New cur_mod tok=%d numpar=%d %s %s\n",*tok4,cur_mod->numparamdef,itok4->name,input);
|
||
// debug=TRUE;
|
||
clearregstat();
|
||
*tok4=tk_endline;
|
||
return TRUE;
|
||
}
|
||
}
|
||
else if(ptr->newid){
|
||
switch(*tok4){
|
||
case tk_string:
|
||
memcpy((char *)string4,ptr->newid,itok4->number);
|
||
if(displaytokerrors&&itok4->rm==1&&ptr->sbuf)strcpy((char *)string3,ptr->sbuf);
|
||
break;
|
||
case tk_structvar:
|
||
itok4->segm=0;
|
||
if(ptr->recpost==DYNAMIC_POST){
|
||
ptr->recpost=itok4->post=1;
|
||
if(alignword){ //выровнять на четный адрес
|
||
if(postsize%2==1)postsize++;
|
||
}
|
||
itok4->number=ptr->recnumber=postsize;
|
||
if(am32==FALSE&&(ptr->recsize+postsize)>0xFFFFL)tobigpost();
|
||
postsize+=ptr->recsize;
|
||
}
|
||
else if(ptr->recpost==DYNAMIC_VAR)itok4->post=ptr->recpost=USED_DIN_VAR;
|
||
return TRUE;
|
||
case tk_proc:
|
||
case tk_apiproc:
|
||
case tk_declare:
|
||
case tk_undefproc:
|
||
strcpy((char *)string4,ptr->newid);
|
||
break;
|
||
default:
|
||
if(scanlexmode==DEFLEX2){
|
||
*tok4=tk_id;
|
||
return TRUE;
|
||
}
|
||
strcpy((char *)string4,ptr->newid);
|
||
if(strcmp((char *)string4,ptr->recid)!=0){ // see if ID has changed
|
||
// searchtree2(fptr,itok4,tok4,string4); // search again
|
||
searchtree(itok4,tok4,string4); // search again
|
||
switch(*tok4){
|
||
case tk_proc:
|
||
case tk_apiproc:
|
||
case tk_declare:
|
||
case tk_undefproc:
|
||
strcpy(itok4->name,ptr->recid); //имя нужно для undefine
|
||
break;
|
||
default:
|
||
strncpy(itok4->name,(char *)string4,IDLENGTH-1); //имя нужно для undefine
|
||
break;
|
||
}
|
||
return TRUE;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else string4[0]=0;
|
||
strcpy(itok4->name,ptr->recid); //имя нужно для undefine
|
||
if(displaytokerrors)ptr->count++;
|
||
break;
|
||
}
|
||
else if(cmpresult<0)ptr=ptr->left;
|
||
else ptr=ptr->right;
|
||
}
|
||
if(ptr==NULL)return FALSE;
|
||
else return TRUE;
|
||
}
|
||
|
||
int searchtree(ITOK *itok4,int *tok4,unsigned char *string4)
|
||
{
|
||
int retval=FALSE;
|
||
if(skipfind==FALSE){
|
||
if(staticlist)retval=searchtree2(staticlist,itok4,tok4,string4);
|
||
if(!retval)retval=searchtree2(treestart,itok4,tok4,string4);
|
||
if(!retval){
|
||
if((retval=searchtree2(definestart,itok4,tok4,string4))==TRUE){
|
||
if(scanlexmode==DEFLEX2)*tok4=tk_id;
|
||
}
|
||
}
|
||
}
|
||
return retval;
|
||
}
|
||
|
||
void AddDynamicList(idrec *ptr)
|
||
{
|
||
// printf("Add dinamic list %s %08X seg=%d tok=%d\n",ptr->recid,ptr,ptr->recsegm,ptr->rectok);
|
||
if(DynamicList==NULL){
|
||
sizeDL=STEPDL;
|
||
DynamicList=(volatile idrec **)MALLOC(sizeof(idrec **)*sizeDL);
|
||
countDP=0;
|
||
}
|
||
else if(sizeDL==(countDP+1)){
|
||
sizeDL+=STEPDL;
|
||
DynamicList=(volatile idrec **)REALLOC(DynamicList,sizeof(idrec **)*sizeDL);
|
||
}
|
||
for(int i=0;i<countDP;i++)if(ptr==DynamicList[i])return;
|
||
DynamicList[countDP]=ptr;
|
||
countDP++;
|
||
}
|
||
|
||
|
||
void docals(struct idrec *ptr)
|
||
/* extract any procedures required from interal library and insert any
|
||
dynamic procedures that have been called.*/
|
||
{
|
||
if(ptr!=NULL){
|
||
// printf("%s\n",ptr->recid);
|
||
tok=ptr->rectok;
|
||
if(sdp_mode==FALSE&&(ptr->flag&f_export)!=0&&tok==tk_proc){
|
||
if(lexport==NULL){
|
||
lexport=(struct listexport *)MALLOC(sizeof(struct listexport));
|
||
lexport->address=ptr->recnumber;
|
||
strcpy(lexport->name,ptr->recid);
|
||
numexport=1;
|
||
}
|
||
else{
|
||
int cmpname,i;
|
||
for(i=0;i<numexport;i++){
|
||
if((cmpname=strcmp(ptr->recid,(lexport+i)->name))<=0)break;
|
||
}
|
||
if(cmpname!=0){
|
||
lexport=(struct listexport *)REALLOC(lexport,sizeof(struct listexport)*(numexport+1));
|
||
if(cmpname<0){
|
||
for(int j=numexport;j>i;j--){
|
||
memcpy(&(lexport+j)->address,&(lexport+j-1)->address,sizeof(struct listexport));
|
||
}
|
||
}
|
||
numexport++;
|
||
(lexport+i)->address=ptr->recnumber;
|
||
strcpy((lexport+i)->name,ptr->recid);
|
||
}
|
||
}
|
||
}
|
||
if(!(ptr->flag&f_extern)){
|
||
if(tok==tk_undefproc){
|
||
strcpy(itok.name,ptr->recid);
|
||
if(sdp_mode){
|
||
int boutptr=outptr;
|
||
int i;
|
||
if((ptr->flag&f_typeproc)==tp_fastcall){
|
||
if((i=includeit(1))!=-1){
|
||
if(updatecall((unsigned int)ptr->recnumber,boutptr,0)>0){
|
||
ptr->rectok=tk_proc;
|
||
ptr->recnumber=boutptr; // record location placed
|
||
ptr->recrm=i;
|
||
ptr->count++;
|
||
}
|
||
}
|
||
}
|
||
else{
|
||
if((i=includeproc())!=-1){
|
||
if(updatecall((unsigned int)ptr->recnumber,boutptr,0)>0){
|
||
ptr->rectok=tk_proc;
|
||
ptr->recnumber=boutptr; // record location placed
|
||
ptr->recrm=i;
|
||
ptr->count++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else{
|
||
if(updatecall((unsigned int)ptr->recnumber,outptr,0)>0){
|
||
ptr->recnumber=outptr; // record location placed
|
||
linenumber=ptr->line;
|
||
currentfileinfo=ptr->file;
|
||
if((ptr->flag&f_typeproc)==tp_fastcall){
|
||
if(includeit(1)==-1)thisundefined(itok.name);
|
||
}
|
||
else{
|
||
if(includeproc()==-1)thisundefined(itok.name);
|
||
}
|
||
ptr->rectok=tk_proc;
|
||
ptr->count++;
|
||
}
|
||
}
|
||
}
|
||
else if(tok==tk_proc){
|
||
// printf("%08X %s\n",ptr->recpost,ptr->recid);
|
||
itok.segm=ptr->recsegm;
|
||
if(itok.segm==DYNAMIC_USED){
|
||
// printf("%08X %s\n",ptr->recpost,ptr->recid);
|
||
// if(updatecall((unsigned int)ptr->recnumber,outptr,0)>0){
|
||
itok.number=ptr->recnumber;
|
||
itok.flag=ptr->flag;
|
||
itok.post=ptr->recpost;
|
||
strcpy(itok.name,ptr->recid);
|
||
if(ptr->newid==NULL)string[0]=0;
|
||
else strcpy((char *)string,(char *)ptr->newid);
|
||
itok.rm=ptr->recrm;
|
||
itok.size=ptr->recsize;
|
||
itok.rec=ptr;
|
||
insert_dynamic();
|
||
// }
|
||
}
|
||
}
|
||
// else printf("tok=%d %s\n",tok,ptr->recid);
|
||
}
|
||
docals(ptr ->left);
|
||
docals(ptr ->right);
|
||
}
|
||
}
|
||
|
||
void docalls2()
|
||
{
|
||
// puts("start docalls2");
|
||
docals(treestart);
|
||
for(unsigned int i=0;i<totalmodule;i++)docals((startfileinfo+i)->stlist);
|
||
// puts("end docalls2");
|
||
}
|
||
|
||
void docalls() /* attempt to declare undefs from library and dynamic proc's */
|
||
{
|
||
int numdinproc;
|
||
// puts("start docalls");
|
||
notdoneprestuff=2;
|
||
docalls2();
|
||
while(DynamicList!=NULL){
|
||
idrec *ptr;
|
||
numdinproc=0;
|
||
// printf("%d dinamic proc\n",countDP);
|
||
for(int i=0;i<countDP;i++){
|
||
ptr=(idrec *)DynamicList[i];
|
||
tok=ptr->rectok;
|
||
itok.segm=ptr->recsegm;
|
||
// printf("%d %08X seg=%d tok=%d %s\n",i+1,ptr,itok.segm,ptr->rectok,ptr->recid);
|
||
if(itok.segm==DYNAMIC_USED){
|
||
itok.number=ptr->recnumber;
|
||
itok.flag=ptr->flag;
|
||
strcpy(itok.name,ptr->recid);
|
||
if(ptr->newid==NULL)string[0]=0;
|
||
else strcpy((char *)string,(char *)ptr->newid);
|
||
itok.rm=ptr->recrm;
|
||
itok.size=ptr->recsize;
|
||
itok.rec=ptr;
|
||
insert_dynamic();
|
||
numdinproc++;
|
||
}
|
||
}
|
||
docalls2();
|
||
if(numdinproc==0)break;
|
||
}
|
||
free(DynamicList);
|
||
DynamicList=NULL;
|
||
countDP=0;
|
||
// puts("end docalls");
|
||
}
|
||
|
||
void CreatParamDestr(idrec *ptrs)
|
||
{
|
||
if(am32==FALSE){
|
||
structadr.rm=rm_d16;
|
||
structadr.sib=CODE16;
|
||
}
|
||
else{
|
||
structadr.rm=rm_d32;
|
||
structadr.sib=CODE32;
|
||
}
|
||
structadr.segm=DS;
|
||
structadr.number=ptrs->recnumber;
|
||
structadr.flag=0;
|
||
structadr.size=0; //addofs
|
||
structadr.rec=NULL;
|
||
structadr.type=tp_ucnovn;
|
||
structadr.npointr=0;
|
||
structadr.post=ptrs->recpost;
|
||
if(ptrs->recsegm==USEDSTR)structadr.sib++;
|
||
if(structadr.post==LOCAL){
|
||
if(ESPloc&&am32){
|
||
structadr.rm=rm_mod10|rm_sib;
|
||
structadr.sib=0x24;
|
||
structadr.number+=addESP;
|
||
}
|
||
else{
|
||
structadr.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
|
||
}
|
||
structadr.segm=SS;
|
||
compressoffset(&structadr);
|
||
}
|
||
}
|
||
|
||
void CallDestr(idrec *ptr)
|
||
{
|
||
int oinptr2;
|
||
char ocha2;
|
||
int oldendinptr=endinptr;
|
||
unsigned char odbg;
|
||
int otok,otok2;
|
||
unsigned char *oinput;
|
||
ITOK oitok; //18.08.04 19:07
|
||
oinptr2=inptr2;
|
||
ocha2=cha2;
|
||
odbg=dbg;
|
||
dbg=0;
|
||
otok=tok;
|
||
otok2=tok2;
|
||
oitok=itok; //18.08.04 19:07
|
||
oinput=input;
|
||
string[0]=0;
|
||
if(ptr->newid)strcpy((char *)string,ptr->newid);
|
||
itok.type=ptr->type;
|
||
itok.npointr=ptr->npointr;
|
||
itok.rm=ptr->recrm;
|
||
itok.flag=ptr->flag;
|
||
itok.rec=ptr;
|
||
strcpy(itok.name,ptr->recid);
|
||
itok.number=ptr->recnumber;
|
||
tok=ptr->rectok;
|
||
itok.post=ptr->recpost;
|
||
itok.segm=ptr->recsegm;
|
||
itok.sib=ptr->recsib;
|
||
ptr->count++;
|
||
if(itok.segm==DYNAMIC)AddDynamicList(ptr);
|
||
tok2=tk_openbracket;
|
||
input=(unsigned char*)"();";
|
||
inptr2=1;
|
||
cha2='(';
|
||
endinptr=3;
|
||
docommand();
|
||
tok=otok;
|
||
input=oinput;
|
||
inptr2=oinptr2;
|
||
cha2=ocha2;
|
||
tok2=otok2;
|
||
endinptr=oldendinptr;
|
||
dbg=odbg;
|
||
itok=oitok;//18.08.04 19:07
|
||
}
|
||
|
||
elementteg *FindOneDestr(structteg *searcht)
|
||
{
|
||
elementteg *bazael=searcht->baza,*retrez=NULL;
|
||
idrec *ptrs;
|
||
int i;
|
||
/// new!
|
||
for(i=0;i<searcht->numoper;i++){
|
||
ptrs=(bazael+i)->rec;
|
||
if((bazael+i)->tok==tk_proc&&(ptrs->flag&fs_destructor)!=0)return(bazael+i);
|
||
}
|
||
for(i=0;i<searcht->numoper;i++){
|
||
ptrs=(bazael+i)->rec;
|
||
if((bazael+i)->tok==tk_baseclass
|
||
||(bazael+i)->tok==tk_struct //new 20.06.05 21:32
|
||
){
|
||
if((retrez=FindOneDestr((structteg *)ptrs))!=NULL)break;
|
||
}
|
||
}
|
||
return retrez;
|
||
}
|
||
|
||
void Destructor(idrec *ptrs)
|
||
{
|
||
char name[IDLENGTH];
|
||
struct elementteg *bazael;
|
||
int addofs;
|
||
structteg *tteg;
|
||
tteg=(structteg *)ptrs->newid;
|
||
sprintf(name,"%s~",tteg->name);
|
||
if((bazael=FindClassEl(tteg,(unsigned char *)name,&addofs,NULL))==NULL){
|
||
if((bazael=FindOneDestr(tteg))==NULL)preerror("destructor not defined");
|
||
}
|
||
if(ptrs->recsize)CreatParamDestr(ptrs);
|
||
else structadr.sib=THIS_ZEROSIZE;
|
||
CallDestr(bazael->rec);
|
||
}
|
||
|
||
void RunNew(int size)
|
||
{
|
||
char buf[128];
|
||
int oinptr2;
|
||
char ocha2;
|
||
int oldendinptr=endinptr;
|
||
unsigned char odbg;
|
||
int otok,otok2;
|
||
unsigned char *oinput;
|
||
oinptr2=inptr2;
|
||
ocha2=cha2;
|
||
odbg=dbg;
|
||
sprintf(buf,"__new(%u);}",size);
|
||
dbg=0;
|
||
otok=tok;
|
||
otok2=tok2;
|
||
oinput=input;
|
||
input=(unsigned char*)buf;
|
||
inptr2=1;
|
||
cha2='_';
|
||
tok=tk_openbrace;
|
||
endinptr=strlen(buf);
|
||
doblock();
|
||
tok=otok;
|
||
tok2=otok2;
|
||
input=oinput;
|
||
inptr2=oinptr2;
|
||
cha2=ocha2;
|
||
endinptr=oldendinptr;
|
||
dbg=odbg;
|
||
}
|
||
|
||
void donew()
|
||
{
|
||
structteg *tteg;
|
||
elementteg *bazael;
|
||
int addofs=0;
|
||
struct idrec *ptr;
|
||
nexttok();
|
||
if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
|
||
tegnotfound();
|
||
er:
|
||
while(tok2!=tk_semicolon&&tok!=tk_eof)nexttok();
|
||
return;
|
||
}
|
||
// printf("flag=%08X\n",tteg->flag);
|
||
if((tteg->flag&fs_constructor)==0){
|
||
RunNew(tteg->size);
|
||
goto er;
|
||
}
|
||
bazael=FindClassEl(tteg,(unsigned char *)tteg->name,&addofs,NULL);
|
||
structadr.sib=THIS_NEW;
|
||
structadr.number=tteg->size;
|
||
ptr=bazael->rec;
|
||
string[0]=0;
|
||
if(ptr->newid!=NULL)strcpy((char *)string,ptr->newid);
|
||
itok.type=ptr->type;
|
||
itok.npointr=ptr->npointr;
|
||
itok.rm=ptr->recrm;
|
||
itok.flag=ptr->flag;
|
||
itok.rec=ptr;
|
||
strcpy(itok.name,ptr->recid);
|
||
itok.number=ptr->recnumber;
|
||
tok=ptr->rectok;
|
||
itok.post=ptr->recpost;
|
||
itok.segm=ptr->recsegm;
|
||
itok.sib=ptr->recsib;
|
||
ptr->count++;
|
||
if(itok.segm==DYNAMIC)AddDynamicList(ptr);
|
||
// docommand();
|
||
if(dbg)AddLine();
|
||
int oflag=current_proc_type;
|
||
current_proc_type&=~f_static;
|
||
if(tok==tk_proc)doanyproc();
|
||
else doanyundefproc();
|
||
current_proc_type=oflag;
|
||
}
|
||
|
||
void dodelete()
|
||
{
|
||
int addofs=0;
|
||
int oinptr,oinptr2;
|
||
char ocha2;
|
||
int oldendinptr=endinptr;
|
||
unsigned char odbg;
|
||
unsigned char *oinput;
|
||
structteg *tteg=NULL;
|
||
elementteg *bazael;
|
||
char buf[128];
|
||
getoperand();
|
||
if(tok==tk_structvar){
|
||
oinptr=tok2;
|
||
// if((itok.flag&fs_useconstr)!=0){
|
||
if((itok.flag&fs_destructor)!=0){
|
||
Destructor(itok.rec);
|
||
}
|
||
else if(itok.rec->newid&&AskUseDestr((structteg *)itok.rec->newid))Destructor(itok.rec);
|
||
// }
|
||
if(oinptr!=tk_semicolon)nexttok();
|
||
}
|
||
else{
|
||
ITOK wtok;
|
||
char *wbuf;
|
||
wbuf=bufrm;
|
||
bufrm=NULL;
|
||
wtok=itok;
|
||
SINFO wstr;
|
||
wstr=strinf;
|
||
strinf.bufstr=NULL;
|
||
getinto_e_ax(0,tok,&wtok,wbuf,&wstr,(am32+1)*2);
|
||
bufrm=NULL;
|
||
strinf.bufstr=NULL;
|
||
if(tok2!=tk_semicolon){
|
||
nexttok();
|
||
if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
|
||
tegnotfound();
|
||
while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
|
||
return;
|
||
}
|
||
}
|
||
oinptr2=inptr2;
|
||
ocha2=cha2;
|
||
odbg=dbg;
|
||
dbg=0;
|
||
oinput=input;
|
||
int oflag=current_proc_type;
|
||
current_proc_type&=~f_static;
|
||
if(tteg){
|
||
structadr.number=0;
|
||
if((tteg->flag&fs_destructor)!=0){
|
||
op(0x50);
|
||
addESP+=am32==FALSE?2:4;
|
||
sprintf(buf,"%s~",tteg->name);
|
||
bazael=FindClassEl(tteg,(unsigned char *)buf,&addofs,NULL);
|
||
|
||
structadr.sib=THIS_REG;
|
||
structadr.rm=AX;
|
||
structadr.size=addofs; // ???? 19.08.04 12:54 нигде не используется
|
||
CallDestr(bazael->rec);
|
||
addESP-=am32==FALSE?2:4;
|
||
op(0x58);
|
||
}
|
||
else if(AskUseDestr(tteg)){
|
||
bazael=FindOneDestr(tteg);
|
||
op(0x50);
|
||
addESP+=am32==FALSE?2:4;
|
||
structadr.sib=THIS_REG;
|
||
structadr.rm=AX;
|
||
structadr.size=0;//addofs;
|
||
CallDestr(bazael->rec);
|
||
addESP-=am32==FALSE?2:4;
|
||
op(0x58);
|
||
}
|
||
}
|
||
input=(unsigned char*)"__delete((E)AX);}";
|
||
inptr2=1;
|
||
cha2='_';
|
||
endinptr=strlen((char *)input);
|
||
tok=tk_openbrace;
|
||
doblock();
|
||
input=oinput;
|
||
inptr2=oinptr2;
|
||
cha2=ocha2;
|
||
endinptr=oldendinptr;
|
||
dbg=odbg;
|
||
current_proc_type=oflag;
|
||
}
|
||
nextseminext();
|
||
}
|
||
|
||
int AskUseDestr(structteg *searcht)
|
||
{
|
||
elementteg *bazael=searcht->baza;
|
||
if((searcht->flag&fs_destructor)!=0)return TRUE;
|
||
for(int i=0;i<searcht->numoper;i++){
|
||
// printf("tok=%d\n",(bazael+i)->tok);
|
||
if((bazael+i)->tok==tk_baseclass
|
||
||(bazael+i)->tok==tk_struct //new 20.06.05 21:33
|
||
){
|
||
if(AskUseDestr((structteg *)(bazael+i)->rec))return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void AutoDestructor()
|
||
{
|
||
struct localrec *ptrs;
|
||
int calldestruct=FALSE;
|
||
int zerosize=FALSE;
|
||
treelocalrec *ftlr;
|
||
for(ftlr=tlr;ftlr!=NULL;ftlr=ftlr->next){
|
||
for(ptrs=ftlr->lrec;ptrs!=NULL;ptrs=ptrs->rec.next){
|
||
if(ptrs->rec.rectok==tk_structvar){
|
||
if((ptrs->rec.flag&fs_destructor)!=0||AskUseDestr((structteg *)ptrs->rec.newid)){
|
||
if(!calldestruct){
|
||
calldestruct=TRUE;
|
||
if(ptrs->rec.recsize==0||returntype==tk_void)zerosize=TRUE;
|
||
else{
|
||
op66(r32);
|
||
op(0x50);
|
||
addESP+=4;
|
||
}
|
||
}
|
||
Destructor(&ptrs->rec);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if(calldestruct&&zerosize==FALSE){
|
||
op66(r32);
|
||
op(0x58);
|
||
addESP-=4;
|
||
}
|
||
}
|
||
|
||
elementteg *FindClassEl(structteg *searcht,unsigned char *string4,int *addofs,
|
||
structteg *subteg)
|
||
{
|
||
struct elementteg *bazael=searcht->baza;
|
||
int numclass=0;
|
||
void **listclass;
|
||
//11.08.04 22:54
|
||
char name[IDLENGTH];
|
||
strcpy(name,searcht->name);
|
||
|
||
for(unsigned int i=0;i<searcht->numoper;i++){
|
||
if((bazael+i)->tok==tk_baseclass){
|
||
if(!numclass)listclass=(void **)MALLOC(sizeof(void **));
|
||
else listclass=(void **)REALLOC(listclass,sizeof(void **)*(numclass+1));
|
||
listclass[numclass]=(void *)(bazael+i)->nteg;
|
||
numclass++;
|
||
continue;
|
||
}
|
||
if(strcmp((bazael+i)->name,(char *)string4)==0){
|
||
if(subteg&&subteg!=searcht)continue;
|
||
if(numclass)free(listclass);
|
||
//11.08.04 22:54
|
||
strcpy((char *)string4,name);
|
||
|
||
return (bazael+i);
|
||
}
|
||
}
|
||
if(numclass){
|
||
structteg *ssubteg=subteg;
|
||
for(int i=numclass-1;i>=0;i--){
|
||
structteg *s=(structteg *)listclass[i];
|
||
if(subteg==searcht)ssubteg=s;
|
||
if((bazael=FindClassEl(s,string4,addofs,ssubteg))!=NULL){
|
||
i--;
|
||
while(i>=0){
|
||
s=(structteg *)listclass[i];
|
||
*addofs+=s->size;
|
||
i--;
|
||
}
|
||
free(listclass);
|
||
return bazael;
|
||
}
|
||
}
|
||
free(listclass);
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
int CallDestructor(structteg *searcht)
|
||
{
|
||
elementteg *bazael=searcht->baza;
|
||
idrec *ptrs;
|
||
for(int i=0;i<searcht->numoper;i++){
|
||
ptrs=(bazael+i)->rec;
|
||
if((searcht->flag&fs_destructor)==0){
|
||
if((bazael+i)->tok==tk_baseclass){
|
||
if(CallDestructor((structteg *)ptrs))return TRUE;
|
||
}
|
||
}
|
||
else if((bazael+i)->tok==tk_proc&&(ptrs->flag&fs_destructor)!=0){
|
||
structadr.sib=THIS_PARAM;
|
||
structadr.number=0;//addofs;
|
||
CallDestr(ptrs);
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void CopyTok(int *tok4,ITOK *itok4,idrec *ptr)
|
||
{
|
||
itok4->number=ptr->recnumber;
|
||
itok4->rm=ptr->recrm;
|
||
*tok4=ptr->rectok;
|
||
itok4->post=ptr->recpost;
|
||
itok4->segm=ptr->recsegm;
|
||
itok4->flag=ptr->flag;
|
||
itok4->size=ptr->recsize;
|
||
itok4->sib=ptr->recsib;
|
||
itok4->rec=ptr;
|
||
itok4->type=ptr->type;
|
||
itok4->npointr=ptr->npointr;
|
||
}
|
||
|
||
int searchlocals(ITOK *itok4,int *tok4,unsigned char *string4)
|
||
//поиск локальных переменых связаного списка
|
||
{
|
||
if(skiplocals){
|
||
skiplocals=FALSE;
|
||
return FALSE;
|
||
}
|
||
if(skipfind==LOCAL)return FALSE;
|
||
treelocalrec *ftlr;
|
||
struct localrec *ptr;
|
||
for(ftlr=tlr;ftlr!=NULL;ftlr=ftlr->next){
|
||
for(ptr=ftlr->lrec;ptr!=NULL;ptr=ptr->rec.next){
|
||
// puts(ptr->rec.recid);
|
||
if(strcmp(ptr->rec.recid,(char *)string4)==0){
|
||
itok4->number=ptr->rec.recnumber;
|
||
*tok4=ptr->rec.rectok;
|
||
itok4->locrec=ptr;
|
||
if(displaytokerrors){
|
||
if(mapfile){
|
||
if(ptr->li.count==0)ptr->li.usedfirst=linenumber;
|
||
else ptr->li.usedlast=linenumber;
|
||
ptr->li.count++;
|
||
}
|
||
if(*tok4==tk_structvar)ptr->rec.count++;
|
||
}
|
||
// printf("type=%d num=%08X %s\n",ptr->rec.type,ptr->rec.recnumber,ptr->rec.recid);
|
||
if(ptr->rec.type==tp_postvar){
|
||
itok4->segm=DS;
|
||
itok4->flag=ptr->rec.flag;
|
||
itok4->size=ptr->rec.recsize;
|
||
itok4->rm=(am32==FALSE?rm_d16:rm_d32);
|
||
itok4->npointr=ptr->rec.npointr;
|
||
itok4->type=tp_localvar;
|
||
itok4->post=1;
|
||
if(*tok4==tk_structvar){
|
||
itok4->rec=&ptr->rec;
|
||
itok4->post=ptr->rec.recpost;
|
||
// itok4->segm=0;
|
||
}
|
||
return TRUE;
|
||
}
|
||
if(ptr->rec.type==tp_gvar){
|
||
itok4->number=0;
|
||
itok4->rm=(am32==FALSE?rm_d16:rm_d32);
|
||
itok4->segm=DS;
|
||
itok4->size=ptr->rec.recsize;
|
||
itok4->npointr=ptr->rec.npointr;
|
||
itok4->type=ptr->rec.recsib; //????01.09.05 15:58
|
||
itok4->post=USED_DIN_VAR;
|
||
if(ptr->rec.recpost==DYNAMIC_VAR)ptr->rec.recpost=USED_DIN_VAR;
|
||
itok4->rec=&ptr->rec;
|
||
ptr->fuse=USEDVAR;
|
||
if(*tok4==tk_structvar){
|
||
itok4->number=ptr->rec.recnumber;
|
||
itok4->flag|=ptr->rec.flag;
|
||
}
|
||
return TRUE;
|
||
}
|
||
itok4->type=ptr->rec.type;
|
||
if(ptr->rec.type==tp_paramvar||ptr->rec.type==tp_localvar){
|
||
if(ESPloc&&am32){
|
||
itok4->rm=rm_mod10|rm_sib;
|
||
itok4->sib=0x24;
|
||
if(ptr->rec.type==tp_paramvar)itok4->number+=localsize+addESP;
|
||
else itok4->number+=-4+addESP;
|
||
}
|
||
else itok4->rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
|
||
itok4->segm=SS;
|
||
itok4->npointr=ptr->rec.npointr;
|
||
if(ptr->rec.npointr){
|
||
itok4->type=(unsigned short)*tok4-tk_charvar+tk_char;
|
||
*tok4=tk_pointer;
|
||
}
|
||
if(*tok4==tk_structvar){
|
||
itok4->rec=&ptr->rec;
|
||
itok4->post=ptr->rec.recpost;
|
||
itok4->segm=0;
|
||
}
|
||
}
|
||
else if(!(ptr->rec.rectok==tk_locallabel||ptr->rec.rectok==tk_number)){
|
||
internalerror("Bad *tok4 value in searchlocals");
|
||
}
|
||
itok4->size=ptr->rec.recsize;
|
||
itok4->flag=ptr->rec.flag;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
if(searchteg){
|
||
struct elementteg *bazael;
|
||
int addofs=0;
|
||
structteg *subteg=NULL;
|
||
if(cha==':'&&cha2==':'){
|
||
nextchar();
|
||
nextchar();
|
||
if((subteg=FindTeg(TRUE,itok4->name))==NULL&&displaytokerrors)undefclass(itok4->name);
|
||
tokscan(tok4,itok4,string4);
|
||
whitespace();
|
||
}
|
||
if(destructor){
|
||
destructor=FALSE;
|
||
strcat((char *)string4,"~");
|
||
}
|
||
if((bazael=FindClassEl(searchteg,string4,&addofs,subteg))!=NULL){
|
||
*tok4=bazael->tok;
|
||
itok4->type=tp_classvar;
|
||
// printf("tok=%d bazael->rec=%08X %s\n",*tok4,bazael->rec,itok4->name);
|
||
if(*tok4==tk_proc||*tok4==tk_pointer){
|
||
idrec *ptr=bazael->rec;
|
||
if(strchr(itok4->name,'@')==NULL){
|
||
strcat(itok4->name,"@");
|
||
strcat(itok4->name,(char *)string4);
|
||
}
|
||
// }
|
||
// printf("tok=%d %s %s\n",*tok4,ptr->recid,ptr->newid);
|
||
if(*tok4==tk_proc&&ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
|
||
CopyTok(tok4,itok4,bazael->rec);
|
||
structadr.sib=THIS_PARAM;
|
||
structadr.number=0;//addofs;
|
||
if(displaytokerrors){
|
||
ptr->count++;
|
||
if(*tok4==tk_proc){
|
||
if(itok4->segm==DYNAMIC)AddDynamicList(ptr);
|
||
}
|
||
}
|
||
if(*tok4==tk_pointer)goto locvar;
|
||
}
|
||
else if(*tok4==tk_struct){
|
||
*tok4=tk_structvar;
|
||
// printf("teg=%08X\n",bazael->nteg);
|
||
dostructvar2(tok4,itok4,(structteg *)bazael->nteg,string4);
|
||
if(*tok4==tk_structvar){
|
||
itok4->rec=(idrec *)bazael->nteg;
|
||
itok4->number+=(itok4->post==0?0:itok4->rm*((structteg *)bazael->nteg)->size);
|
||
itok4->size=(itok4->post==0?bazael->numel:1)*((structteg *)bazael->nteg)->size;
|
||
|
||
itok4->number+=bazael->ofs+addofs;
|
||
if(displaytokerrors){
|
||
if(strinf.bufstr!=NULL)free(strinf.bufstr);
|
||
strinf.bufstr=(char *)MALLOC(7);
|
||
strcpy(strinf.bufstr,"&this;");
|
||
strinf.size=1;
|
||
}
|
||
// itok4->flag|=f_useidx;
|
||
// if(itok4->sib>=CODE16)itok4->sib++;
|
||
return TRUE;
|
||
|
||
}
|
||
else if(*tok4==tk_proc){
|
||
structadr.sib=THIS_PARAM;
|
||
structadr.number+=bazael->ofs+addofs;
|
||
|
||
if(itok4->sib>=CODE16)itok4->sib++;
|
||
return TRUE;
|
||
}
|
||
|
||
goto locvar;;
|
||
}
|
||
else{
|
||
if(bazael->rec){ //static var
|
||
CopyTok(tok4,itok4,bazael->rec);
|
||
return TRUE;
|
||
}
|
||
|
||
locvar:
|
||
itok4->number+=bazael->ofs+addofs;
|
||
if(displaytokerrors){
|
||
if(bufrm!=NULL)free(bufrm);
|
||
bufrm=(char *)MALLOC(7);
|
||
strcpy(bufrm,"&this;");
|
||
}
|
||
// itok4->flag|=f_useidx;
|
||
if(itok4->sib>=CODE16)itok4->sib++;
|
||
// printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,string4);
|
||
}
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void dostructvar2(int *tok4,ITOK *itok4,struct structteg *tteg,unsigned char *string4) //разбор структур на переменные и структуры
|
||
{
|
||
struct elementteg *bazael;
|
||
int numel=0;
|
||
int usenumstruct=FALSE;
|
||
int sopenb;
|
||
long cnum;
|
||
ITOK cstok;
|
||
char *cstring;
|
||
char c=0;
|
||
int i;
|
||
structteg *subteg=NULL;
|
||
structadr=*itok4;
|
||
// bazael=tteg->baza;
|
||
whitespace();//пропуск незначащих символов
|
||
cstring=(char *)MALLOC(STRLEN);
|
||
if(cha=='['){ //[ номер структуры
|
||
usenumstruct=TRUE;
|
||
nextchar();
|
||
sopenb=inptr;
|
||
unsigned char bcha=cha;
|
||
tokscan(&i,&cstok,(unsigned char *)cstring);
|
||
if(bufrm){
|
||
free(bufrm);
|
||
bufrm=NULL;
|
||
}
|
||
if(i==tk_number){ //числовой
|
||
ITOK dstok;
|
||
memcpy(&dstok,itok4,sizeof(ITOK));
|
||
calcnum(&i,&cstok,cstring,&cnum);
|
||
memcpy(itok4,&dstok,sizeof(ITOK));
|
||
if(i!=tk_closeblock)goto notnum;
|
||
numel=cnum;
|
||
}
|
||
else{
|
||
notnum:
|
||
//new!!!
|
||
if(displaytokerrors){
|
||
if(itok4->segm==USEDSTR)preerror("only once possible use variable an index structure");
|
||
|
||
// if(itok4->segm==USEDSTR&&displaytokerrors)preerror("only once possible use variable an index structure");
|
||
itok4->segm=USEDSTR;
|
||
SRBackBuf(0);
|
||
AddBackBuf(sopenb,bcha);
|
||
CharToBackBuf(';');
|
||
CharToBackBuf(0);
|
||
if(cha!=']')blockerror();
|
||
if(strinf.bufstr!=NULL)free(strinf.bufstr);//internalerror("Previous block was not used");
|
||
strinf.bufstr=(char *)REALLOC(BackTextBlock,SizeBackBuf+1);
|
||
SRBackBuf(1);
|
||
nextchar();
|
||
//new!!!
|
||
}
|
||
else{
|
||
do{
|
||
tokscan(&i,&cstok,(unsigned char *)cstring);
|
||
if(i==tk_eof)break;
|
||
}while(i!=tk_closeblock);
|
||
}
|
||
|
||
c=1;
|
||
strinf.size=tteg->size;
|
||
}
|
||
itok4->flag|=f_useidx;
|
||
whitespace();//пропуск незначащих символов
|
||
}
|
||
if(cha=='.'){
|
||
int fdestr=FALSE;
|
||
nextchar();
|
||
if(cha=='~'){
|
||
nextchar();
|
||
fdestr=TRUE;
|
||
}
|
||
skipfind=LOCAL;
|
||
do{
|
||
tokscan(&i,&cstok,(unsigned char *)cstring);
|
||
// puts(cstok.name);
|
||
if(cha=='.')searchtree2(definestart,&cstok,&i,(unsigned char *)cstring);
|
||
}while(i==tk_endline);
|
||
whitespace();
|
||
if(cha==':'){
|
||
nextchar();
|
||
if(cha!=':')expectederror("::");
|
||
nextchar();
|
||
if((subteg=FindTeg(TRUE,cstok.name))==NULL&&displaytokerrors)undefclass(cstok.name);
|
||
tokscan(&i,&cstok,(unsigned char *)cstring);
|
||
whitespace();
|
||
}
|
||
skipfind=FALSE;
|
||
int addofs=0;
|
||
if(fdestr)strcat(cstok.name,"~");
|
||
if((bazael=FindClassEl(tteg,(unsigned char *)cstok.name,&addofs,subteg))==NULL){
|
||
if(displaytokerrors)unknownstruct(cstok.name,tteg->name);
|
||
*tok4=tk_number;
|
||
free(cstring);
|
||
return;
|
||
}
|
||
free(cstring);
|
||
*tok4=bazael->tok;
|
||
itok4->size=bazael->numel*GetVarSize(*tok4);
|
||
cnum=(c==0?tteg->size*numel:0);
|
||
if((itok4->flag&f_extern)!=0)itok4->number+=((bazael->ofs+cnum)<<16);
|
||
else itok4->number+=bazael->ofs+cnum;
|
||
if(*tok4==tk_struct){
|
||
*tok4=tk_structvar;
|
||
itok4->size=bazael->numel*((structteg *)bazael->nteg)->size;
|
||
dostructvar2(tok4,itok4,(structteg *)bazael->nteg,string4);
|
||
return;
|
||
}
|
||
if((itok4->flag&f_extern)!=0)itok4->number+=addofs<<16;
|
||
else itok4->number+=addofs;
|
||
// printf("tok=%d %s\n",*tok4,bufrm);
|
||
if(*tok4==tk_proc||*tok4==tk_pointer){
|
||
idrec *ptr;//=NULL;
|
||
if(*tok4==tk_proc){
|
||
if(am32==FALSE){
|
||
structadr.rm=rm_d16;
|
||
structadr.sib=CODE16;
|
||
}
|
||
else{
|
||
structadr.rm=rm_d32;
|
||
structadr.sib=CODE32;
|
||
}
|
||
structadr.segm=DS;
|
||
structadr.number=itok4->number;
|
||
// structadr.number=0;
|
||
structadr.flag=0;
|
||
structadr.size=addofs;
|
||
structadr.type=tp_ucnovn;
|
||
structadr.npointr=0;
|
||
structadr.post=itok4->post;
|
||
structadr.rec=(structadr.post==USED_DIN_VAR?itok4->rec:NULL);
|
||
if(itok4->segm==USEDSTR)structadr.sib++;
|
||
if(structadr.post==LOCAL){
|
||
if(ESPloc&&am32){
|
||
structadr.rm=rm_mod10|rm_sib;
|
||
structadr.sib=0x24; //???
|
||
structadr.number+=addESP;
|
||
}
|
||
else{
|
||
structadr.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
|
||
}
|
||
structadr.segm=SS;
|
||
compressoffset(&structadr);
|
||
if(tteg->size==0)structadr.sib=THIS_ZEROSIZE; //14.11.05 13:51
|
||
}
|
||
/* if(strcmp(bazael->name,tteg->name)==0&&itok4->rec){ //вызов конструктора
|
||
ptr=itok4->rec;
|
||
// printf("constructor %08X\n",ptr);
|
||
}*/
|
||
}
|
||
// if(ptr)printf("new address constructor %08X\n",bazael->rec);
|
||
ptr=bazael->rec;
|
||
itok4->type=ptr->type;
|
||
itok4->npointr=ptr->npointr;
|
||
itok4->rm=ptr->recrm;
|
||
itok4->flag=ptr->flag;
|
||
itok4->rec=ptr;
|
||
strcpy(itok4->name,ptr->recid);
|
||
if(*tok4==tk_pointer){
|
||
// puts("Check this code");
|
||
string4[0]=0;
|
||
if(ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
|
||
*tok4=ptr->rectok;
|
||
//!!!
|
||
if(itok4->type==tk_proc&&cha!='('){
|
||
itok4->type=(am32==FALSE?tk_wordvar:tk_dwordvar);
|
||
goto notbit;
|
||
}
|
||
|
||
if(itok4->type!=tk_proc)goto notbit;
|
||
// printf("post=%08X %s\n",itok4->post,itok4->name);
|
||
if(itok4->post==LOCAL){
|
||
if(ESPloc&&am32){
|
||
itok4->rm=rm_mod10|rm_sib;
|
||
itok4->sib=0x24;
|
||
itok4->number+=addESP;
|
||
}
|
||
else{
|
||
itok4->sib=rm_mod10|(am32==FALSE?rm_BP:rm_EBP); //???rm
|
||
}
|
||
itok4->segm=SS;
|
||
itok4->post=FALSE;
|
||
}
|
||
else{
|
||
itok4->sib=(am32==FALSE?rm_d16:rm_d32); //установки по умолчанию
|
||
itok4->segm=DS;
|
||
}
|
||
// itok4->post=0;
|
||
itok4->flag|=f_useidx;
|
||
return;
|
||
}
|
||
itok4->number=ptr->recnumber;
|
||
*tok4=ptr->rectok;
|
||
itok4->post=ptr->recpost;
|
||
itok4->segm=ptr->recsegm;
|
||
itok4->sib=ptr->recsib;
|
||
itok4->size=ptr->recsize; //11.08.04 00:24
|
||
//11.09.04 00:28
|
||
if(strchr(itok4->name,'@')==NULL){
|
||
strcat(itok4->name,"@");
|
||
strcat(itok4->name,(char *)string4);
|
||
}
|
||
string4[0]=0;
|
||
if(ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
|
||
////////////////////
|
||
|
||
// printf("tok=%d num=%d %s\n",*tok4,itok4->number,itok4->name);
|
||
if(displaytokerrors){
|
||
ptr->count++;
|
||
if(*tok4==tk_proc&&itok4->segm==DYNAMIC)AddDynamicList(ptr);
|
||
if(*tok4!=tk_proc&&*tok4!=tk_undefproc&&*tok4!=tk_declare)thisundefined(ptr->recid,FALSE);
|
||
}
|
||
return;
|
||
}
|
||
// if((itok4->flag&f_extern)!=0)itok4->number+=addofs;
|
||
// else itok4->number+=addofs;
|
||
if(*tok4==tk_bits){
|
||
itok4->flag|=f_useidx;
|
||
itok4->number+=bazael->bit.ofs/8;
|
||
if((bazael->bit.ofs%8)==0){
|
||
switch(bazael->bit.siz){
|
||
case 8:
|
||
*tok4=tk_bytevar;
|
||
goto notbit;
|
||
case 16:
|
||
*tok4=tk_wordvar;
|
||
goto notbit;
|
||
case 32:
|
||
*tok4=tk_dwordvar;
|
||
goto notbit;
|
||
}
|
||
}
|
||
itok4->bit.siz=bazael->bit.siz;
|
||
itok4->bit.ofs=bazael->bit.ofs%8;
|
||
}
|
||
else if(bazael->rec){ //static var
|
||
CopyTok(tok4,itok4,bazael->rec);
|
||
return;
|
||
}
|
||
notbit:
|
||
itok4->sib=cstok.sib;
|
||
if(itok4->post==LOCAL){
|
||
if(ESPloc&&am32){
|
||
itok4->rm=rm_mod10|rm_sib;
|
||
// printf("sib=%x tok=%d name=%s\n",itok4->sib,*tok4,itok4->name);
|
||
itok4->sib=0x24;
|
||
itok4->number+=addESP;
|
||
}
|
||
else{
|
||
itok4->rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
|
||
if(itok4->segm==USEDSTR&&itok4->sib>=CODE16)itok4->sib++;
|
||
}
|
||
itok4->segm=SS;
|
||
itok4->post=FALSE;
|
||
itok4->flag=f_useidx;
|
||
}
|
||
else{
|
||
itok4->rm=(am32==FALSE?rm_d16:rm_d32); //установки по умолчанию
|
||
if(itok4->segm==USEDSTR&&itok4->sib>=CODE16)itok4->sib++;
|
||
itok4->segm=DS;
|
||
itok4->flag=FixUp|f_useidx;
|
||
}
|
||
return;
|
||
}
|
||
// itok4->size=(numel==0?bazael->numel:1)*((structteg *)bazael->nteg)->size;
|
||
// itok4->rec=(idrec *)tteg;
|
||
itok4->rm=numel;
|
||
itok4->post=usenumstruct;
|
||
free(cstring);
|
||
}
|
||
|
||
void dosizeof(ITOK *itok4) //опр значение sizeof
|
||
{
|
||
struct structteg *tteg;
|
||
int i,brase=FALSE;
|
||
ITOK cstok;
|
||
whitespace();//пропуск незначащих символов
|
||
itok4->number=0;
|
||
if(cha=='('){
|
||
nextchar();
|
||
brase=TRUE;
|
||
}
|
||
// if((cha!='(')&&(displaytokerrors))expected('(');
|
||
// nextchar();
|
||
cstok.name[0]=0;
|
||
// if(displaytokerrors)puts("start sizeof");
|
||
tokscan(&i,&cstok,string2);
|
||
// if(displaytokerrors)printf("tok=%d findoffset=%d %s\n",i,findofset,cstok.name);
|
||
if(i==tk_dblcolon&&numblocks){
|
||
skiplocals=TRUE;
|
||
tokscan(&i,&cstok,string2);
|
||
}
|
||
if(strcmp(cstok.name,"__CODESIZE")==0){
|
||
itok4->post=CODE_SIZE+am32;
|
||
}
|
||
else if(strcmp(cstok.name,"__DATASIZE")==0){
|
||
itok4->post=DATA_SIZE+am32;
|
||
}
|
||
else if(strcmp(cstok.name,"__POSTSIZE")==0){
|
||
itok4->post=POST_SIZE+am32;
|
||
}
|
||
else if(strcmp(cstok.name,"__STACKSIZE")==0){
|
||
itok4->post=STACK_SIZE+am32;
|
||
}
|
||
else{
|
||
switch(i){
|
||
case tk_char:
|
||
case tk_byte:
|
||
case tk_beg:
|
||
itok4->number=1;
|
||
break;
|
||
case tk_int:
|
||
case tk_word:
|
||
case tk_reg:
|
||
case tk_seg:
|
||
itok4->number=2;
|
||
break;
|
||
case tk_float:
|
||
case tk_reg32:
|
||
case tk_long:
|
||
case tk_dword:
|
||
itok4->number=4;
|
||
break;
|
||
case tk_double:
|
||
case tk_qword:
|
||
itok4->number=8;
|
||
break;
|
||
case tk_string:
|
||
itok4->number=cstok.number;
|
||
if(/*itok4->*/cstok.flag!=no_term)itok4->number++;
|
||
break;
|
||
case tk_bits:
|
||
itok4->number=cstok.bit.siz;
|
||
break;
|
||
case tk_proc:
|
||
case tk_charvar:
|
||
case tk_bytevar:
|
||
case tk_intvar:
|
||
case tk_wordvar:
|
||
case tk_longvar:
|
||
case tk_dwordvar:
|
||
case tk_floatvar:
|
||
case tk_structvar:
|
||
case tk_qwordvar:
|
||
case tk_doublevar:
|
||
case tk_interruptproc:
|
||
if(cstok.size==0)if(displaytokerrors)preerror("unknown size");
|
||
itok4->number=cstok.size;
|
||
break;
|
||
default:
|
||
if((tteg=FindTeg(FALSE,cstok.name))!=NULL||(tteg=FindTeg(TRUE,cstok.name))!=NULL){
|
||
if(cha=='.'){
|
||
dostructvar2(&i,itok4,tteg,string2);
|
||
itok4->number=itok4->size;
|
||
if(bufrm){
|
||
free(bufrm);
|
||
bufrm=NULL;
|
||
}
|
||
}
|
||
else itok4->number=tteg->size;
|
||
itok4->flag=0;
|
||
break;
|
||
}
|
||
if(strcmp("file",(char *)string2)==0){
|
||
displaytokerrors=1;
|
||
tokscan(&i,&cstok,string2);
|
||
if(i==tk_string){
|
||
struct stat statbuf;
|
||
if(stat((char *)string3,&statbuf)!=0)unableopenfile((char *)string3);
|
||
else itok4->number=statbuf.st_size;
|
||
}
|
||
else stringexpected();
|
||
}
|
||
else if(displaytokerrors)preerror("illegal use of sizeof");
|
||
break;
|
||
}
|
||
}
|
||
whitespace();//пропуск незначащих символов
|
||
if(brase){
|
||
if(cha!=')'&&displaytokerrors)expected(')');
|
||
nextchar();
|
||
}
|
||
}
|
||
|
||
void ofsstr(int *tok4,ITOK *itok4)
|
||
{
|
||
struct structteg *tteg;
|
||
int newreg=(idxregs[4]==255?idxregs[0]:idxregs[4]); //14.06.06 20:06
|
||
int poststr;
|
||
int flagstr;
|
||
if(itok4->type==tp_classvar){
|
||
tteg=(structteg *)itok4->rec;
|
||
poststr=0;
|
||
flagstr=f_useidx;
|
||
}
|
||
else{
|
||
struct idrec *ptrs;
|
||
ptrs=itok4->rec;
|
||
tteg=(structteg *)ptrs->newid;
|
||
poststr=ptrs->recpost;
|
||
flagstr=ptrs->flag;
|
||
}
|
||
if(tteg==NULL){
|
||
if(displaytokerrors){
|
||
unknowntagstruct(itok4->name);
|
||
}
|
||
return;
|
||
}
|
||
if(strinf.bufstr==NULL&&itok4->post==TRUE)itok4->number+=(tteg->size*(itok4->rm));
|
||
itok4->size=tteg->size;
|
||
itok4->sib=(am32==FALSE?CODE16:CODE32);
|
||
char ocha=cha;
|
||
int binptr=inptr;
|
||
if(poststr==LOCAL){
|
||
itok4->rm=rm_mod10;
|
||
if(strinf.bufstr==NULL){
|
||
if(ESPloc&&am32){
|
||
itok4->rm|=rm_sib;
|
||
itok4->sib=0x24;
|
||
}
|
||
else{
|
||
itok4->rm|=(am32==FALSE?rm_BP:rm_EBP);
|
||
}
|
||
}
|
||
else{
|
||
if(displaytokerrors){
|
||
if((newreg=CheckIDXReg(strinf.bufstr,strinf.size,idxregs[0]))!=NOINREG){
|
||
if(newreg==SKIPREG){
|
||
newreg=idxregs[0];
|
||
}
|
||
else{
|
||
if(am32==FALSE&&newreg!=DI)goto noopt1;
|
||
waralreadinitreg(regs[am32][idxregs[0]],regs[am32][newreg]);
|
||
}
|
||
free(strinf.bufstr);
|
||
strinf.bufstr=NULL;
|
||
goto cont1;
|
||
}
|
||
newreg=idxregs[0];
|
||
noopt1:
|
||
CheckMassiv(strinf.bufstr,strinf.size,idxregs[0]);
|
||
cont1: ;
|
||
}
|
||
if(am32==FALSE)itok4->rm|=CalcRm16(BP,newreg);
|
||
else{
|
||
itok4->sib=(newreg<<3)+(ESPloc?ESP:EBP);
|
||
itok4->rm=4|rm_mod10;
|
||
}
|
||
}
|
||
itok4->segm=SS;
|
||
if(ESPloc&&am32)itok4->number+=addESP;
|
||
// else itok4->number-=localsize;
|
||
*tok4=tk_rmnumber;
|
||
if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
|
||
itok4->post=FALSE;
|
||
compressoffset(itok4);
|
||
}
|
||
else{
|
||
itok4->post=poststr;
|
||
if(strinf.bufstr==NULL){
|
||
itok4->rm=(am32==FALSE?rm_d16:rm_d32); //установки по умолчанию
|
||
if(itok4->post!=0)*tok4=tk_postnumber;
|
||
else *tok4=tk_number;
|
||
}
|
||
else{
|
||
if(displaytokerrors){
|
||
if((newreg=CheckIDXReg(strinf.bufstr,strinf.size,idxregs[0]))!=NOINREG){
|
||
if(newreg==SKIPREG){
|
||
newreg=idxregs[0];
|
||
}
|
||
else{
|
||
if(am32==FALSE&&newreg!=DI&&newreg!=BX)goto noopt2;
|
||
waralreadinitreg(regs[am32][idxregs[0]],regs[am32][newreg]);
|
||
}
|
||
free(strinf.bufstr);
|
||
strinf.bufstr=NULL;
|
||
goto cont2;
|
||
}
|
||
newreg=(idxregs[4]==255?idxregs[0]:idxregs[4]); //14.06.06 20:06
|
||
noopt2:
|
||
CheckMassiv(strinf.bufstr,strinf.size,(idxregs[4]==255?idxregs[0]:idxregs[4]));
|
||
cont2: ;
|
||
}
|
||
itok4->rm=RegToRM(newreg,(am32==FALSE?tk_reg:tk_reg32))|rm_mod10;
|
||
*tok4=tk_rmnumber;
|
||
}
|
||
itok4->segm=DS;
|
||
}
|
||
if(itok4->post==0&&(itok4->flag&f_reloc)==0){ // cannot compress if POST var
|
||
compressoffset(itok4);
|
||
}
|
||
// compressoffset(itok4);
|
||
itok4->flag|=flagstr;
|
||
inptr=binptr;
|
||
cha=ocha;
|
||
}
|
||
|
||
void AddUndefOff(int segm,char *ostring) //зафиксировать обращение к еще не объявленым именам
|
||
/*segm - сегмент откуда идет обращение
|
||
0 - сегмент кода
|
||
1 - сегмент данных
|
||
2 - сегмент кода, но без занесения в таблицу перемещений
|
||
3 - сегмент данных, но без занесения в таблицу перемещений
|
||
*/
|
||
{
|
||
UNDEFOFF *curptr;
|
||
if(undefoffstart==NULL){ //если еще не было неизв меток
|
||
undefoffstart=(UNDEFOFF *)MALLOC(sizeof(UNDEFOFF));
|
||
memset(undefoffstart,0,sizeof(UNDEFOFF));
|
||
strcpy(undefoffstart->name,ostring);
|
||
}
|
||
for(curptr=undefoffstart;;curptr=curptr->next){
|
||
if(strcmp(curptr->name,ostring)==0){ //ранее уже обращались к ней
|
||
//таблица обращений к undef
|
||
if(curptr->pos==NULL)curptr->pos=(IOFS *)MALLOC(sizeof(IOFS)*(curptr->num+1));
|
||
else curptr->pos=(IOFS *)REALLOC(curptr->pos,sizeof(IOFS)*(curptr->num+1));
|
||
(curptr->pos+curptr->num)->ofs=segm==0?outptr:outptrdata;
|
||
(curptr->pos+curptr->num)->dataseg=(unsigned char)segm;
|
||
(curptr->pos+curptr->num)->line=linenumber;
|
||
(curptr->pos+curptr->num)->file=currentfileinfo;
|
||
curptr->num++;
|
||
return;
|
||
}
|
||
if(curptr->next==NULL)break; //конец списка
|
||
}
|
||
curptr=curptr->next=(UNDEFOFF *)MALLOC(sizeof(UNDEFOFF)); //новая undef
|
||
memset(curptr,0,sizeof(UNDEFOFF));
|
||
strcpy(curptr->name,ostring);
|
||
curptr->num=1;
|
||
curptr->pos=(IOFS *)MALLOC(sizeof(IOFS));
|
||
curptr->pos->ofs=segm==0?outptr:outptrdata;
|
||
curptr->pos->dataseg=(unsigned char)segm;
|
||
curptr->pos->line=linenumber;
|
||
curptr->pos->file=currentfileinfo;
|
||
}
|
||
|
||
int CheckUseAsUndef(unsigned char *name)
|
||
{
|
||
UNDEFOFF *curptr;
|
||
int count=0;
|
||
if(undefoffstart==NULL)return 0; //не было обращений к undef
|
||
for(curptr=undefoffstart;;curptr=curptr->next){
|
||
if(strcmp(curptr->name,(char *)name)==0){ //нашли
|
||
count=curptr->num;
|
||
break;
|
||
}
|
||
if(curptr->next==NULL)break;
|
||
}
|
||
return count;
|
||
}
|
||
|
||
int FindOff(unsigned char *name,int base) //поиск ссылок на текущее имя
|
||
{
|
||
/*-----------------13.08.00 23:48-------------------
|
||
просмотреть процедуру при вводе разделения данных и кода
|
||
--------------------------------------------------*/
|
||
UNDEFOFF *curptr,*prev;
|
||
unsigned char segm;
|
||
unsigned int ofs,valofs;
|
||
int count=0;
|
||
if(undefoffstart==NULL)return 0; //не было обращений к undef
|
||
for(curptr=undefoffstart;;curptr=curptr->next){
|
||
if(strcmp(curptr->name,(char *)name)==0){ //нашли
|
||
for(int i=0;i<curptr->num;i++){
|
||
ofs=(curptr->pos+i)->ofs;
|
||
segm=(curptr->pos+i)->dataseg;
|
||
if(base==DS&&dynamic_flag){ //было обращение к динамическим иниц. переменным
|
||
CheckPosts();
|
||
(postbuf+posts)->type=(unsigned short)(am32==0?DIN_VAR:DIN_VAR32);
|
||
(postbuf+posts)->num=(int)itok.rec;
|
||
(postbuf+posts)->loc=ofs;
|
||
}
|
||
else{
|
||
if((segm&1)==0||modelmem==TINY){ //в сегменте кода
|
||
if(base!=VARPOST){
|
||
// if(am32==FALSE)valofs=*(unsigned short *)&output[ofs];
|
||
// else valofs=*(unsigned long *)&output[ofs];
|
||
// valofs+=(base==CS?outptr:outptrdata);
|
||
valofs=(base==CS?outptr:outptrdata);
|
||
}
|
||
else valofs=postsize;
|
||
if(am32==FALSE)*(unsigned short *)&output[ofs]+=(unsigned short)valofs;
|
||
else *(unsigned long *)&output[ofs]+=valofs;
|
||
}
|
||
else{
|
||
if(am32==FALSE)*(unsigned short *)&outputdata[ofs]+=(unsigned short)(base==CS?outptr:outptrdata);
|
||
else *(unsigned long *)&outputdata[ofs]+=(unsigned long)(base==CS?outptr:outptrdata);
|
||
}
|
||
if((FixUp!=FALSE&&(segm&2)==0)/*||base==VARPOST*/){
|
||
CheckPosts();
|
||
(postbuf+posts)->type=(unsigned char)
|
||
// (base==VARPOST?(am32==FALSE?POST_VAR:POST_VAR32):
|
||
((segm&1)==0?(am32==FALSE?FIX_VAR:FIX_VAR32):
|
||
(am32==FALSE?FIX_CODE:FIX_CODE32)
|
||
// )
|
||
);
|
||
(postbuf+posts)->loc=ofs;
|
||
posts++;
|
||
}
|
||
if(base==VARPOST){
|
||
unsigned int i;
|
||
for(i=0;i<posts;i++){
|
||
if(ofs==(postbuf+i)->loc)break;
|
||
}
|
||
if(i==posts){
|
||
CheckPosts();
|
||
posts++;
|
||
(postbuf+i)->loc=ofs;
|
||
}
|
||
(postbuf+i)->type=(unsigned char)(am32==FALSE?POST_VAR:POST_VAR32);
|
||
}
|
||
}
|
||
}
|
||
free(curptr->pos);
|
||
if(undefoffstart->next==NULL)undefoffstart=NULL;
|
||
else if(undefoffstart==curptr)undefoffstart=curptr->next;
|
||
else{
|
||
for(prev=undefoffstart;prev->next!=curptr;prev=prev->next);
|
||
prev->next=curptr->next;
|
||
}
|
||
count=curptr->num;
|
||
free(curptr);
|
||
break;
|
||
}
|
||
if(curptr->next==NULL)break;
|
||
}
|
||
return count;
|
||
}
|
||
|
||
int FindUseName(char *name) //поиск ссылок на текущее имя
|
||
{
|
||
UNDEFOFF *curptr;
|
||
if(undefoffstart){
|
||
for(curptr=undefoffstart;;curptr=curptr->next){
|
||
if(strcmp(curptr->name,(char *)name)==0){ //нашли
|
||
return curptr->num;
|
||
}
|
||
if(curptr->next==NULL)break;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int GetDirective(char *str)
|
||
{
|
||
int i;
|
||
i=FastSearch(dirlist,ofsdir,1,str);
|
||
// printf("i=%d %s\n",i,str);
|
||
if(i!=-1&&i<d_end1&¬doneprestuff!=TRUE&&displaytokerrors!=0){
|
||
char buf[80];
|
||
sprintf(buf,"Too late to change %s",str);
|
||
preerror(buf);
|
||
}
|
||
return i;
|
||
}
|
||
|
||
int FastSearch(unsigned char *list,short unsigned *ofs,int type,char *str)
|
||
{
|
||
if((strlen(str)-1)>0){
|
||
short offs=-1;
|
||
unsigned char c;
|
||
c=str[0];
|
||
switch(type){
|
||
case 0:
|
||
if(c>='A'&&c<='Z')offs=ofs[c-'A'];
|
||
break;
|
||
case 1:
|
||
if(c=='D')offs=ofs[0];
|
||
else if(c>='a'&&c<='z')offs=ofs[c-0x60];
|
||
break;
|
||
case 2:
|
||
if(c=='_')offs=ofs[26];
|
||
else if(c>='a'&&c<='z')offs=ofs[c-'a'+27];
|
||
else offs=ofs[c-'A'];
|
||
break;
|
||
case 3:
|
||
if(c>='a'&&c<='z')offs=ofs[c-0x61];
|
||
break;
|
||
}
|
||
// if(type==0)printf("%s\n",str);
|
||
if(offs!=-1){
|
||
for(unsigned char *ii=(unsigned char *)(list+offs);;ii++){
|
||
short types;
|
||
if((types=*(short *)&*ii)==-1)break;
|
||
ii+=2;
|
||
unsigned char c=*ii;
|
||
int i;
|
||
i=1;
|
||
while(c==str[i]){
|
||
if(c==0)return types;
|
||
ii++;
|
||
i++;
|
||
c=*ii;
|
||
}
|
||
if(c>str[i])break;
|
||
while(*ii!=0)ii++;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
/*-----------------05.01.00 22:56-------------------
|
||
Работа со структурами
|
||
--------------------------------------------------*/
|
||
|
||
int GetVarSize(int var)
|
||
{
|
||
switch(var){
|
||
case tk_reg:
|
||
case tk_intvar:
|
||
case tk_seg:
|
||
case tk_wordvar: return 2;
|
||
case tk_bits:
|
||
case tk_charvar:
|
||
case tk_beg:
|
||
case tk_bytevar: return 1;
|
||
case tk_pointer:
|
||
if(am32==0)return 2;
|
||
case tk_longvar:
|
||
case tk_dwordvar:
|
||
case tk_reg32:
|
||
case tk_floatvar: return 4;
|
||
case tk_doublevar:
|
||
case tk_qwordvar: return 8;
|
||
default:
|
||
if(am32)return 4;
|
||
}
|
||
return 2;
|
||
}
|
||
|
||
unsigned long getsizebit(int size)
|
||
{
|
||
unsigned long num;
|
||
nexttok();
|
||
if(tok!=tk_number)numexpected();
|
||
num=doconstdwordmath();
|
||
if(num>(unsigned int)(size*8))preerror("Bit field to large");
|
||
return num;
|
||
}
|
||
|
||
int GetFirstDestr(structteg *searcht)
|
||
{
|
||
elementteg *bazael=searcht->baza;
|
||
idrec *ptrs;
|
||
if((searcht->flag&fs_destructor)!=0)return TRUE;
|
||
for(int i=0;i<searcht->numoper;i++){
|
||
ptrs=(bazael+i)->rec;
|
||
if((bazael+i)->tok==tk_baseclass){
|
||
if(GetFirstDestr((structteg *)ptrs))return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void AddTegToTree(structteg *newteg,int Global)
|
||
{
|
||
struct structteg *tteg;
|
||
int i;
|
||
tteg=(Global==TRUE?tegtree:ltegtree);
|
||
if(tteg==NULL)(Global==TRUE?tegtree:ltegtree)=newteg;
|
||
else{
|
||
while(((i=strcmp(tteg->name,newteg->name))<0&&tteg->left!=NULL)||(i>0&&tteg->right!=NULL))
|
||
tteg=(i<0?tteg->left:tteg->right);
|
||
(i<0?tteg->left:tteg->right)=newteg;
|
||
}
|
||
}
|
||
|
||
int IsClass(structteg *searcht)
|
||
{
|
||
elementteg *bazael=searcht->baza;
|
||
if((searcht->flag&fs_destructor)!=0)return TRUE;
|
||
for(int i=0;i<searcht->numoper;i++){
|
||
if((bazael+i)->tok==tk_baseclass)return TRUE;
|
||
// if(IsClass((structteg *)(bazael+i)->rec))return TRUE;
|
||
else if((bazael+i)->tok==tk_proc){
|
||
if((bazael+i)->rec&&((bazael+i)->rec->flag&f_classproc))return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
struct structteg *CreatTeg(int Global,int useunion,int noname) //создать новый тег
|
||
{
|
||
struct structteg *newteg,*tteg;
|
||
struct elementteg *bazael;
|
||
int ssize=0,numel=0,localtok,size,numt,nameid=FALSE,tsize;
|
||
int bitofs=0,bitsize=0,i,type;
|
||
int isdestr=FALSE,isbase=0;
|
||
int unionsize=0;
|
||
newteg=(struct structteg *)MALLOC(sizeof(struct structteg));
|
||
newteg->left=newteg->right=NULL;
|
||
newteg->baza=NULL;
|
||
newteg->flag=useunion;
|
||
newteg->name[0]=0;
|
||
if(tok==tk_ID||tok==tk_id){
|
||
strcpy(newteg->name,itok.name);
|
||
AddTegToTree(newteg,Global);
|
||
nexttok();
|
||
nameid=TRUE;
|
||
}
|
||
if(tok==tk_colon){
|
||
nexttok();
|
||
do{
|
||
if((tteg=FindTeg(TRUE))==NULL)undefclass(itok.name);
|
||
else{
|
||
size=tteg->size;
|
||
if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg));
|
||
else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+1));
|
||
for(i=0;i<numel;i++){
|
||
if(strcmp((bazael+i)->name,itok.name)==0){
|
||
sprintf((char *)string,"Dublicate base class '%s'",itok.name);
|
||
preerror((char *)string);
|
||
}
|
||
}
|
||
strcpy((bazael+numel)->name,itok.name);
|
||
(bazael+numel)->tok=tk_baseclass;
|
||
(bazael+numel)->ofs=ssize;
|
||
(bazael+numel)->numel=1;
|
||
ssize+=size;
|
||
(bazael+numel)->nteg=tteg;
|
||
numel++;
|
||
isbase++;
|
||
}
|
||
nexttok();
|
||
if(tok==tk_openbrace)break;
|
||
expecting(tk_camma);
|
||
}while(tok!=tk_eof);
|
||
if(useunion)preerror("union cannot have a base type");
|
||
}
|
||
expecting(tk_openbrace);
|
||
while(tok!=tk_closebrace&&tok!=tk_eof){
|
||
int oflag,orm,npointr;
|
||
int utestInitVar=FALSE;
|
||
orm=tokens;
|
||
npointr=oflag=0;
|
||
type=variable;
|
||
if(tok==tk_tilda){
|
||
newteg->flag|=fs_destructor;
|
||
oflag|=fs_destructor;
|
||
// oflag=newteg->flag;
|
||
nexttok();
|
||
isdestr=TRUE;
|
||
}
|
||
//13.09.04 00:08
|
||
if(tok==tk_static){
|
||
oflag|=f_static;
|
||
nexttok();
|
||
}
|
||
/////////////
|
||
switch(tok){
|
||
case tk_int: orm=tok; localtok=tk_intvar; size=2; break;
|
||
case tk_word: orm=tok; localtok=tk_wordvar; size=2; break;
|
||
case tk_char: orm=tok; localtok=tk_charvar; size=1; break;
|
||
case tk_byte: orm=tok; localtok=tk_bytevar; size=1; break;
|
||
case tk_long: orm=tok; localtok=tk_longvar; size=4; break;
|
||
case tk_dword: orm=tok; localtok=tk_dwordvar; size=4; break;
|
||
case tk_float: orm=tok; localtok=tk_floatvar; size=4; break;
|
||
case tk_qword: orm=tok; localtok=tk_qwordvar; size=8; break;
|
||
case tk_double: orm=tok; localtok=tk_doublevar; size=8; break;
|
||
case tk_union:
|
||
nexttok();
|
||
i=FALSE;
|
||
if(bitofs&&(!useunion)){
|
||
ssize+=(bitofs+7)/8;
|
||
bitofs=0;
|
||
}
|
||
if(tok==tk_openbrace)i=TRUE;
|
||
if((tteg=CreatTeg(Global,TRUE,i))!=NULL){
|
||
if(tok==tk_semicolon){
|
||
if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg)*tteg->numoper);
|
||
else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+tteg->numoper));
|
||
for(i=0;i<tteg->numoper;i++)(tteg->baza+i)->ofs+=ssize;
|
||
memcpy((elementteg *)(bazael+numel),tteg->baza,sizeof(struct elementteg)*tteg->numoper);
|
||
tsize=tteg->size;
|
||
if(useunion==FALSE)ssize+=tsize;
|
||
else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
|
||
numel+=tteg->numoper;
|
||
free(tteg->baza);
|
||
free(tteg);
|
||
size=0;
|
||
nexttok();
|
||
break;
|
||
}
|
||
else{
|
||
tsize=size=tteg->size;
|
||
localtok=tk_struct;
|
||
goto dproc2;
|
||
}
|
||
}
|
||
else declareunion();
|
||
break;
|
||
case tk_struct:
|
||
nexttok();
|
||
case tk_id:
|
||
case tk_ID:
|
||
if(bitofs&&(!useunion)){
|
||
ssize+=(bitofs+7)/8;
|
||
bitofs=0;
|
||
}
|
||
i=0;
|
||
if(tok==tk_openbrace||tok2==tk_openbrace){
|
||
if(tok==tk_openbrace)i=TRUE;
|
||
if((tteg=CreatTeg(Global,FALSE,i))!=NULL){
|
||
if(tok!=tk_semicolon){
|
||
tsize=size=tteg->size;
|
||
localtok=tk_struct;
|
||
// printf("tok=%d %s\n",tok,itok.name);
|
||
goto dproc2;
|
||
}
|
||
else{
|
||
if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg)*tteg->numoper);
|
||
else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+tteg->numoper));
|
||
for(i=0;i<tteg->numoper;i++)(tteg->baza+i)->ofs+=ssize;
|
||
memcpy((elementteg *)(bazael+numel),tteg->baza,sizeof(struct elementteg)*tteg->numoper);
|
||
tsize=tteg->size;
|
||
if(useunion==FALSE)ssize+=tsize;
|
||
else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
|
||
numel+=tteg->numoper;
|
||
free(tteg->baza);
|
||
free(tteg);
|
||
size=0;
|
||
nexttok();
|
||
break;
|
||
}
|
||
}
|
||
datatype_expected();
|
||
}
|
||
if(strcmp(itok.name,newteg->name)==0&&tok2==tk_openbracket){
|
||
if(oflag==0){
|
||
newteg->flag|=fs_constructor;
|
||
oflag|=fs_constructor;
|
||
orm=am32==FALSE?tk_word:tk_dword;
|
||
}
|
||
else if(oflag==fs_destructor){
|
||
strcat(itok.name,"~");
|
||
orm=tk_void;
|
||
}
|
||
goto dproc2;
|
||
}
|
||
if((tteg=FindTeg(FALSE))!=NULL||(tteg=FindTeg(TRUE))!=NULL){
|
||
if(tok2==tk_mult){
|
||
while(tok2==tk_mult)nexttok();
|
||
if(am32){
|
||
localtok=tk_dwordvar;
|
||
size=4;
|
||
orm=tk_dword;
|
||
}
|
||
else{
|
||
localtok=tk_wordvar;
|
||
size=2;
|
||
orm=tk_word;
|
||
}
|
||
warpointerstruct();
|
||
}
|
||
else{
|
||
size=tteg->size;
|
||
localtok=tk_struct;
|
||
}
|
||
goto locvar;
|
||
// break;
|
||
}
|
||
default:
|
||
skipfind=LOCAL; //запретить поиск в глобальном и локальном списке
|
||
utestInitVar=TRUE;
|
||
if((i=testInitVar())==FALSE||i==2){ //определение процедуры пока не обрабатываем
|
||
skipfind=FALSE; //разрешить поиск
|
||
FindEndLex();
|
||
datatype_expected();
|
||
nexttok();
|
||
size=0;
|
||
break;
|
||
}
|
||
oflag|=itok.flag;
|
||
npointr=itok.npointr;
|
||
if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
|
||
orm=itok.rm;
|
||
if(tok2==tk_openbracket&&strcmp(itok.name,newteg->name)==0){
|
||
newteg->flag|=fs_constructor;
|
||
oflag|=fs_constructor;
|
||
if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;
|
||
}
|
||
/* if(tok==tk_openbracket){
|
||
if(itok.npointr)orm=am32==FALSE?tk_word:tk_dword;
|
||
npointr=0;
|
||
nexttok();
|
||
while(tok==tk_mult){ //указатель на процедуру
|
||
npointr++;
|
||
nexttok();
|
||
}
|
||
type=pointer;
|
||
}*/
|
||
goto dproc2;
|
||
}
|
||
if(size!=0){
|
||
locvar:
|
||
do{
|
||
tsize=size;
|
||
skipfind=LOCAL; //запретить поиск в глобальном и локальном списке
|
||
nexttok();
|
||
if(tok==tk_colon){
|
||
numt=getsizebit(size);
|
||
if(numt==0)numt=size*8-bitofs%(size*8); //(am32==0?16:32)-bitofs%(am32==0?16:32);
|
||
bitofs+=numt;
|
||
continue;
|
||
}
|
||
dproc2:
|
||
if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg));
|
||
else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+1));
|
||
if(tok!=tk_ID&&tok!=tk_id){
|
||
utestInitVar=TRUE;
|
||
if(testInitVar()==FALSE){ //определение процедуры пока не обрабатываем
|
||
idalreadydefined();
|
||
}
|
||
else{
|
||
oflag|=itok.flag;
|
||
npointr=itok.npointr;
|
||
if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
|
||
if(itok.rm!=tokens)orm=itok.rm;
|
||
if(tok==tk_openbracket){
|
||
if(itok.npointr)orm=am32==FALSE?tk_word:tk_dword;
|
||
npointr=0;
|
||
nexttok();
|
||
while(tok==tk_mult){ //указатель на процедуру
|
||
npointr++;
|
||
nexttok();
|
||
}
|
||
type=pointer;
|
||
}
|
||
for(i=0;i<numel;i++){
|
||
if(strcmp((bazael+i)->name,itok.name)==0)idalreadydefined();
|
||
}
|
||
strcpy((bazael+numel)->name,itok.name);
|
||
if(tok2==tk_openbracket&&strcmp(itok.name,newteg->name)==0){
|
||
newteg->flag|=fs_constructor;
|
||
oflag|=fs_constructor;
|
||
if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;
|
||
}
|
||
nexttok();
|
||
if(tok==tk_openbracket||type==pointer)goto dproc;
|
||
if(npointr){
|
||
idrec *nrec;
|
||
nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
|
||
strcpy(nrec->recid,(bazael+numel)->name);//скопир название
|
||
nrec->newid=NULL;
|
||
nrec->npointr=(unsigned short)npointr;
|
||
nrec->flag=oflag;
|
||
nrec->line=linenumber;
|
||
nrec->file=currentfileinfo;
|
||
nrec->rectok=(bazael+numel)->tok=tk_pointer;
|
||
nrec->type=(unsigned short)orm;
|
||
tsize=2;
|
||
if(am32||(oflag&f_far))tsize=4;
|
||
goto endelteg;
|
||
}
|
||
else unuseableinput();
|
||
}
|
||
}
|
||
else{
|
||
for(i=0;i<numel;i++){
|
||
if(strcmp((bazael+i)->name,itok.name)==0){
|
||
idalreadydefined();
|
||
FindEndLex();
|
||
break;
|
||
}
|
||
}
|
||
strcpy((bazael+numel)->name,itok.name/*(char *)string*/);
|
||
if(tok2==tk_openbracket&&utestInitVar==FALSE){
|
||
if(tok==tk_id)oflag|=(comfile==file_w32?tp_stdcall:tp_pascal); //тип проц по умолчанию
|
||
else oflag=tp_fastcall;
|
||
}
|
||
// printf("tok=%d %s\n",tok,itok.name);
|
||
nexttok();
|
||
if(tok==tk_colon){
|
||
numt=getsizebit(size);
|
||
if(numt==0)preerror("Bit fields must contain at least one bit");
|
||
(bazael+numel)->ofs=ssize;
|
||
(bazael+numel)->tok=tk_bits;
|
||
(bazael+numel)->bit.siz=numt;
|
||
(bazael+numel)->bit.ofs=bitofs;
|
||
if(useunion==FALSE)bitofs+=numt;
|
||
else if(numt>bitsize)bitsize=numt;
|
||
// printf("n=%d size=%d %s\n",numel,numt,(bazael+numel)->name);
|
||
}
|
||
else if(tok==tk_openbracket){
|
||
dproc:
|
||
idrec *nrec;
|
||
param[0]=0;
|
||
if(type==pointer)expecting(tk_closebracket);
|
||
else{
|
||
if(npointr){
|
||
orm=am32==FALSE?tk_word:tk_dword;
|
||
npointr=0;
|
||
}
|
||
}
|
||
skipfind=FALSE; //разрешить поиск
|
||
expecting(tk_openbracket);
|
||
if((oflag&f_typeproc)==tp_fastcall)declareparamreg();
|
||
else declareparamstack();
|
||
skipfind=LOCAL;
|
||
nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
|
||
strcpy(nrec->recid,(bazael+numel)->name);//скопир название
|
||
nrec->newid=NULL;
|
||
// printf("name=%s param=%s\n",nrec->recid,param);
|
||
if(param[0]!=0)nrec->newid=BackString((char *)param);
|
||
if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;//tk_void;
|
||
nrec->npointr=(unsigned short)npointr;
|
||
nrec->recrm=orm;
|
||
nrec->flag=oflag;
|
||
nrec->line=linenumber;
|
||
nrec->file=currentfileinfo;
|
||
nrec->count=0;
|
||
nrec->recpost=0;//itok.post;
|
||
nrec->recsize=0;//itok.size;
|
||
nrec->recsib=(am32==TRUE?CODE32:CODE16);//itok.sib;
|
||
nrec->sbuf=NULL;
|
||
if(npointr){
|
||
nrec->rectok=(bazael+numel)->tok=tk_pointer;
|
||
nrec->type=tk_proc;
|
||
nrec->recsib=am32==FALSE?rm_d16:rm_d32;
|
||
tsize=2;
|
||
if(am32||(oflag&f_far))tsize=4;
|
||
if(bitofs&&(!useunion)){
|
||
ssize+=(bitofs+7)/8;
|
||
bitofs=0;
|
||
}
|
||
tsize=Align(tsize,strpackcur); //new 16.03.05 14:21
|
||
nrec->recnumber=(bazael+numel)->ofs=ssize;
|
||
if(useunion==FALSE)ssize+=tsize;
|
||
else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
|
||
}
|
||
else{
|
||
(bazael+numel)->tok=tk_proc;
|
||
nrec->rectok=tk_declare;
|
||
nrec->type=tp_ucnovn;
|
||
nrec->recsegm=NOT_DYNAMIC;
|
||
(bazael+numel)->ofs=0;
|
||
nrec->recnumber=secondcallnum++;
|
||
nrec->flag|=f_classproc;
|
||
}
|
||
(bazael+numel)->numel=1;
|
||
nexttok();
|
||
if(tok==tk_openbracket)IsUses(nrec);
|
||
// printf("name=%s post=%08X\n",nrec->recid,nrec->recpost);
|
||
}
|
||
else{
|
||
(bazael+numel)->rec=NULL;
|
||
(bazael+numel)->tok=localtok;
|
||
endelteg:
|
||
if(bitofs&&(!useunion)){
|
||
ssize+=(bitofs+7)/8;
|
||
bitofs=0;
|
||
}
|
||
(bazael+numel)->ofs=ssize;
|
||
numt=1;
|
||
if(tok==tk_openblock){//[
|
||
skipfind=FALSE;
|
||
nexttok();
|
||
numt=doconstlongmath();
|
||
expecting(tk_closeblock);
|
||
skipfind=LOCAL;
|
||
}
|
||
(bazael+numel)->numel=numt;
|
||
// printf("%d: unionsize=%d elemsize=%d\n",numel,unionsize,tsize*numt);
|
||
if((oflag&f_static)){
|
||
idrec *nrec;
|
||
nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
|
||
strcpy(nrec->recid,(bazael+numel)->name);//скопир название
|
||
nrec->line=linenumber;
|
||
nrec->file=currentfileinfo;
|
||
nrec->count=0;
|
||
nrec->sbuf=NULL;
|
||
nrec->recsize=tsize*numt;
|
||
nrec->recsegm=DS;
|
||
if(localtok==tk_struct){
|
||
nrec->recsib=0;
|
||
nrec->newid=(char *)tteg;
|
||
(bazael+numel)->tok=nrec->rectok=tk_structvar;
|
||
nrec->flag=/*flag|*/tteg->flag;
|
||
if(FixUp)nrec->flag|=f_reloc;
|
||
nrec->recrm=numt;
|
||
}
|
||
else{
|
||
nrec->newid=NULL;
|
||
nrec->npointr=(unsigned short)npointr;
|
||
nrec->recrm=(am32==FALSE?rm_d16:rm_d32);
|
||
if(FixUp)oflag|=f_reloc;
|
||
nrec->flag=oflag;
|
||
nrec->recsib=(am32==TRUE?CODE32:CODE16);//itok.sib;
|
||
nrec->rectok=localtok;
|
||
nrec->type=tp_ucnovn;
|
||
}
|
||
if(tok==tk_assign){
|
||
skipfind=FALSE; //разрешить поиск
|
||
nrec->recpost=0;
|
||
if(localtok==tk_struct){
|
||
if(alignword)alignersize+=AlignCD(DS,2); //выровнять
|
||
nrec->recnumber=outptrdata; //адрес начала структуры
|
||
i=initstructvar(tteg,numt);
|
||
if(numt==0){
|
||
numt=i/tteg->size;
|
||
if((i%tteg->size)!=0){
|
||
numt++;
|
||
i=tteg->size-(i%tteg->size);
|
||
for(;i!=0;i--)opd(0);
|
||
i=numt*tteg->size;
|
||
}
|
||
nrec->recrm=numel;
|
||
nrec->recsize=i;
|
||
}
|
||
datasize+=i;
|
||
}
|
||
else{
|
||
if(alignword)alignersize+=AlignCD(DS,tsize);
|
||
nrec->recnumber=outptrdata;
|
||
initglobalvar(orm,numt,tsize,variable);
|
||
datasize+=tsize*numt;
|
||
}
|
||
}
|
||
else{
|
||
nrec->recpost=1;
|
||
if(localtok==tk_struct){
|
||
if(numt==0){
|
||
ZeroMassiv();
|
||
break;
|
||
}
|
||
}
|
||
if(alignword){ //выровнять на четный адрес
|
||
if(postsize%2==1)postsize++;
|
||
if(tsize==4&&postsize%4!=0)postsize+=2;
|
||
}
|
||
nrec->recnumber=postsize;
|
||
AddPostData(numt*tteg->size);
|
||
}
|
||
}
|
||
else{
|
||
tsize=Align(tsize*numt,strpackcur); //new 16.03.05 14:21
|
||
if(useunion==FALSE)ssize+=tsize;
|
||
else if(unionsize<(unsigned int)tsize)unionsize=tsize;
|
||
if(localtok==tk_struct)(bazael+numel)->nteg=tteg;
|
||
}
|
||
}
|
||
if(useunion)bitofs=0;
|
||
numel++;
|
||
}
|
||
newteg->size=ssize+unionsize;
|
||
}while(tok==tk_camma);
|
||
skipfind=FALSE; //разрешить поиск
|
||
seminext();
|
||
}
|
||
};//while(tok!=tk_closebrace&&tok!=tk_eof);
|
||
if(bitofs&&useunion==FALSE)ssize+=(bitofs+7)/8;
|
||
else if(bitsize&&((unsigned int)((bitsize+7)/8)>unionsize))unionsize=(bitsize+7)/8;
|
||
// printf("bitofs=%d size=%d\n",bitofs,ssize);
|
||
if(isdestr==FALSE&&isbase>1){
|
||
char *buf=(char *)MALLOC(16);
|
||
strcpy(buf,"(){");
|
||
int j;
|
||
for(i=0,j=0;i<isbase;i++){
|
||
if(GetFirstDestr((structteg *)(bazael+i)->nteg))j++;
|
||
}
|
||
if(j>1){
|
||
strcat(buf,"};");
|
||
int oflag,oinptr2;
|
||
char ocha2;
|
||
int oldendinptr=endinptr;
|
||
char *oinput;
|
||
idrec *nrec;
|
||
oinptr2=inptr2;
|
||
ocha2=cha2;
|
||
oinput=(char*)input;
|
||
string[0]=0;
|
||
newteg->flag|=fs_destructor;
|
||
strcpy(itok.name,newteg->name);
|
||
if(CidOrID()==tk_ID)oflag=tp_fastcall;
|
||
else oflag=(comfile==file_w32?tp_stdcall:tp_pascal);
|
||
bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+1));
|
||
strcpy((bazael+numel)->name,itok.name);
|
||
strcat((bazael+numel)->name,"~");
|
||
itok.rec=nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
|
||
strcpy(nrec->recid,itok.name);//скопир название
|
||
nrec->newid=NULL;
|
||
itok.npointr=nrec->npointr=0;
|
||
itok.rm=nrec->recrm=tk_void;
|
||
itok.flag=nrec->flag=fs_destructor|oflag|f_classproc;
|
||
nrec->line=linenumber;
|
||
nrec->file=currentfileinfo;
|
||
nrec->count=0;
|
||
itok.post=nrec->recpost=0;
|
||
itok.size=nrec->recsize=0;
|
||
itok.sib=nrec->recsib=(am32==TRUE?CODE32:CODE16);
|
||
nrec->sbuf=NULL;
|
||
(bazael+numel)->tok=tk_proc;
|
||
tok=nrec->rectok=tk_declare;
|
||
itok.type=nrec->type=tp_ucnovn;
|
||
itok.segm=nrec->recsegm=NOT_DYNAMIC;
|
||
(bazael+numel)->ofs=0;
|
||
itok.number=nrec->recnumber=secondcallnum++;
|
||
(bazael+numel)->numel=1;
|
||
numel++;
|
||
input=(unsigned char*)buf;
|
||
inptr2=1;
|
||
cha2='(';
|
||
endinptr=strlen(buf);
|
||
searchteg=newteg;
|
||
dynamic_proc();
|
||
searchteg=NULL;
|
||
input=(unsigned char*)oinput;
|
||
inptr2=oinptr2;
|
||
cha2=ocha2;
|
||
endinptr=oldendinptr;
|
||
}
|
||
free(buf);
|
||
}
|
||
newteg->size=ssize+unionsize;
|
||
newteg->numoper=numel;
|
||
newteg->baza=bazael;
|
||
nexttok();
|
||
if(noname==FALSE&&nameid==FALSE){
|
||
if(tok==tk_ID||tok==tk_id){
|
||
strcpy(newteg->name,itok.name);
|
||
AddTegToTree(newteg,Global);
|
||
}
|
||
else{
|
||
notstructname();
|
||
if(newteg->baza)free(newteg->baza);
|
||
free(newteg);
|
||
newteg=NULL;
|
||
}
|
||
}
|
||
return newteg;
|
||
}
|
||
|
||
struct structteg * FindTeg(int Global,char *name) //найти тег
|
||
{
|
||
struct structteg *tteg;
|
||
int i;
|
||
char *tn;
|
||
if((tn=strchr(name,'@'))!=NULL)*tn=0;
|
||
tteg=(Global==TRUE?tegtree:ltegtree);
|
||
while(tteg&&(i=strcmp(tteg->name,name))!=0)tteg=(i<0?tteg->left:tteg->right);
|
||
return tteg;
|
||
}
|
||
|
||
unsigned int SaveVal(unsigned long long val,int type)
|
||
{
|
||
unsigned int loop=0;
|
||
switch(type){
|
||
case tk_bytevar:
|
||
case tk_charvar:
|
||
opd(val);
|
||
break;
|
||
case tk_wordvar:
|
||
case tk_intvar:
|
||
outwordd(val);
|
||
loop++;
|
||
break;
|
||
case tk_dwordvar:
|
||
case tk_longvar:
|
||
case tk_floatvar:
|
||
outdwordd(val);
|
||
loop+=3;
|
||
break;
|
||
case tk_qwordvar:
|
||
case tk_doublevar:
|
||
outqwordd(val);
|
||
loop+=7;
|
||
break;
|
||
case tk_pointer:
|
||
if(am32){
|
||
outdwordd(val);
|
||
loop+=3;
|
||
}
|
||
else{
|
||
outwordd(val);
|
||
loop++;
|
||
}
|
||
break;
|
||
case tk_proc:
|
||
loop--;
|
||
break;
|
||
default: internalerror("Bad type variable");
|
||
}
|
||
return loop;
|
||
}
|
||
|
||
void FillTeg(unsigned long long val,unsigned int numel,struct structteg *tteg)
|
||
/*-----------------03.10.99 00:20-------------------
|
||
заполнить структуру одинаковыми величинами
|
||
--------------------------------------------------*/
|
||
{
|
||
struct elementteg *elem=tteg->baza;
|
||
int bitofs=0;
|
||
unsigned int startstruct;
|
||
if(dbg&2)AddDataLine(1/*,variable*/);
|
||
for(unsigned int j=0;j<numel;j++){
|
||
startstruct=outptrdata;
|
||
for(unsigned int c=0;c<tteg->numoper;c++){
|
||
if((elem+c)->ofs)outptrdata=startstruct+(elem+c)->ofs;
|
||
if(splitdata==FALSE)outptr=outptrdata;
|
||
int type=(elem+c)->tok;
|
||
if(type==tk_bits){
|
||
opb(val,(elem+c)->bit.ofs,(elem+c)->bit.siz);
|
||
bitofs=(elem+c)->bit.ofs+(elem+c)->bit.siz;
|
||
}
|
||
else{
|
||
if(bitofs){
|
||
CorrectOfsBit(bitofs);
|
||
bitofs=0;
|
||
}
|
||
for(unsigned int i=0;i<(elem+c)->numel;i++){
|
||
if(type==tk_struct||type==tk_baseclass){
|
||
FillTeg(val,(elem+c)->numel,(struct structteg *)(elem+c)->nteg);
|
||
break;
|
||
}
|
||
SaveVal(val,type);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if(bitofs)CorrectOfsBit(bitofs);
|
||
}
|
||
|
||
unsigned int Fill2Teg(unsigned int numel,struct structteg *tteg)
|
||
/*-----------------03.10.99 00:20-------------------
|
||
заполнить структуру величинами
|
||
--------------------------------------------------*/
|
||
{
|
||
unsigned long long hold;
|
||
struct elementteg *elem=tteg->baza;
|
||
unsigned int tnumel=0; //номер елемента одного типа
|
||
unsigned int ttype=0; //номер элемента структуры
|
||
unsigned int nums=0; //номер копии структуры
|
||
unsigned int loop=0; //заполненый размер
|
||
int type=tokens;
|
||
int bitofs=0;
|
||
unsigned int startstruct=outptrdata;
|
||
scanalltoks=FALSE;
|
||
for(;;){
|
||
hold=0;
|
||
if(tnumel==(elem+ttype)->numel||type==tk_bits){
|
||
tnumel=0;
|
||
ttype++;
|
||
if(ttype==tteg->numoper){
|
||
ttype=0;
|
||
nums++;
|
||
startstruct=outptrdata;
|
||
if(nums==numel){
|
||
scanalltoks=TRUE;
|
||
return loop;
|
||
}
|
||
}
|
||
loop=(elem+ttype)->ofs;
|
||
outptrdata=startstruct+loop;
|
||
if(splitdata==FALSE)outptr=outptrdata;
|
||
loop+=tteg->size*nums;
|
||
}
|
||
tnumel++;
|
||
type=(elem+ttype)->tok;
|
||
// puts((elem+ttype)->name);
|
||
if(type==tk_struct||type==tk_baseclass){
|
||
tnumel=(elem+ttype)->numel;
|
||
loop+=Fill2Teg((elem+ttype)->numel,(struct structteg *)(elem+ttype)->nteg);
|
||
if(tok==tk_closebrace)break;
|
||
continue;
|
||
}
|
||
if(type==tk_proc)continue;
|
||
if((elem+ttype)->rec&&((elem+ttype)->rec->flag&f_static))continue;
|
||
if(dbg&2)AddDataLine((char)GetVarSize(type)/*,variable*/);
|
||
loopsw:
|
||
int htok=tok;
|
||
// printf("tok=%d\n",tok);
|
||
switch(tok){
|
||
case tk_camma:
|
||
hold=0;
|
||
goto strl3;
|
||
case tk_postnumber:
|
||
(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
|
||
itok.flag=0;
|
||
// goto strl1;
|
||
case tk_undefofs:
|
||
// AddUndefOff(1,itok.name);
|
||
//strl1:
|
||
tok=tk_number;
|
||
if(htok==tk_undefofs)AddUndefOff(3,itok.name);
|
||
hold+=doconstdwordmath();
|
||
if(tok==tk_plus&&tok2==tk_postnumber&&htok!=tk_undefofs){
|
||
nexttok();
|
||
goto loopsw;
|
||
}
|
||
goto strl2;
|
||
case tk_minus:
|
||
case tk_number:
|
||
if(type==tk_bytevar||type==tk_wordvar||type==tk_dwordvar||type==tk_bits||type==tk_pointer){
|
||
hold=doconstdwordmath();
|
||
}
|
||
else if(type==tk_charvar||type==tk_intvar||type==tk_longvar){
|
||
hold=doconstlongmath();
|
||
}
|
||
else if(type==tk_floatvar)hold=doconstfloatmath();
|
||
else if(type==tk_doublevar)hold=doconstdoublemath();
|
||
else if(type==tk_qwordvar)hold=doconstqwordmath();
|
||
// printf("tok=%d num=%08X\n",tok,hold);
|
||
strl2:
|
||
if((postnumflag&f_reloc)!=0)AddReloc();
|
||
strl3:
|
||
if(type==tk_bits){
|
||
opb(hold,(elem+ttype)->bit.ofs,(elem+ttype)->bit.siz);
|
||
bitofs=(elem+ttype)->bit.ofs+(elem+ttype)->bit.siz;
|
||
}
|
||
else{
|
||
if(bitofs){
|
||
CorrectOfsBit(bitofs);
|
||
loop+=(bitofs+7)/8;
|
||
bitofs=0;
|
||
}
|
||
loop+=SaveVal(hold,type);
|
||
}
|
||
break;
|
||
case tk_string:
|
||
if(type==tk_bytevar||type==tk_charvar){
|
||
unsigned int i;
|
||
if((unsigned int)itok.number<(elem+ttype)->numel)i=itok.number;
|
||
else i=(elem+ttype)->numel;
|
||
tnumel=0;
|
||
for(;tnumel<i;tnumel++){
|
||
opd(string[tnumel]);
|
||
}
|
||
if(tnumel<(elem+ttype)->numel){
|
||
switch(itok.flag&3){
|
||
case zero_term:
|
||
if(itok.flag&s_unicod)opd(0);
|
||
opd(0);
|
||
tnumel++;
|
||
break;
|
||
case dos_term:
|
||
if(itok.flag&s_unicod)opd(0);
|
||
opd('$');
|
||
tnumel++;
|
||
break;
|
||
}
|
||
while(tnumel<(elem+ttype)->numel){
|
||
opd(aligner);
|
||
tnumel++;
|
||
}
|
||
}
|
||
loop+=tnumel-1;
|
||
nexttok();
|
||
break;
|
||
}
|
||
if(am32==FALSE){
|
||
outwordd(addpoststring());
|
||
if(type==tk_longvar||type==tk_dwordvar){
|
||
loop+=2;
|
||
outword(0);
|
||
}
|
||
loop++;
|
||
}
|
||
else{
|
||
if(type==tk_intvar||type==tk_wordvar)dwordvalexpected();
|
||
outdwordd(addpoststring());
|
||
loop+=3;
|
||
}
|
||
nexttok();
|
||
break;
|
||
default:
|
||
numexpected();
|
||
nexttok();
|
||
break;
|
||
}
|
||
loop++;
|
||
if(tok==tk_closebrace)break;
|
||
// printf("tok=%d\n",tok);
|
||
expecting(tk_camma);
|
||
}
|
||
scanalltoks=TRUE;
|
||
if(bitofs){
|
||
CorrectOfsBit(bitofs);
|
||
loop+=(bitofs+7)/8;
|
||
}
|
||
return loop;
|
||
}
|
||
|
||
unsigned int initstructvar(structteg *tteg,int numel)
|
||
{
|
||
unsigned int loop=0;
|
||
nexttok();
|
||
switch(tok){ //заполнить величинами
|
||
case tk_minus:
|
||
case tk_number:
|
||
if(numel==0)ZeroMassiv();
|
||
FillTeg(doconstqwordmath(),numel,tteg);
|
||
loop=numel*tteg->size;
|
||
break;
|
||
case tk_from: //считать файл с данными
|
||
nexttok();
|
||
loop=dofrom();
|
||
for(;loop<tteg->size*numel;loop++)opd(aligner);
|
||
nexttok();
|
||
break;
|
||
case tk_extract: //считать фрагмент файла с данными
|
||
nexttok();
|
||
loop=doextract();
|
||
for(;loop<tteg->size*numel;loop++)opd(aligner);
|
||
break;
|
||
case tk_openbrace: //массив данных
|
||
nexttok();
|
||
loop=Fill2Teg(numel,tteg);
|
||
for(;loop<tteg->size*numel;loop++)opd(aligner);
|
||
if(tok!=tk_closebrace){
|
||
preerror("extra parameter at initialization of structure");
|
||
while(tok!=tk_closebrace&&tok!=tk_eof)nexttok();
|
||
}
|
||
nexttok();
|
||
break;
|
||
default:
|
||
// printf("tok=%d\n",tok);
|
||
numexpected(); nexttok(); break;
|
||
}
|
||
return loop;
|
||
}
|
||
|
||
void InitStruct2(unsigned int flag,structteg *tteg) //инициализировать глобальную структуру
|
||
{
|
||
struct idrec *newrec=NULL,*ptr;
|
||
int numel,count;
|
||
char done=0,dynamic;
|
||
unsigned int loop;
|
||
while(tok!=tk_eof&&done==0){
|
||
loop=0;
|
||
// printf("3 tok=%d %s\n",tok,itok.name);
|
||
switch(tok){
|
||
case tk_id:
|
||
case tk_ID: //инициализировать структуру
|
||
//выделить память под новую структ
|
||
newrec=(struct idrec *)MALLOC(sizeof(struct idrec));
|
||
|
||
// if(strcmp(itok.name,"ccchrg")==0)printf("rec=%08X teg=%08X size=%X %s\n",newrec,tteg,sizeof(idrec),itok.name);
|
||
|
||
ptr=((flag&f_static)==0?treestart:staticlist); //начало дерева
|
||
if(ptr==NULL)((flag&f_static)==0?treestart:staticlist)=newrec;//начало дерева
|
||
else{ //поиск строки в дереве
|
||
while(((numel=strcmp(ptr->recid,itok.name))<0&&ptr->left!=NULL)||(numel>0&&ptr->right!=NULL)){
|
||
ptr=(numel<0?ptr->left:ptr->right);
|
||
}
|
||
(numel<0?ptr->left:ptr->right)=newrec; //строка меньше
|
||
}
|
||
newrec->recsib=0;
|
||
strcpy(newrec->recid,itok.name);//скопир название
|
||
newrec->newid=(char *)tteg;
|
||
newrec->left=NULL;
|
||
newrec->right=NULL;
|
||
newrec->rectok=tk_structvar;
|
||
newrec->flag=flag|tteg->flag;
|
||
newrec->line=linenumber;
|
||
newrec->file=currentfileinfo;
|
||
newrec->type=tp_gvar;
|
||
if(FixUp)newrec->flag|=f_reloc;
|
||
numel=1;
|
||
nexttok();
|
||
if(tok==tk_openblock){//[
|
||
nexttok();
|
||
if(tok!=tk_closeblock)numel=doconstlongmath(); //число элементов
|
||
else numel=0;
|
||
expecting(tk_closeblock);//]
|
||
}
|
||
newrec->recrm=numel;
|
||
newrec->recsize=numel*tteg->size;
|
||
dynamic=FALSE;
|
||
if(tok==tk_assign||notpost==TRUE){//=
|
||
if(useStartup==TRUE&&tok!=tk_assign&&numel!=0){
|
||
if(SaveStruct(numel*tteg->size,newrec)==TRUE)break;
|
||
}
|
||
if(alignword&&(!dynamic_flag))alignersize+=AlignCD(DS,2); //выровнять
|
||
// NotPostUnion();
|
||
itok.rec=newrec;
|
||
if((count=FindOff((unsigned char *)newrec->recid,DS))==0){
|
||
if(dynamic_flag)dynamic=DYNAMIC_VAR;
|
||
}
|
||
else if(dynamic_flag)dynamic=USED_DIN_VAR;
|
||
newrec->recnumber=(dynamic==0?outptrdata:0); //адрес начала структуры
|
||
newrec->recpost=dynamic;
|
||
if(notpost==TRUE&&tok!=tk_assign){
|
||
if(numel==0)ZeroMassiv();
|
||
for(;loop<tteg->size*numel;loop++)opd(aligner);
|
||
datasize+=loop;
|
||
break;
|
||
}
|
||
if(dynamic)newrec->sbuf=dynamic_var();
|
||
else{
|
||
loop=initstructvar(tteg,numel);
|
||
if(numel==0){
|
||
numel=loop/tteg->size;
|
||
if((loop%tteg->size)!=0){
|
||
numel++;
|
||
int i=tteg->size-(loop%tteg->size);
|
||
for(;i!=0;i--)opd(0);
|
||
loop=numel*tteg->size;
|
||
}
|
||
newrec->recrm=numel;
|
||
newrec->recsize=loop;
|
||
}
|
||
datasize+=loop;
|
||
}
|
||
}
|
||
else{
|
||
if(numel==0){
|
||
ZeroMassiv();
|
||
break;
|
||
}
|
||
if(CheckUseAsUndef((unsigned char *)newrec->recid)==0&&dynamic_flag)dynamic=TRUE;
|
||
switch(tok){ //неинициализированные
|
||
default: expected(';');
|
||
case tk_semicolon: done=1;// ;
|
||
case tk_camma: //, post global type
|
||
// long longpostsize;
|
||
if(useStartup==TRUE){
|
||
if(SaveStruct(numel*tteg->size,newrec)==TRUE){
|
||
nexttok();
|
||
break;
|
||
}
|
||
}
|
||
newrec->recpost=dynamic+1;
|
||
loop=numel*tteg->size;
|
||
if((flag&f_extern)==0&&dynamic==0){
|
||
if(alignword){ //выровнять на четный адрес
|
||
if(postsize%2==1)postsize++;
|
||
}
|
||
newrec->recnumber=postsize;
|
||
}
|
||
else newrec->recnumber=externnum++;
|
||
count=FindOff((unsigned char *)newrec->recid,VARPOST);
|
||
if((flag&f_extern)==0&&dynamic==0)
|
||
/*-----------------10.09.02 23:21-------------------
|
||
этот вызов должен быть после FindOff
|
||
--------------------------------------------------*/
|
||
AddPostData(loop);
|
||
nexttok();
|
||
break;
|
||
}
|
||
}
|
||
newrec->count=count;
|
||
break;
|
||
case tk_proc:
|
||
case tk_qwordvar:
|
||
case tk_doublevar:
|
||
case tk_floatvar:
|
||
case tk_dwordvar:
|
||
case tk_longvar:
|
||
case tk_charvar:
|
||
case tk_intvar:
|
||
case tk_bytevar:
|
||
case tk_wordvar: idalreadydefined(); nexttok(); break;
|
||
default:
|
||
if(newrec)expected(';');
|
||
else errstruct();
|
||
FindStopTok();
|
||
case tk_semicolon: done=1;
|
||
case tk_camma: nexttok(); break;
|
||
}
|
||
}
|
||
dopoststrings();
|
||
}
|
||
|
||
void InitStruct() //инициализировать глобальную структуру
|
||
{
|
||
struct structteg *tteg;
|
||
unsigned int flag;
|
||
//if(debug)puts("start init struct");
|
||
flag=itok.flag;
|
||
if(fstatic){
|
||
flag|=f_static;
|
||
fstatic=FALSE;
|
||
}
|
||
if(tok==tk_struct)nexttok();
|
||
else if(tok2!=tk_id&&tok2!=tk_ID){
|
||
if(tok2==tk_dblcolon){
|
||
itok.flag=f_classproc;
|
||
itok.rm=am32==FALSE?tk_word:tk_dword;//tk_void;
|
||
itok.npointr=0;
|
||
doclassproc(0/*comfile==file_w32?tk_stdcall:tk_pascal 18.10.05 10:52*/);
|
||
return;
|
||
}
|
||
notstructname();
|
||
}
|
||
tteg=FindTeg(TRUE);
|
||
if(tteg==NULL){
|
||
if(tok==tk_openbrace||tok2==tk_openbrace||tok==tk_colon||tok2==tk_colon)
|
||
tteg=CreatTeg(TRUE); //найти или создать тег
|
||
else{
|
||
while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
|
||
tegnotfound();
|
||
return;
|
||
}
|
||
}
|
||
else{
|
||
if(tok2==tk_openbrace)idalreadydefined();
|
||
nexttok();
|
||
}
|
||
InitStruct2(flag,tteg);
|
||
}
|
||
|
||
unsigned long LocalStruct2(int flag,int *localline,int binptr,char bcha,structteg *tteg) //инициализировать локальную структуру
|
||
{
|
||
int numel,first=FALSE;
|
||
struct localrec *newrec;
|
||
unsigned long size=0;
|
||
skipfind=TRUE; //запретить искать в глобальном дереве
|
||
do{
|
||
if(first!=FALSE){
|
||
binptr=inptr2;
|
||
bcha=cha2;
|
||
nexttok();
|
||
}
|
||
first=TRUE;
|
||
if(tok!=tk_ID&&tok!=tk_id)idalreadydefined();
|
||
else{ //инициализировать структуру
|
||
numel=1;
|
||
newrec=addlocalvar((char *)string,tk_structvar,localsize);
|
||
newrec->rec.newid=(char *)tteg;
|
||
newrec->rec.flag=tteg->flag;
|
||
newrec->rec.type=tp_localvar;
|
||
nexttok();
|
||
if(tok==tk_openblock){//[
|
||
skipfind=FALSE;
|
||
nexttok();
|
||
numel=doconstlongmath(); //число элементов
|
||
skipfind=TRUE;
|
||
expecting(tk_closeblock);//]
|
||
}
|
||
newrec->rec.recrm=numel;
|
||
size=numel*tteg->size;
|
||
newrec->rec.recsize=size;
|
||
if(flag&f_static){
|
||
// if(bcha==0)not_union_static();
|
||
if(tok==tk_assign){
|
||
// newrec->rec.rectok=tk_structvar;
|
||
newrec->rec.recnumber=0;
|
||
newrec->rec.recpost=DYNAMIC_VAR;
|
||
// newrec->rec.recsize=tteg->size;
|
||
// newrec->rec.recrm=numel;
|
||
newrec->rec.line=linenumber;
|
||
newrec->rec.file=currentfileinfo;
|
||
newrec->rec.npointr=0;
|
||
newrec->rec.sbuf=dynamic_var();
|
||
newrec->rec.recsib=newrec->rec.type=tp_gvar;
|
||
}
|
||
else{
|
||
newrec->rec.recpost=TRUE;
|
||
if(alignword){ //выровнять на четный адрес
|
||
if(postsize%2==1)postsize++;
|
||
}
|
||
newrec->rec.recnumber=postsize;
|
||
AddPostData(size);
|
||
}
|
||
size=0;
|
||
}
|
||
else{
|
||
size=Align(size,(am32==FALSE?2:4));
|
||
newrec->rec.recpost=LOCAL;
|
||
newrec->rec.recnumber=-localsize-size;
|
||
// localsize+=size;
|
||
if(tok==tk_assign){
|
||
if(*localline==0)*localline=linenumber;
|
||
AddBackBuf(binptr,bcha);
|
||
}
|
||
}
|
||
}
|
||
localsize+=size;
|
||
}while(tok==tk_camma);
|
||
skipfind=FALSE; //запретить искать в глобальном дереве
|
||
// localsize+=size;
|
||
itok.name[0]=0;
|
||
seminext();
|
||
return size;
|
||
}
|
||
|
||
unsigned long LocalStruct(int flag,int *localline) //инициализировать локальную структуру
|
||
{
|
||
struct structteg *tteg;
|
||
int binptr;
|
||
char bcha;
|
||
structteg *osearchteg;
|
||
osearchteg=searchteg;
|
||
searchteg=NULL;
|
||
skipfind=TRUE; //запретить искать в глобальном дереве
|
||
if(tok==tk_struct)nexttok();
|
||
binptr=inptr2;
|
||
bcha=cha2;
|
||
if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
|
||
skipfind=FALSE;
|
||
if(tok==tk_openbrace||tok2==tk_openbrace){
|
||
tteg=CreatTeg(FALSE); //найти или создать тег
|
||
}
|
||
else{
|
||
while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
|
||
tegnotfound();
|
||
searchteg=osearchteg;
|
||
return 0;
|
||
}
|
||
}
|
||
else{
|
||
searchteg=osearchteg;
|
||
if(tok2==tk_openbrace){
|
||
idalreadydefined();
|
||
SkipBlock2();
|
||
return 0;
|
||
}
|
||
nexttok();
|
||
if(tok!=tk_id&&tok!=tk_ID){
|
||
notstructname();
|
||
FindStopTok();
|
||
return 0;
|
||
}
|
||
}
|
||
searchteg=osearchteg;
|
||
return LocalStruct2(flag,localline,binptr,bcha,tteg);
|
||
}
|
||
|
||
void dostruct()
|
||
{
|
||
struct structteg *tteg;
|
||
int numel;
|
||
int usenumstr;
|
||
SINFO rstr;
|
||
char *ofsst=NULL;
|
||
int oneloop=FALSE;
|
||
unsigned long hnum;
|
||
unsigned int num,sized=0,sign=FALSE;
|
||
unsigned long adr;
|
||
int localstr=FALSE;
|
||
int poststr;
|
||
int flagstr;
|
||
struct idrec *ptrs;
|
||
if(tok2==tk_assign){
|
||
switch(ScanTok3()){
|
||
case tk_proc:
|
||
case tk_apiproc:
|
||
case tk_undefproc:
|
||
case tk_declare:
|
||
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;
|
||
}
|
||
itok.sib=(am32==FALSE?CODE16:CODE32);
|
||
itok.flag=ptrs->flag;
|
||
switch(itok.size){
|
||
case 1:
|
||
tok=tk_bytevar;
|
||
dobytevar(0);
|
||
break;
|
||
case 2:
|
||
case 3:
|
||
tok=tk_wordvar;
|
||
do_d_wordvar(0,r16);
|
||
break;
|
||
case 4:
|
||
case 5:
|
||
case 6:
|
||
case 7:
|
||
tok=tk_dwordvar;
|
||
do_d_wordvar(0,r32);
|
||
break;
|
||
default:
|
||
tok=tk_qwordvar;
|
||
doqwordvar();
|
||
break;
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
adr=itok.number;
|
||
numel=itok.rm; //число структур
|
||
usenumstr=itok.post; //было указание номера структуры
|
||
if(itok.type==tp_classvar){
|
||
tteg=(structteg *)itok.rec;
|
||
poststr=0;
|
||
flagstr=f_useidx;
|
||
}
|
||
else{
|
||
ptrs=itok.rec;
|
||
tteg=(structteg *)ptrs->newid;
|
||
if(ptrs->recpost==LOCAL)localstr=TRUE;
|
||
poststr=ptrs->recpost;
|
||
flagstr=ptrs->flag;
|
||
}
|
||
rstr=strinf;
|
||
strinf.bufstr=NULL;
|
||
num=itok.size;
|
||
// if(bufrm)printf("num=%d %s\n",adr,bufrm);
|
||
nexttok();
|
||
if(tok==tk_assign){
|
||
getoperand();
|
||
int starts=0; //смещение заполнения в структуре
|
||
if(tok==tk_int||tok==tk_word){
|
||
sized=2;
|
||
getoperand();
|
||
}
|
||
else if(tok==tk_long||tok==tk_dword){
|
||
sized=4;
|
||
getoperand();
|
||
}
|
||
else if(tok==tk_char||tok==tk_byte){
|
||
sized=1;
|
||
getoperand();
|
||
}
|
||
switch(tok){
|
||
case tk_charvar:
|
||
case tk_bytevar:
|
||
case tk_intvar:
|
||
case tk_wordvar:
|
||
case tk_longvar:
|
||
case tk_dwordvar:
|
||
int razr,retreg;
|
||
ITOK wtok;
|
||
char *wbuf;
|
||
wbuf=bufrm;
|
||
bufrm=NULL;
|
||
wtok=itok;
|
||
SINFO wstr;
|
||
wstr=strinf;
|
||
strinf.bufstr=NULL;
|
||
if((retreg=CheckIDZReg(itok.name,AX,razr=GetVarSize(tok)))!=NOINREG){
|
||
GenRegToReg(AX,retreg,razr);
|
||
IDZToReg(itok.name,AX,razr);
|
||
if(bufrm){
|
||
free(bufrm);
|
||
bufrm=NULL;
|
||
}
|
||
if(strinf.bufstr){
|
||
free(strinf.bufstr);
|
||
strinf.bufstr=NULL;
|
||
}
|
||
if(sized){
|
||
switch(razr){
|
||
case r8: tok=tk_beg; break;
|
||
case r16: tok=tk_reg; break;
|
||
case r32: tok=tk_reg32; break;
|
||
}
|
||
itok.number=0;
|
||
goto convr;
|
||
}
|
||
break;
|
||
}
|
||
IDZToReg(itok.name,AX,razr);
|
||
if(sized==0){
|
||
switch(tok){
|
||
case tk_charvar:
|
||
case tk_bytevar:
|
||
getintoal(tok,&wtok,wbuf,&wstr);
|
||
sized=1;
|
||
break;
|
||
case tk_intvar:
|
||
sign=TRUE;
|
||
case tk_wordvar:
|
||
getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,r16);
|
||
sized=2;
|
||
break;
|
||
case tk_longvar:
|
||
sign=TRUE;
|
||
case tk_dwordvar:
|
||
getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,r32);
|
||
sized=4;
|
||
break;
|
||
}
|
||
}
|
||
else{
|
||
convr:
|
||
switch(sized){
|
||
case 1:
|
||
getintoal(tok,&wtok,wbuf,&wstr);
|
||
break;
|
||
case 2:
|
||
getinto_e_ax(0,tok,&wtok,wbuf,&wstr,r16);
|
||
break;
|
||
case 4:
|
||
getinto_e_ax(0,tok,&wtok,wbuf,&wstr,r32);
|
||
break;
|
||
}
|
||
}
|
||
if(usenumstr!=FALSE){
|
||
// num/=ptrs->recrm; //указан номер структуры - значит не все
|
||
num=tteg->size;
|
||
if(strinf.bufstr==NULL)starts=num*numel;
|
||
}
|
||
num/=sized;
|
||
goto fillstr;
|
||
case tk_minus:
|
||
nexttok();
|
||
if(tok!=tk_number){
|
||
errstruct();
|
||
break;
|
||
}
|
||
itok.number=-itok.number;
|
||
case tk_number:
|
||
if(sized==0){
|
||
sized=4;
|
||
if(itok.number<65536)sized=2;
|
||
if(itok.number<256)sized=1;
|
||
}
|
||
if(usenumstr!=FALSE){
|
||
// num/=ptrs->recrm; //указан номер структуры - значит не все
|
||
num=tteg->size;
|
||
if(strinf.bufstr==NULL)starts=num*numel;
|
||
}
|
||
if(strinf.bufstr==NULL){
|
||
if(optimizespeed==TRUE){
|
||
if(sized==1&&(num%2)==0){
|
||
sized=2;
|
||
itok.number=(itok.number&255)|((itok.number<<8)&0xFF00);
|
||
}
|
||
if(chip>2&&sized==2&&(num%4)==0){
|
||
sized=4;
|
||
itok.number=(itok.number&0xFFFF)|(itok.number<<16);
|
||
}
|
||
}
|
||
else{
|
||
if(am32==FALSE){
|
||
if(sized==1&&((num<7&&(num%2)==0)||(itok.number==0&&num==8))){
|
||
sized=2;
|
||
itok.number=(itok.number&255)|((itok.number<<8)&0xFF00);
|
||
}
|
||
}
|
||
else if(chip>2&&sized!=4&&(num%4)==0&&itok.number==0)sized=4;
|
||
}
|
||
}
|
||
num/=sized;
|
||
if(num==1){
|
||
oneloop++;
|
||
hnum=itok.number;
|
||
}
|
||
else if(num==2&&sized==2&&chip>2){
|
||
oneloop++;
|
||
hnum=(itok.number&0xFFFF)|(itok.number<<16);
|
||
sized=4;
|
||
num=1;
|
||
}
|
||
else if(num==4&&sized==1&&chip>2){
|
||
oneloop++;
|
||
itok.number&=255;
|
||
hnum=itok.number|(itok.number<<8)|(itok.number<<16)|(itok.number<<24);
|
||
sized=4;
|
||
num=1;
|
||
}
|
||
else{
|
||
if(sized==1){
|
||
if(itok.number==0)outword(0x00B0);
|
||
else{
|
||
op(0xB0);
|
||
op(itok.number);
|
||
}
|
||
ConstToReg(itok.number,AX,r8);
|
||
}
|
||
else MovRegNum(sized,0,itok.number,EAX);
|
||
}
|
||
fillstr:
|
||
// itok.number=ptrs->recnumber;
|
||
itok.number=adr;
|
||
if(rstr.bufstr==NULL)itok.number+=starts;
|
||
itok.sib=(am32==FALSE?CODE16:CODE32);
|
||
if(localstr){
|
||
if(comfile!=file_w32&&oneloop==FALSE){
|
||
pushss();
|
||
popes();
|
||
}
|
||
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;
|
||
tok=tk_rmnumber;
|
||
itok.post=0;
|
||
itok.size=tteg->size;
|
||
compressoffset(&itok);
|
||
if(rstr.bufstr!=NULL)CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
|
||
}
|
||
else{
|
||
if(comfile!=file_w32&&oneloop==FALSE){
|
||
pushds();
|
||
popes();
|
||
}
|
||
itok.post=poststr;
|
||
itok.segm=DS;
|
||
itok.rm=(am32==FALSE?rm_d16:rm_d32); //установки по умолчанию
|
||
itok.rec=NULL;//ptrs;
|
||
if(rstr.bufstr==NULL){
|
||
if(itok.post!=0)tok=tk_postnumber;
|
||
else tok=tk_number;
|
||
}
|
||
else{
|
||
// printf("bufrm=%s rstr=%s\n",bufrm,rstr.bufstr);
|
||
CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
|
||
// puts("end rm");
|
||
tok=tk_rmnumber;
|
||
itok.size=tteg->size; // ???? trap
|
||
}
|
||
}
|
||
itok.flag=flagstr;
|
||
if(oneloop){
|
||
switch(sized){
|
||
case 1:
|
||
outseg(&itok,2);
|
||
op(0xC6);
|
||
op(itok.rm);
|
||
outaddress(&itok);
|
||
op(hnum);
|
||
break;
|
||
case 2:
|
||
case 4:
|
||
op66(sized);
|
||
if(hnum==0){
|
||
outseg(&itok,2);
|
||
op(0x83);
|
||
op(itok.rm+0x20);
|
||
outaddress(&itok);
|
||
op(0);
|
||
break;
|
||
}
|
||
if((sized==4&&hnum==0xFFFFFFFF)||(sized==2&&hnum==0xFFFF)){
|
||
outseg(&itok,2);
|
||
op(0x83);
|
||
op(itok.rm+0x8);
|
||
outaddress(&itok);
|
||
op(0xFF);
|
||
break;
|
||
}
|
||
if(optimizespeed==0&&sized==4&&short_ok(hnum,TRUE)){
|
||
op(0x6A);
|
||
op(hnum); //push short number
|
||
op66(sized);
|
||
outseg(&itok,2);
|
||
op(0x8f);
|
||
op(itok.rm);
|
||
outaddress(&itok);
|
||
break;
|
||
}
|
||
outseg(&itok,2);
|
||
op(0xC7); //mov word[],number
|
||
op(itok.rm);
|
||
outaddress(&itok);
|
||
if(sized==2)outword(hnum);
|
||
else outdword(hnum);
|
||
break;
|
||
}
|
||
}
|
||
else{
|
||
warningreg(regs[am32][DI]);
|
||
getintoreg_32(DI,(am32+1)*2,0,&ofsst);
|
||
if(num<=2||(num<=4&&(!optimizespeed))){
|
||
for(unsigned int i=0;i<num;i++){
|
||
if(sized==1)stosb();
|
||
else if(sized==2)stosw();
|
||
else stosd();
|
||
}
|
||
}
|
||
else{
|
||
MovRegNum((am32+1)*2,0,num,ECX);
|
||
warningreg(regs[am32][CX]);
|
||
ConstToReg(0,ECX,(am32+1)*2);
|
||
op(0xF3); // REPZ
|
||
if(sized==1)stosb();
|
||
else if(sized==2)stosw();
|
||
else stosd();
|
||
}
|
||
}
|
||
nexttok();
|
||
break;
|
||
case tk_structvar:
|
||
struct structteg *tteg2;
|
||
int numel2;
|
||
int usenumstr2;
|
||
unsigned int num2;
|
||
int localstr2;
|
||
int poststr2;
|
||
int flagstr2;
|
||
// adr=itok.number;
|
||
|
||
localstr2=FALSE;
|
||
numel2=itok.rm; //число структур
|
||
usenumstr2=itok.post; //было указание номера структуры
|
||
if(itok.type==tp_classvar){
|
||
tteg2=(structteg *)itok.rec;
|
||
poststr2=0;
|
||
flagstr2=f_useidx;
|
||
}
|
||
else{
|
||
struct idrec *ptrs;
|
||
ptrs=itok.rec;
|
||
tteg2=(structteg *)ptrs->newid;
|
||
if(ptrs->recpost==LOCAL)localstr2=TRUE;
|
||
poststr2=ptrs->recpost;
|
||
flagstr2=ptrs->flag;
|
||
}
|
||
num2=itok.size;
|
||
// ptrs2=itok.rec;
|
||
// tteg2=(structteg *)ptrs2->newid;
|
||
// numel2=itok.rm; //число структур
|
||
// num2=tteg2->size;
|
||
if(usenumstr2!=FALSE){
|
||
num2=tteg->size;
|
||
if(strinf.bufstr==NULL)starts=num2*numel2;
|
||
}
|
||
// if(itok.post==FALSE)num2*=ptrs2->recrm; //не указан номер структуры - значит все
|
||
// else if(strinf.bufstr==NULL)starts=num2*numel2;
|
||
if(strinf.bufstr==NULL)itok.number+=starts;
|
||
itok.sib=(am32==FALSE?CODE16:CODE32);
|
||
if(localstr2){
|
||
itok.rm=rm_mod10;
|
||
if(strinf.bufstr==NULL){
|
||
if(ESPloc&&am32){
|
||
itok.rm|=rm_sib;
|
||
itok.sib=0x24;
|
||
}
|
||
else{
|
||
itok.rm|=(am32==FALSE?rm_BP:rm_EBP);
|
||
}
|
||
}
|
||
else{
|
||
CheckAllMassiv(bufrm,2,&strinf);
|
||
if(am32==FALSE)itok.rm|=rm_BPSI;
|
||
else{
|
||
itok.sib=(ESPloc?0x34:0x35);
|
||
itok.rm=4|rm_mod10;
|
||
}
|
||
}
|
||
itok.segm=SS;
|
||
if(ESPloc&&am32)itok.number+=addESP;
|
||
// else itok.number-=localsize;
|
||
tok=tk_rmnumber;
|
||
itok.size=tteg2->size;
|
||
itok.post=0;
|
||
compressoffset(&itok);
|
||
}
|
||
else{
|
||
itok.post=poststr2;
|
||
itok.rm=(am32==FALSE?rm_d16:rm_d32); //22.11.04 09:22//установки по умолчанию
|
||
if(strinf.bufstr==NULL){
|
||
if(itok.post==TRUE)tok=tk_postnumber;
|
||
else tok=tk_number;
|
||
}
|
||
else{
|
||
CheckAllMassiv(bufrm,2,&strinf);
|
||
itok.rm=rm_mod10|(am32==FALSE?rm_SI:6);
|
||
tok=tk_rmnumber;
|
||
itok.size=tteg2->size;
|
||
}
|
||
itok.segm=DS;
|
||
}
|
||
///!new
|
||
itok.flag=flagstr2;
|
||
warningreg(regs[am32][SI]);
|
||
///!new
|
||
// printf("tok=%d rm=%08X %s",tok,itok.rm,itok.name);
|
||
getintoreg_32(SI,(am32+1)*2,0,&ofsst);
|
||
ClearReg(SI);
|
||
num=tteg->size;
|
||
starts=0;
|
||
if(usenumstr==FALSE)num*=tteg->size; //ptrs->recrm; //не указан номер структуры - значит все
|
||
else if(rstr.bufstr==NULL)starts=num*numel;
|
||
itok.number=adr;//ptrs->recnumber;
|
||
if(rstr.bufstr==NULL)itok.number+=starts;
|
||
itok.sib=(am32==FALSE?CODE16:CODE32);
|
||
if(localstr){
|
||
// 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;
|
||
tok=tk_rmnumber;
|
||
itok.size=tteg->size;
|
||
itok.post=0;
|
||
compressoffset(&itok);
|
||
if(rstr.bufstr!=NULL)CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
|
||
}
|
||
else{
|
||
itok.post=poststr;//ptrs->recpost;
|
||
itok.segm=DS;
|
||
itok.rm=(am32==FALSE?rm_d16:rm_d32); //установки по умолчанию
|
||
if(rstr.bufstr==NULL){
|
||
if(itok.post==TRUE)tok=tk_postnumber;
|
||
else tok=tk_number;
|
||
}
|
||
else{
|
||
CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
|
||
tok=tk_rmnumber;
|
||
itok.size=tteg->size;
|
||
}
|
||
}
|
||
///!new
|
||
itok.flag=flagstr;//ptrs->flag;
|
||
warningreg(regs[am32][DI]);
|
||
if(num2>num)warnsize();
|
||
ClearReg(DI);
|
||
///!new
|
||
usenumstr2=DS;
|
||
if(poststr2==LOCAL)usenumstr2=SS;
|
||
getintoreg_32(DI,(am32+1)*2,0,&ofsst);
|
||
num=num2;
|
||
sized=1;
|
||
if(optimizespeed){
|
||
if((num%2)==0)sized=2;
|
||
if(chip>2&&(num%4)==0)sized=4;
|
||
}
|
||
else{
|
||
if(am32==FALSE){
|
||
if((num%2)==0)sized=2;
|
||
}
|
||
else{
|
||
if(chip>2&&(num%4)==0)sized=4;
|
||
}
|
||
}
|
||
num/=sized;
|
||
///!new
|
||
if(num<=2||(num<=4&&(!optimizespeed&&usenumstr2!=SS))){
|
||
for(unsigned int i=0;i<num;i++){
|
||
if(usenumstr2==SS)op(0x36);
|
||
if(sized==1)movsb();
|
||
else if(sized==2)movsw();
|
||
else movsd();
|
||
}
|
||
}
|
||
else{
|
||
///!new
|
||
MovRegNum((am32+1)*2,0,num,ECX);
|
||
warningreg(regs[am32][CX]);
|
||
ConstToReg(0,ECX,(am32+1)*2);
|
||
if(comfile!=file_w32){
|
||
if(poststr)pushss();
|
||
// if(ptrs->recpost==LOCAL)pushss();
|
||
else pushds();
|
||
popes();
|
||
}
|
||
op(0xF3); // REPZ
|
||
if(usenumstr2==SS)op(0x36);
|
||
if(sized==1)movsb();
|
||
else if(sized==2)movsw();
|
||
else movsd();
|
||
}
|
||
break;
|
||
default: errstruct();
|
||
}
|
||
}
|
||
else{
|
||
nexttok();
|
||
errstruct();
|
||
}
|
||
if(ofsst)free(ofsst);
|
||
}
|
||
|
||
int SaveStruct(int size,idrec *newrec)
|
||
{
|
||
int i=0;
|
||
if((startStartup+size)<endStartup){
|
||
if(alignword){ //выровнять на четный адрес
|
||
if(startStartup%2==1)i=1;
|
||
}
|
||
if((startStartup+size+i)<=endStartup){
|
||
startStartup+=i;
|
||
newrec->recnumber=startStartup; //адрес начала структуры
|
||
newrec->recpost=FALSE;
|
||
startStartup+=size;
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
int CheckAsmName(char *name)
|
||
{
|
||
char buf[IDLENGTH];
|
||
strcpy(buf,name);
|
||
strupr(buf);
|
||
return FastSearch((unsigned char *)asmMnem,ofsmnem,0,buf);
|
||
}
|
||
|
||
void FastTok(int mode,int *tok4,ITOK *itok4)
|
||
{
|
||
int useme;
|
||
int next=1;
|
||
*tok4=tokens;
|
||
itok4->type=tp_ucnovn;
|
||
whitespace(); //пропуск незначащих символов
|
||
if(isalpha(cha)||(cha=='_')||cha>=0x80){ //идентификатор
|
||
if(mode==1){
|
||
int i=0;
|
||
do{
|
||
itok4->name[i++]=cha;
|
||
nextchar();
|
||
}while(CheckChar2()==TRUE&&i<IDLENGTH);
|
||
if(i==IDLENGTH)i--;
|
||
itok4->name[i]=0;
|
||
}
|
||
while(CheckChar2()==TRUE)nextchar(); //дочитать слово
|
||
*tok4=tk_id;
|
||
return;
|
||
}
|
||
if(isdigit(cha)){//числа
|
||
if(mode==1){
|
||
inptr--;
|
||
itok4->lnumber=scannumber(&itok4->rm);
|
||
}
|
||
else{
|
||
do{
|
||
nextchar();
|
||
}while(isdigit(cha));
|
||
}
|
||
*tok4=tk_number;
|
||
return;
|
||
}
|
||
else switch(cha){
|
||
case '\"':
|
||
nextchar(); //строковая константа
|
||
while(cha!='\"'&&!endoffile){
|
||
convert_char();
|
||
nextchar();
|
||
}
|
||
*tok4=tk_string;
|
||
break;
|
||
case '\'': //символьная константа может иметь более 1 символа
|
||
nextchar();
|
||
while(cha!='\''&&!endoffile){ // special character
|
||
convert_char();
|
||
nextchar();
|
||
}
|
||
break;
|
||
case '/': nextchar();
|
||
switch(cha){
|
||
case '*': nextchar(); //соментарий
|
||
useme=1;
|
||
if(mode==2)itok4->number=inptr-2;
|
||
while(!endoffile&&useme>0){
|
||
whitespace();
|
||
if(cha=='*'){
|
||
nextchar();
|
||
if(cha=='/')useme--;
|
||
else continue;
|
||
}
|
||
else if(cha=='/'){
|
||
nextchar();
|
||
if(cha=='*')useme++;
|
||
else continue;
|
||
}
|
||
nextchar();
|
||
}
|
||
if(mode==2)*tok4=tk_comment2;
|
||
else FastTok(mode,tok4,itok4);
|
||
if(endoffile)*tok4=tk_eof;
|
||
return;
|
||
case '/':
|
||
if(mode==2)itok4->number=inptr-2;
|
||
do{
|
||
nextchar();
|
||
}while(!endoffile&&cha!=13); //строка коментария
|
||
if(endoffile)*tok4=tk_eof;
|
||
if(mode==2)*tok4=tk_comment1;
|
||
else FastTok(mode,tok4,itok4);
|
||
return;
|
||
}
|
||
break;
|
||
case '#':
|
||
case '?':
|
||
nextchar();
|
||
// tokscan(&tok,&itok,string);
|
||
FastTok(1,tok4,itok4);
|
||
// if((itok.number=GetDirective((char *)string))!=-1){
|
||
if(*tok4==tk_id&&(itok4->number=GetDirective(itok4->name))!=-1){
|
||
*tok4=tk_question;
|
||
}
|
||
return;
|
||
case ';': *tok4=tk_semicolon; break;
|
||
case '[': *tok4=tk_openblock; break;
|
||
case ']': *tok4=tk_closeblock; break;
|
||
case '(': *tok4=tk_openbracket; break;
|
||
case ')': *tok4=tk_closebracket; break;
|
||
case '{': *tok4=tk_openbrace; break;
|
||
case '}': *tok4=tk_closebrace; break;
|
||
case ',': *tok4=tk_camma; break;
|
||
case ':': *tok4=tk_colon; break;
|
||
case 26: *tok4=tk_eof; return;
|
||
case 13: *tok4=tk_endline; break;
|
||
case '\\':
|
||
nextchar();
|
||
if(cha==13){
|
||
FastTok(mode,tok4,itok4);
|
||
if(tok==tk_endline)FastTok(mode,tok4,itok4);
|
||
return;
|
||
}
|
||
break;
|
||
case '!':
|
||
nextchar();
|
||
if(cha=='='){
|
||
*tok4=tk_notequal; //!=
|
||
itok4->type=tp_compare;
|
||
}
|
||
else{
|
||
*tok4=tk_not;
|
||
next=0;
|
||
}
|
||
break;
|
||
case '=':
|
||
nextchar();
|
||
if(cha=='='){
|
||
*tok4=tk_equalto; //==
|
||
itok4->type=tp_compare;
|
||
}
|
||
else{
|
||
*tok4=tk_assign; //присвоить
|
||
next=0;
|
||
}
|
||
break;
|
||
case '>':
|
||
nextchar();
|
||
switch(cha){
|
||
case '>':
|
||
nextchar();
|
||
if(cha=='=')*tok4=tk_rrequals; //сдвиг вправо с присвоением
|
||
else{
|
||
*tok4=tk_rr; //сдвиг вправо
|
||
next=0;
|
||
itok4->type=tp_opperand;
|
||
}
|
||
break;
|
||
case '<': *tok4=tk_swap; break; //обмен
|
||
case '=': *tok4=tk_greaterequal; itok4->type=tp_compare; break; //больше или равно
|
||
default: *tok4=tk_greater; next=0; itok4->type=tp_compare; break; //больше
|
||
}
|
||
break;
|
||
case '<':
|
||
nextchar();
|
||
switch(cha){
|
||
case '<':
|
||
nextchar();
|
||
if(cha=='=')*tok4=tk_llequals; //сдвиг влево с присвоением
|
||
else{
|
||
*tok4=tk_ll; //сдвиг влево
|
||
next=0;
|
||
itok4->type=tp_opperand;
|
||
}
|
||
break;
|
||
case '>': *tok4=tk_notequal; itok4->type=tp_compare; break; //!=
|
||
case '=': *tok4=tk_lessequal; itok4->type=tp_compare; break; //меньше или равно
|
||
default: *tok4=tk_less; next=0; itok4->type=tp_compare; break;//меньше
|
||
}
|
||
break;
|
||
}
|
||
if(next)nextchar();
|
||
}
|
||
|
||
void FindDirectiv()
|
||
//ускоренный поиск директивы
|
||
{
|
||
inptr=inptr2;
|
||
cha=cha2;
|
||
linenumber=linenum2;
|
||
do{
|
||
FastTok(0);
|
||
}while(tok!=tk_question&&tok!=tk_eof);
|
||
inptr2=inptr;
|
||
cha2=cha;
|
||
linenum2=linenumber;
|
||
}
|
||
|
||
unsigned long long scannumber(int *rm)
|
||
{
|
||
int useme=0,binnum=0;
|
||
unsigned char c;
|
||
unsigned long long number=0;
|
||
*rm=tokens;
|
||
for(int i=inptr;;i++){
|
||
c=input[i];
|
||
unsigned char cc=c&(unsigned char)0x5f;
|
||
if(cc>='A'&&cc<='F'){
|
||
if(cc=='B'&&binnum==1)binnum++;
|
||
else binnum=3;
|
||
useme=3;
|
||
}
|
||
else if(c<'0'||c>'9'){
|
||
if(useme==0&&c=='.'&&input[i+1]!='.'){ //float
|
||
binnum=3;
|
||
useme++;
|
||
*rm=tk_double;
|
||
*(double *)&number=atof((char *)&input[inptr]);
|
||
// printf("float=%f %08X\n",*(float *)&number,*(long *)&number);
|
||
inptr=i+1;
|
||
do{
|
||
nextchar();
|
||
}while(isdigit(cha));
|
||
if((cha&0x5f)!='E')break;
|
||
nextchar();
|
||
if(isdigit(cha)||cha=='-'){
|
||
do{
|
||
nextchar();
|
||
}while(isdigit(cha));
|
||
}
|
||
break;
|
||
}
|
||
else if(cc=='H'){ //hex
|
||
useme=2;
|
||
binnum=3;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
else if(c<'2'&&(binnum==0||binnum==2))binnum++;
|
||
}
|
||
if(binnum==2)goto cbinnum;
|
||
if(useme!=1){
|
||
nextchar();
|
||
if(useme==2)goto hexnum;
|
||
if(cha=='0'){
|
||
nextchar();
|
||
switch(cha&0x5f){
|
||
case 'X': // hexadecimal number
|
||
nextchar();
|
||
hexnum:
|
||
while(isxdigit(cha)){
|
||
number*=16;
|
||
if(isdigit(cha))number+=cha-'0';
|
||
else number+=(cha&0x5f)-'7';
|
||
nextchar();
|
||
}
|
||
if(useme==2)nextchar();
|
||
useme++;
|
||
break;
|
||
case 'B': // binary number
|
||
cbinnum:
|
||
nextchar();
|
||
while(cha=='0'||cha=='1'){
|
||
number=number*2+(cha-'0');
|
||
nextchar();
|
||
}
|
||
if(binnum==2)nextchar();
|
||
else useme++;
|
||
break;
|
||
case 'O': // octal number
|
||
nextchar();
|
||
while(cha>='0'&&cha<='7'){
|
||
number=number*8+(cha-'0');
|
||
nextchar();
|
||
}
|
||
useme++;
|
||
break;
|
||
}
|
||
}
|
||
if(useme==0||useme==3){ // decimal number
|
||
while(isdigit(cha)){
|
||
number=number*10+(cha-'0');
|
||
nextchar();
|
||
}
|
||
}
|
||
}
|
||
c=(unsigned char)(cha&0x5F);
|
||
if(c=='I'){
|
||
if(input[inptr]=='6'&&input[inptr+1]=='4'){
|
||
inptr+=2;
|
||
nextchar();
|
||
*rm=tk_qword;
|
||
}
|
||
}
|
||
else if(c=='L'||c=='U'||c=='F'||c=='Q'){
|
||
if(c=='L')*rm=tk_dword;
|
||
if(c=='F'){
|
||
*rm=tk_float;
|
||
*(float *)&number=*(double *)&number;
|
||
}
|
||
if(c=='Q')*rm=tk_qword;
|
||
nextchar();
|
||
c=(unsigned char)(cha&0x5F);
|
||
if(c=='L'||c=='U'){
|
||
if(c=='L')*rm=tk_dword;
|
||
nextchar();
|
||
}
|
||
}
|
||
if(*rm==tokens){
|
||
if(number<256)*rm=tk_byte;
|
||
else if(number<65536)*rm=tk_word;
|
||
else if(number<0x100000000LL)*rm=tk_dword;
|
||
else *rm=tk_qword;
|
||
}
|
||
return number;
|
||
}
|
||
|
||
void tag_massiv(int *tok4,ITOK *itok4,unsigned char *string4)
|
||
{
|
||
struct structteg *tteg;
|
||
int number,tok,rm;
|
||
tok=*tok4;
|
||
number=itok4->number;
|
||
nextchar();
|
||
//14.09.04 18:52
|
||
do{
|
||
FastTok(1,tok4,itok4);
|
||
strcpy((char *)string4,itok4->name);
|
||
searchtree2(definestart,itok4,tok4,string4);
|
||
}while(*tok4==tk_endline);
|
||
///////////////////
|
||
// printf("tok=%d %s\n",*tok4,itok4->name);
|
||
char *tn;
|
||
if((tn=strchr(itok4->name,'@'))!=NULL)*tn=0;
|
||
if((tteg=FindTeg(FALSE,itok4->name))!=NULL||(tteg=FindTeg(TRUE,itok4->name))!=NULL){
|
||
// printf("tok=%d %s\n",*tok4,itok4->name);
|
||
itok4->number=0;
|
||
dostructvar2(tok4,itok4,tteg,string4);
|
||
rm=RegToRM(number,tok);
|
||
// printf("tok=%d rm=%d %s\n",*tok4,itok4->rm,itok4->name);
|
||
if(*tok4==tk_pointer&&itok4->type==tk_proc){
|
||
itok4->sib=rm|rm_mod10;
|
||
itok4->flag&=~f_reloc;
|
||
}
|
||
else if(*tok4!=tk_proc&&*tok4!=tk_declare/*&&(itok4->flag&f_static)==0 эффект добавления регристра*/){
|
||
itok4->rm=rm_mod10|rm;
|
||
itok4->flag&=~f_reloc;
|
||
}
|
||
if(*tok4==tk_proc||*tok4==tk_declare||*tok4==tk_undefproc){
|
||
structadr.sib=THIS_REG;
|
||
structadr.rm=number;
|
||
}
|
||
else if(*tok4==tk_id||*tok4==tk_ID||*tok4==tk_structvar){
|
||
*tok4=tk_rmnumber;
|
||
itok4->segm=(splitdata==FALSE)?DS:CS;
|
||
itok4->post=0;
|
||
}
|
||
if(bufrm&&strcmp(bufrm,"&this;")==0){
|
||
free(bufrm);
|
||
bufrm=NULL;
|
||
}
|
||
// printf("tok=%d rm=%d post=%d %s\n",*tok4,itok4->rm,itok4->post,itok4->name);
|
||
// if(strinf.bufstr)puts(strinf.bufstr);
|
||
}
|
||
else if(displaytokerrors){
|
||
unknowntagstruct(itok4->name);
|
||
*tok4=tk_number;
|
||
}
|
||
}
|
||
|
||
int RegToRM(int number,int tok4)
|
||
{
|
||
int rm;
|
||
if(displaytokerrors){
|
||
if(am32==FALSE&&tok4==tk_reg32)regBXDISIBPexpected();
|
||
else if(am32&&tok4==tk_reg)reg32expected();
|
||
}
|
||
if(am32==FALSE){
|
||
switch(number){
|
||
case BX:
|
||
rm=rm_BX;
|
||
break;
|
||
case DI:
|
||
rm=rm_DI;
|
||
break;
|
||
case SI:
|
||
rm=rm_SI;
|
||
break;
|
||
case BP:
|
||
rm=rm_BP;
|
||
break;
|
||
default:
|
||
if(displaytokerrors)regBXDISIBPexpected();
|
||
break;
|
||
}
|
||
}
|
||
else rm=number;
|
||
return rm;
|
||
}
|
||
|
||
int CheckResName(char *name)
|
||
{
|
||
char buf[IDLENGTH];
|
||
strcpy(buf,name);
|
||
strlwr(buf);
|
||
return FastSearch((unsigned char *)resMnem,ofsres,3,buf);
|
||
}
|
||
|
||
int GetTokVar2()
|
||
{
|
||
ITOK cstok;
|
||
int i;
|
||
unsigned char ocha=cha;
|
||
unsigned int oinptr=inptr;
|
||
int oline=linenumber;
|
||
char odisplay=displaytokerrors;
|
||
displaytokerrors=0;
|
||
tokscan(&i,&cstok,string2);
|
||
displaytokerrors=odisplay;
|
||
switch(i){
|
||
case tk_number:
|
||
cha=ocha;
|
||
inptr=oinptr;
|
||
linenumber=oline;
|
||
case tk_int:
|
||
case tk_char:
|
||
case tk_long:
|
||
case tk_short:
|
||
case tk_byte:
|
||
case tk_word:
|
||
case tk_dword:
|
||
case tk_signed:
|
||
case tk_unsigned:
|
||
return i;
|
||
}
|
||
cha=ocha;
|
||
inptr=oinptr;
|
||
linenumber=oline;
|
||
return 0;
|
||
}
|
||
|
||
void GetTypeVar(int *tok4)
|
||
{
|
||
static int use=0;
|
||
int i;
|
||
if(use)return;
|
||
use=1;
|
||
i=GetTokVar2();
|
||
if(*tok4==tk_signed){
|
||
if(i==tk_char||i==tk_int||i==tk_long){
|
||
*tok4=i;
|
||
i=GetTokVar2();
|
||
if(*tok4==tk_long){
|
||
if(i==tk_long)*tok4=tk_qword;
|
||
else if(i!=tk_int&&i!=0&&displaytokerrors)unknowntype();
|
||
}
|
||
if(*tok4==tk_int&&am32)*tok4=tk_long;
|
||
}
|
||
else if(i==tk_short){
|
||
i=GetTokVar2();
|
||
*tok4=tk_int;
|
||
if(i!=0&&i!=tk_int&&displaytokerrors)unknowntype();
|
||
}
|
||
else if(i==0)*tok4=(am32==0?tk_int:tk_long);
|
||
else if(displaytokerrors)unknowntype();
|
||
}
|
||
else if(*tok4==tk_unsigned){
|
||
switch(i){
|
||
case tk_char:
|
||
*tok4=tk_byte;
|
||
break;
|
||
case tk_int:
|
||
*tok4=(am32==0?tk_word:tk_dword);
|
||
break;
|
||
case tk_long:
|
||
*tok4=tk_dword;
|
||
i=GetTokVar2();
|
||
if(i==tk_long)*tok4=tk_qword;
|
||
else if(i!=tk_int&&i!=0&&displaytokerrors)unknowntype();
|
||
break;
|
||
case tk_short:
|
||
*tok4=tk_word;
|
||
i=GetTokVar2();
|
||
if(i!=0&&i!=tk_int&&displaytokerrors)unknowntype();
|
||
break;
|
||
case 0:
|
||
*tok4=(am32==0?tk_word:tk_dword);
|
||
break;
|
||
default:
|
||
if(displaytokerrors)unknowntype();
|
||
}
|
||
}
|
||
else if(i==tk_int&&(*tok4==tk_long||*tok4==tk_short))*tok4=i;
|
||
else if(*tok4==tk_short)*tok4=tk_int;
|
||
else if(*tok4==tk_int&&(!(idasm==TRUE&&i==tk_number))&&am32)*tok4=tk_long;
|
||
else if(i==tk_long&& *tok4==tk_long)*tok4=tk_qword;
|
||
use=0;
|
||
}
|
||
|
||
int CheckDef()
|
||
{
|
||
int otok;
|
||
if(skipfind!=LOCAL)return FALSE;
|
||
switch(tok2){
|
||
case tk_semicolon:
|
||
case tk_assign:
|
||
case tk_openblock:
|
||
case tk_openbracket:
|
||
case tk_camma:
|
||
case tk_openbrace:
|
||
return FALSE;
|
||
}
|
||
otok=tok;
|
||
searchtree2(definestart,&itok,&tok,string);
|
||
if(tok==otok)return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
/* end of TOKA.C */
|