WebSVN – Kolibri OS – Blame – /programs/develop/cmm/toka.cpp

Rev	Author	Line No.	Line
6446	GerdtR	1
		2
		3
		4
		5
		6
		7
		8	#include
		9	#endif
		10
		11
		12	#include
		13
		14
		15	#include "id.h"
		16	#include "resname.h"
		17
		18
		19	struct idrec *definestart=NULL;
		20	UNDEFOFF *undefoffstart=NULL;
		21	DLLLIST *listdll=NULL;
		22	struct structteg *tegtree=NULL; //�� ᮪ ⥣��
		23	struct structteg *ltegtree=NULL; //�� ᮪ ⥣��
		24	//struct idrec *lstructlist=NULL; //ᯨ᮪ ��
		25	SINFO strinf={NULL};
		26	static int notdef=TRUE;
		27	static char precha;
		28	int scanalltoks=TRUE;
		29
		30
		31
		32	static int sizeDL; //ࠧ�� ᯨ᪠
		33	static volatile int countDP; //�᫮ ��᪨� ��楤�� ᯨ᪥
		34	static int findofset=FALSE;
		35	#define STEPDL 128; //蠣㢥��祭�� ࠧ�� ᯨ᪠
		36	ITOK structadr;
		37
		38
		39
		40	"ESCHAR","ESBYTE","ESINT","ESWORD","ESLONG","ESDWORD","ESFLOAT","ESQWORD","ESDOUBLE",
		41	"CSCHAR","CSBYTE","CSINT","CSWORD","CSLONG","CSDWORD","CSFLOAT","CSQWORD","CSDOUBLE",
		42	"SSCHAR","SSBYTE","SSINT","SSWORD","SSLONG","SSDWORD","SSFLOAT","SSQWORD","SSDOUBLE",
		43	"DSCHAR","DSBYTE","DSINT","DSWORD","DSLONG","DSDWORD","DSFLOAT","DSQWORD","DSDOUBLE",
		44	"FSCHAR","FSBYTE","FSINT","FSWORD","FSLONG","FSDWORD","FSFLOAT","FSQWORD","FSDOUBLE",
		45	"GSCHAR","GSBYTE","GSINT","GSWORD","GSLONG","GSDWORD","GSFLOAT","GSQWORD","GSDOUBLE",};
		46
		47
		48	"EAX","ECX","EDX","EBX","ESP","EBP","ESI","EDI"};
		49	char begs[8][3]={"AL","CL","DL","BL","AH","CH","DH","BH"};
		50	char segs[6][3]={"ES","CS","SS","DS","FS","GS"};
		51
		52
		53	"Sep","Oct","Nov","Dec"};
		54
		55
		56	char skipfind=FALSE; /* �ய�� ᪠ � ��쭮� ��ॢ� � �।�
		57	�� ६�� */
		58	static unsigned char savestring3=FALSE; //ࠧ�� string3
		59	static int posstr3; //㪠��⥫� ��樨 � string3
		60
		61
		62	unsigned int linenum2=0; //�᫨ �� , � �� ⪠
		63	char displaytokerrors; /* flag to display errors, 0 for tok2 scan */
		64	char *bufrm=NULL;
		65	char *startline=NULL;
		66	char *endinput=NULL;
		67	unsigned char skiplocals=FALSE;
		68	int scanlexmode=STDLEX;
		69	unsigned char bytesize=TRUE;
		70
		71
		72
		73
		74	void dostructvar2(int tok4,ITOK itok4,struct structteg tteg,unsigned char string4); //ࠧ�� ६��
		75	void dosizeof(ITOK *itok4); //�� 祭�� sizeof
		76	void ofsstr(int tok4,ITOK itok4);
		77	int searchlocals(ITOK itok4,int tok4,unsigned char *string4);
		78	unsigned char convert_char();
		79	void tokscan (int tok4,ITOK itok4,unsigned char *string4);
		80	int calcnum(int ctok,ITOK cstok,char cstring,long retval);
		81	int GetDirective(char *str);
		82	int CheckAsmName(char *name);
		83	void tag_massiv(int tok4,ITOK itok4,unsigned char *string4);
		84	int CheckResName(char *name);
		85	void GetTypeVar(int *tok4);
		86	int RegToRM(int number,int tok4);
		87	elementteg FindClassEl(structteg searcht,unsigned char string4,int addofs,
		88	structteg *subteg);
		89	int AskUseDestr(structteg *searcht);
		90	int SaveStruct(int size,idrec *newrec);
		91	int CheckDefPar(char *name);
		92	int searchtree2(idrec fptr,ITOK itok4,int tok4,unsigned char string4);
		93
		94
		95	extern void block16_32error();
		96	extern void notstructname();
		97	extern void badtoken();
		98	extern void opb(unsigned long num,unsigned int ofs,unsigned int size);
		99	extern void CorrectOfsBit(int bitofs);
		100	extern int skipstring(int pos,unsigned char term);
		101	extern int skipcomment(int pos);
		102
		103
		104
		105	{
		106	if(mode==STDLEX&&cha2==13&&tok!=tk_endline){
		107	cha2=cha;
		108	}
		109	scanlexmode=mode;
		110	}
		111
		112
		113	{
		114	if(cha=='o'){
		115	OemToChar(string4,string4);
		116	nextchar();
		117	}
		118	else if(cha=='w'){
		119	CharToOem(string4,string4);
		120	nextchar();
		121	}
		122	}
		123
		124
		125	{
		126	// GetDateFormat(LOCALE_SYSTEM_DEFAULT,DATE_SHORTDATE\|LOCALE_NOUSEROVERRIDE,NULL,NULL,buf,80);
		127	sprintf(buf,"%2d %s %d",timeptr.tm_mday,mon[timeptr.tm_mon],timeptr.tm_year+1900);
		128	}
		129
		130
		131	{
		132	if(thetok->sib==CODE16){
		133	if(thetok->rm!=rm_d16){
		134	thetok->rm&=7;
		135	if(thetok->number==0){
		136	if(thetok->rm==rm_BP)thetok->rm\|=rm_mod01;
		137	}
		138	else if((int)thetok->number<128&&(int)thetok->number>=-128)thetok->rm\|=rm_mod01;
		139	else thetok->rm\|=rm_mod10;
		140	}
		141	}
		142	else{
		143	if(thetok->rm!=rm_d32&&thetok->rm!=rm_sib){
		144	thetok->rm&=7;
		145	if(thetok->number==0){
		146	if(thetok->rm==5)thetok->rm\|=rm_mod01;
		147	if(thetok->rm==4&&(thetok->sib&7)==5)thetok->rm\|=rm_mod01;
		148	}
		149	else if(thetok->number<128&&thetok->number>=-128)thetok->rm\|=rm_mod01;
		150	else thetok->rm\|=rm_mod10;
		151	}
		152	}
		153	}
		154
		155
		156	{
		157	int rm;
		158	rm=0;
		159	switch(base+idx){
		160	case 2: rm++;
		161	case 4: rm++;
		162	case 6: rm++;
		163	case 5: rm++;
		164	case 12: rm++;
		165	case 11: rm++;
		166	case 10: rm++;
		167	}
		168	return rm;
		169	}
		170
		171
		172	{
		173	static int size=0;
		174	static char *buf;
		175	if(mode==0){
		176	if(SizeBackBuf){
		177	size=SizeBackBuf;
		178	SizeBackBuf=0;
		179	buf=BackTextBlock;
		180	}
		181	}
		182	else{
		183	SizeBackBuf=size;
		184	size=0;
		185	BackTextBlock=buf;
		186	}
		187	}
		188
		189
		190	{
		191	int rm0;
		192	int reg1=-1,reg2=-1;
		193	int z=0;
		194	rm0=rm&0x7;
		195	if(sib==CODE16\|\|sib==(CODE16+1)){
		196	switch(rm0){
		197	case 0:
		198	reg1=BX;
		199	reg2=SI;
		200	break;
		201	case 1:
		202	reg1=BX;
		203	reg2=DI;
		204	break;
		205	case 2:
		206	reg1=BP;
		207	reg2=SI;
		208	break;
		209	case 3:
		210	reg1=BP;
		211	reg2=DI;
		212	break;
		213	case 4:
		214	reg2=SI;
		215	break;
		216	case 5:
		217	reg2=DI;
		218	break;
		219	case 6:
		220	if((rm&0xC0)!=0)reg1=BP;
		221	break;
		222	case 7:
		223	reg1=BX;
		224	break;
		225	}
		226	}
		227	else{
		228	if(rm0==4){
		229	reg1=sib&7;
		230	reg2=(sib>>3)&7;
		231	if(reg1==5&&(rm&0xc0)==0)reg1=-1;
		232	if(reg2==4)reg2=-1;
		233	else z=sib>>6;
		234	}
		235	else{
		236	reg1=rm0;
		237	if(reg1==5&&(rm&0xc0)==0)reg1=-1;
		238	}
		239	}
		240	*base=reg1;
		241	*idx=reg2;
		242	*zoom=z;
		243	}
		244
		245
		246	{
		247	int zoom=0;
		248	switch(size){
		249	case 8: zoom++;
		250	case 4: zoom++;
		251	case 2: zoom++;
		252	}
		253	return zoom;
		254	}
		255
		256
		257	{
		258	int idx,base,razr=0,zoom,rm=0;
		259	long numrm=0,cnum,ocnum;
		260	int nextscan;
		261	ITOK cstok,dstok;
		262	int ctok,sopenb;
		263	unsigned char *pstring;
		264	unsigned int flag;
		265	unsigned int sizevar=1;
		266	unsigned int prevtok=tk_number,operand=tk_plus;
		267	int dsword,dsword2;
		268	nextchar();
		269	whitespace();//�ய�� ᨬ��
		270	if(!displaytokerrors){
		271	for(int i=1;i!=0;){
		272	FastTok(0,&ctok,&cstok);
		273	switch(ctok){
		274	case tk_closeblock: i--; break;
		275	case tk_openblock: i++; break;
		276	case tk_eof: i=0; break;
		277	}
		278	}
		279	return;
		280	}
		281
		282
		283	itok4->post&=NOTPOINTER;
		284	memcpy(&dstok,itok4,sizeof(ITOK));
		285	ExpandRm(dstok.rm,dstok.sib,&zoom,&base,&idx);
		286	if((dstok.sib==CODE16\|\|dstok.sib==(CODE16+1))&&dstok.rm!=rm_d16)razr=r16;
		287	if(am32&&dstok.rm!=rm_d32){
		288	rm=dstok.rm&0xC0;
		289	razr=r32;
		290	}
		291	// printf("in idx=%d base=%d zoom=%d\n",idx,base,zoom);
		292	pstring=(unsigned char *)MALLOC(STRLEN);
		293	sopenb=inptr;
		294	char bcha=cha;
		295	SRBackBuf(0);
		296	flag=f_useidx;//0;//cstok.flag;
		297	if(bytesize==FALSE){
		298	sizevar=GetVarSize(ttok);
		299	if(dsword)sizevar=1;
		300	if(am32)zoom=CheckZoom(sizevar);
		301	}
		302	if(cha=='&'){
		303	nextchar();
		304	whitespace();//�ய�� ᨬ��
		305	sizevar=1;
		306	zoom=0;
		307	}
		308	for(;;){
		309	nextscan=TRUE;
		310	if(cha=='#'&&dsword)dsword=1;
		311	tokscan(&ctok,&cstok,pstring);
		312	whitespace();//�ய�� ᨬ��
		313	if(dsword==1)strcpy(dstok.name,cstok.name);
		314	// printf("tok=%d num=%d %s\n",ctok,cstok.number,cstok.name);
		315	loopsw:
		316	switch(ctok){
		317	case tk_reg:
		318	if(razr==0)razr=r16;
		319	else if(razr==r32\|\|sizevar!=1\|\|operand!=tk_plus)goto runblock; //16.12.04 22:39
		320	if(cstok.number==BP\|\|cstok.number==BX){
		321	if(base==-1)base=cstok.number;
		322	else goto runblock;
		323	}
		324	else if(cstok.number==SI\|\|cstok.number==DI){
		325	if(idx==-1)idx=cstok.number;
		326	else goto runblock;
		327	}
		328	else goto runblock;
		329	prevtok=tk_reg;
		330	break;
		331	case tk_minus:
		332	if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
		333	prevtok=tk_number;
		334	ocnum=cstok.number;
		335	goto enumb;
		336	case tk_number:
		337	if(operand==tk_mult&&prevtok==tk_reg32){
		338	if(zoom==0){
		339	prevtok=tk_number;
		340	if(razr==0)razr=r32;
		341	else if(razr==r16)goto runblock;
		342	zoom=CheckZoom(cstok.number);
		343	if(zoom)break;
		344	}
		345	else goto runblock;
		346	}
		347	prevtok=tk_number;
		348	ocnum=cstok.number;
		349	if(zoom==0&&razr!=r16&&(idx==-1\|\|base==-1)){
		350	if((zoom=CheckZoom(cstok.number))!=0){
		351	if(cha=='*'){
		352	nextchar();
		353	tokscan(&ctok,&cstok,pstring);
		354	if(ctok==tk_reg32){
		355	if(idx!=-1)base=idx;
		356	idx=cstok.number;
		357	prevtok=tk_reg32;
		358	if(razr==0)razr=r32;
		359	break;
		360	}
		361	if(ctok==tk_number){
		362	calclongnumber(&ocnum,cstok.number,tk_mult);
		363	numrm+=ocnum;
		364	zoom=0;
		365	break;
		366	}
		367	goto runblock;
		368	}
		369	zoom=0;
		370	}
		371	}
		372	if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
		373	enumb:
		374	flag^=cstok.flag;
		375	whitespace();//�ய�� ᨬ��
		376	ocnum=cnum;
		377	numrm+=cnum;
		378	if(cstok.type==tp_opperand\|\|cstok.type==tp_stopper)nextscan=FALSE;
		379	else{
		380	operand=tk_plus;
		381	goto loopsw;
		382	}
		383	break;
		384	case tk_reg32:
		385	// printf("prevtok=%d operand=%d ocnum=%d idx=%d base=%d zoom=%d\n",prevtok,operand,ocnum,idx,base,zoom);
		386	if(razr==0)razr=r32;
		387	if(razr==r16\|\|(operand!=tk_plus&&operand!=tk_mult)\|\|(idx!=-1&&base!=-1))goto runblock;
		388	if(sizevar!=1){
		389	if(idx!=-1)goto runblock;
		390	idx=cstok.number;
		391	}
		392	else if(operand==tk_mult){
		393	if(prevtok!=tk_number)goto runblock;
		394	zoom=CheckZoom(ocnum);
		395	numrm-=ocnum;
		396	if(idx!=-1)base=idx;
		397	idx=cstok.number;
		398	}
		399	else if(cha=='*'){
		400	if(idx!=-1)base=idx;
		401	idx=cstok.number;
		402	}
		403	else if(base==-1)base=cstok.number;
		404	else if(idx==-1)idx=cstok.number;
		405	// else goto runblock;
		406	prevtok=tk_reg32;
		407	break;
		408	case tk_postnumber:
		409	if(dsword==0\|\|sizevar!=1)goto runblock;
		410	if((cstok.post&USED_DIN_VAR)==USED_DIN_VAR){ //��᪠� ��६��
		411	if(dstok.rec!=NULL)goto runblock;
		412	dstok.rec=cstok.rec;
		413	}
		414	if(operand==tk_minus)numrm-=cstok.number;
		415	else numrm+=cstok.number;
		416	dstok.post\|=cstok.post;
		417	prevtok=tk_number;
		418	break;
		419	case tk_undefofs:
		420	if(dsword==0\|\|sizevar!=1)goto runblock;
		421	if(operand==tk_minus)numrm-=cstok.number;
		422	else numrm+=cstok.number;
		423	dstok.post\|=UNDEF_OFSET;
		424	strcpy(dstok.name,cstok.name);
		425	flag^=cstok.flag;
		426	prevtok=tk_number;
		427	break;
		428	case tk_rmnumber:
		429	/* if(strinf.bufstr!=NULL){
		430	free(strinf.bufstr);
		431	strinf.bufstr=NULL;
		432	goto runblock;
		433	}*/
		434	if(dsword==0\|\|sizevar!=1)goto runblock;
		435	if(operand==tk_minus)numrm-=cstok.number;
		436	else numrm+=cstok.number;
		437	dstok.post\|=cstok.post;
		438	if(dstok.sib==CODE16){
		439	if(cstok.rm!=rm_d16){
		440	switch(cstok.rm&7){
		441	case 0:
		442	if(base!=-1\|\|idx!=-1)goto runblock;
		443	base=BX; idx=SI; break;
		444	case 1:
		445	if(base!=-1\|\|idx!=-1)goto runblock;
		446	base=BX; idx=DI; break;
		447	case 2:
		448	if(base!=-1\|\|idx!=-1)goto runblock;
		449	base=BP; idx=SI; break;
		450	case 3:
		451	if(base!=-1\|\|idx!=-1)goto runblock;
		452	base=BP; idx=DI; break;
		453	case 4:
		454	if(idx!=-1)goto runblock;
		455	idx=SI; break;
		456	case 5:
		457	if(idx!=-1)goto runblock;
		458	idx=DI; break;
		459	case 6:
		460	if(idx!=-1)goto runblock;
		461	base=BP; break;
		462	case 7:
		463	if(idx!=-1)goto runblock;
		464	base=BX; break;
		465	}
		466	}
		467	razr=r16;
		468	}
		469	else{
		470	if(cstok.rm!=rm_d32){
		471	rm=cstok.rm&0xC0;
		472	cstok.rm&=7;
		473	if(base==-1)base=cstok.rm;
		474	else if(idx==-1){
		475	idx=base;
		476	base=cstok.rm;
		477	}
		478	else goto runblock;
		479	if(base==4){
		480	base=cstok.sib&7;
		481	idx=(cstok.sib>>3)&7;
		482	if(base==5&&rm==0)base=-1;
		483	if(idx==4)idx=-1;
		484	}
		485	}
		486	else dstok.flag\|=cstok.flag&f_reloc;
		487	razr=r32;
		488	}
		489	break;
		490	//-----------------28.07.98 13:59-------------------
		491	// var[i]
		492	//--------------------------------------------------
		493	default:
		494	runblock:
		495	if(dsword2){
		496	CharToBackBuf('&');
		497	if(strinf.bufstr){
		498	free(strinf.bufstr);
		499	strinf.bufstr=NULL;
		500	}
		501	}
		502	AddBackBuf(sopenb,bcha);
		503	if(bufrm){
		504	if(strcmp(bufrm,"&this;")==0){
		505	free(bufrm);
		506	CharToBackBuf(0);
		507	sprintf((char )string3,"&%s%d+this;",BackTextBlock,GetVarSize(ttok));
		508	bufrm=BackString((char *)string3);
		509	// puts((char *)string3);
		510	goto con1;
		511	}
		512	else free(bufrm);
		513	}
		514	CharToBackBuf(';');
		515	CharToBackBuf(0);
		516	bufrm=(char *)REALLOC(BackTextBlock,SizeBackBuf+1);
		517	con1:
		518	if(cha!=']')blockerror();
		519	tokscan(&ctok,&cstok,pstring);
		520	if(itok4->sib>=CODE16)itok4->sib++;
		521	SRBackBuf(1);
		522	// if(itok4->post&POINTER)itok4->post=0;//&=NOTPOINTER;
		523	free(pstring);
		524	itok4->flag\|=flag;
		525	return;
		526	//-----------------28.07.98 13:59-------------------
		527	// end
		528	//--------------------------------------------------
		529	}
		530	if(dsword==1)dsword=0;
		531	if(nextscan){
		532	tokscan(&ctok,&cstok,pstring);
		533	whitespace();//�ய�� ᨬ��
		534	}
		535	while(ctok==tk_minus){
		536	if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
		537	whitespace();//�ய�� ᨬ��
		538	numrm+=cnum;
		539	flag^=cstok.flag;
		540	if(cstok.type!=tp_opperand&&cstok.type!=tp_stopper){
		541	operand=tk_plus;
		542	goto loopsw;
		543	}
		544	}
		545	operand=ctok;
		546	// printf("operand tok=%d flag=%08X %s\n",ctok,cstok.flag,cstok.name);
		547	if(ctok==tk_closeblock\|\|ctok==tokens\|\|ctok==tk_eof)break;
		548	if(ctok!=tk_plus&&ctok!=tk_mult)goto runblock;
		549	// flag\|=cstok.flag;
		550	}
		551	// printf("out idx=%d base=%d zoom=%d\n",idx,base,zoom);
		552	SRBackBuf(1);
		553	if(ctok!=tk_closeblock)expected(']');
		554	numrm*=sizevar;
		555	dstok.number+=numrm;
		556	if(razr==r16){
		557	if(idx==-1&&base==-1)cstok.rm=6;
		558	else{
		559	cstok.rm=CalcRm16(base,idx)\|rm_mod10;
		560	dstok.sib=CODE16;
		561	}
		562	}
		563	else if(razr==0){
		564	if(dstok.number<65536&&dstok.number>-65535)cstok.rm=6;
		565	else{
		566	cstok.rm=5;
		567	dstok.sib=0;
		568	}
		569	if(am32)cstok.rm=5;
		570	}
		571	else{
		572	// printf("razr=%d sib=%08X %s\n",razr,dstok.sib,dstok.name);
		573	if(dstok.sib>CODE32)dstok.sib-=CODE32;
		574	else dstok.sib=0;
		575	if(idx!=-1){
		576	cstok.rm=4;
		577	if(idx==4)preerror("ESP cannot be the index register");
		578	if(base!=-1)dstok.sib=(zoom<<6)+(idx<<3)+base;
		579	else{
		580	dstok.sib=(zoom<<6)+(idx<<3)+5;
		581	rm=(base==5?rm_mod10:0);
		582	}
		583	}
		584	else{
		585	if(base==4){
		586	dstok.sib=(4<<3)+4;
		587	cstok.rm=4;
		588	}
		589	else if(base==-1){
		590	cstok.rm=rm_d32;
		591	}
		592	else cstok.rm=base;
		593	}
		594	if(base!=-1\|\|rm!=0)cstok.rm\|=rm_mod10; //��४�� MOD �㤥� ��, � ᥩ�� ᨬ�
		595	}
		596	dstok.rm=cstok.rm;
		597	dstok.flag\|=flag;
		598	memcpy(itok4,&dstok,sizeof(ITOK));
		599	free(pstring);
		600	}
		601
		602
		603	{
		604	long value;
		605	unsigned int flag;
		606	if(*ctok==tk_minus){
		607	tokscan(ctok,cstok,(unsigned char *)cstring);
		608	if(*ctok!=tk_number)return(0);
		609	cstok->number=-cstok->number;
		610	}
		611	else if(*ctok!=tk_number)return(0);
		612	value=cstok->number;
		613	flag=cstok->flag;
		614	for(;;){
		615	int otok;
		616	tokscan(ctok,cstok,(unsigned char *)cstring);
		617	otok=*ctok;
		618	if(otok==tk_closeblock)break;
		619	tokscan(ctok,cstok,(unsigned char *)cstring);
		620	if(*ctok!=tk_number){
		621	if(*ctok==tk_reg32&&(otok==tk_mult\|\|otok==tk_minus)){
		622	*ctok=(unsigned int)cstok->number;
		623	*retval=value;
		624	cstok->flag=flag;
		625	return 0;
		626	}
		627	break;
		628	}
		629	if(calclongnumber(&value,cstok->number,otok)==FALSE){
		630	if(displaytokerrors)blockerror();
		631	break;
		632	}
		633	/* switch(otok){
		634	case tk_minus: value-=cstok->number; break;
		635	case tk_plus: value+=cstok->number; break;
		636	case tk_xor: value^=cstok->number; break;
		637	case tk_and: value&=cstok->number; break;
		638	case tk_or: value\|=cstok->number; break;
		639	case tk_mod: value%=cstok->number; break;
		640	case tk_div: value/=cstok->number; break;
		641	case tk_mult: value*=cstok->number; break;
		642	case tk_rr: value>>=cstok->number; break;
		643	case tk_ll: value<<=cstok->number; break;
		644	case tk_xorminus: value^=-cstok->number; break;
		645	case tk_andminus: value&=-cstok->number; break;
		646	case tk_orminus: value\|=-cstok->number; break;
		647	case tk_modminus: value%=-cstok->number; break;
		648	case tk_divminus: value/=-cstok->number; break;
		649	case tk_multminus: value*=-cstok->number; break;
		650	case tk_rrminus: value>>=-cstok->number; break;
		651	case tk_llminus: value<<=-cstok->number; break;
		652	default: if(displaytokerrors)blockerror(); goto end;
		653	}*/
		654	flag^=cstok->flag;
		655	}
		656	//end:
		657	cstok->flag=flag;
		658	*retval=value;
		659	return -1;
		660	}
		661
		662
		663	{
		664	if(razr==r32){
		665	unsigned char lreg[8];
		666	int i;
		667	for(i=0;i<8;i++){
		668	if(i==ESP\|\|i==EBP)lreg[i]=1;
		669	else{
		670	if((idx!=-1&&idx==i)\|\|(base!=-1&&base==i))lreg[i]=1;
		671	else lreg[i]=0;
		672	}
		673	// printf("%c",lreg[i]+'0');
		674	}
		675	if(lreg[reg1]==0)lreg[reg1]=1;
		676	else{
		677	for(i=7;i>=0;i--){ // fix by cppcheck, side effect - enable EAX
7626	siemargl	678	if(lreg[i]==0){
6446	GerdtR	679	lreg[i]=1;
		680	*reg1=i;
		681	break;
		682	}
		683	}
		684	}
		685	// printf("\nreg1=%d",*reg1);
		686	if(lreg[*reg2]!=0){
		687	for(i=7;i>=0;i--){ // fix by cppcheck, side effect - enable EAX
7626	siemargl	688	if(lreg[i]==0){
6446	GerdtR	689	*reg2=i;
		690	break;
		691	}
		692	}
		693	}
		694	// printf(" reg2=%d\n",*reg2);
		695	}
		696	else{
		697	if(base!=-1){
		698	if(base==reg1)reg1=SI;
		699	else if(base==reg2)reg2=DI;
		700	if(reg1==reg2){
		701	if(reg1==SI)reg2=DI;
		702	else *reg2=SI;
		703	}
		704	}
		705	if(idx!=-1){
		706	if(idx==SI)*reg1=DI;
		707	else *reg1=SI;
		708	*reg2=CX;
		709	}
		710	}
		711	}
		712
		713
		714	{
		715	int zoom0,idx0,base0,newreg;
		716	int zoom1=0,zoom2=0;
		717	char pv=FALSE;
		718	int razr=r32;
		719	//printf("sib=%X\n",ctok->sib);
		720	switch(ctok->sib){
		721	case CODE16+2:
		722	case CODE32+2: ctok->sib--;
		723	case CODE16+1:
		724	case CODE32+1: ctok->sib--;
		725	}
		726	if(ctok->sib==CODE16){
		727	razr=r16;
		728	if(am32)block16_32error();
		729	}
		730	if(buf==NULL&&strc->bufstr==NULL)return;
		731	ExpandRm(ctok->rm,ctok->sib,&zoom0,&base0,&idx0);
		732	if(base0==-1&&idx0!=-1&&zoom0==0){
		733	base0=idx0;
		734	idx0=-1;
		735	}
		736	CheckReg(idx0,base0,®1,®2,razr);
		737	// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
		738	if(buf!=NULL){
		739	if(*buf=='&'){
		740	sizeel=1;
		741	pv=TRUE;
		742	ctok->flag&=~f_reloc;
		743	}
		744	if((newreg=CheckIDXReg(buf,sizeel,reg1))!=NOINREG){
		745	if(newreg!=SKIPREG){
		746	if(razr==r16){
		747	if(newreg!=BX&&newreg!=DI&&newreg!=SI&&newreg!=BP)goto noopt;
		748	if(base0!=-1&&(newreg==BX\|\|newreg==BP))goto noopt;
		749	if(idx0!=-1&&(newreg==DI\|\|newreg==SI))goto noopt;
		750	}
		751	waralreadinitreg(regs[am32][reg1],regs[am32][newreg]);
		752	reg1=newreg;
		753	}
		754	free(buf);
		755	buf=NULL;
		756	}
		757	else{
		758	if(razr==r32){
		759	if((zoom1=CheckZoom(sizeel))){
		760	sizeel=1;
		761	if((newreg=CheckIDXReg(buf,sizeel,reg1))!=NOINREG){
		762	if(newreg!=SKIPREG){
		763	waralreadinitreg(regs[1][reg1],regs[1][newreg]);
		764	reg2=reg1;
		765	reg1=newreg;
		766	}
		767	free(buf);
		768	buf=NULL;
		769	goto cont1;
		770	}
		771	}
		772	}
		773	noopt:
		774	if(razr==r32&&idx0==-1&&base0==-1&&zoom1==0){
		775	ITOK wtok;
		776	wtok=*ctok;
		777	newreg=CheckMassiv(buf,sizeel,reg1,&idx0,&base0,&wtok.number);
		778	*ctok=wtok;
		779	// newreg=CheckMassiv(buf,sizeel,reg1);
		780	}
		781	else newreg=CheckMassiv(buf,sizeel,reg1);
		782	if(newreg!=-1){
		783	reg2=reg1;
		784	reg1=newreg;
		785	}
		786	}
		787	}
		788	else{
		789	reg2=reg1;
		790	reg1=-1;
		791	}
		792	cont1:
		793	// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
		794	if(strc->bufstr!=NULL){
		795	sizeel=strc->size;
		796	if((newreg=CheckIDXReg(strc->bufstr,sizeel,reg2))!=NOINREG){
		797	if(newreg!=SKIPREG){
		798	if(razr==r16){
		799	if(newreg!=BX&&newreg!=DI&&newreg!=SI&&newreg!=BP)goto noopt2;
		800	if(base0!=-1&&(newreg==BX\|\|newreg==BP))goto noopt2;
		801	if(idx0!=-1&&(newreg==DI\|\|newreg==SI))goto noopt2;
		802	}
		803	waralreadinitreg(regs[am32][reg2],regs[am32][newreg]);
		804	reg2=newreg;
		805	}
		806	free(strc->bufstr);
		807	strc->bufstr=NULL;
		808	}
		809	else{
		810	if(razr==r32&&zoom1==0){
		811	if((zoom2=CheckZoom(sizeel))){
		812	sizeel=1;
		813	if((newreg=CheckIDXReg(strc->bufstr,sizeel,reg2))!=NOINREG){
		814	if(newreg!=SKIPREG){
		815	waralreadinitreg(regs[2][reg1],regs[2][newreg]);
		816	reg2=newreg;
		817	}
		818	free(strc->bufstr);
		819	strc->bufstr=NULL;
		820	goto cont2;
		821	}
		822	}
		823	}
		824	noopt2:
		825	if((newreg=CheckMassiv(strc->bufstr,sizeel,reg2))!=-1)reg2=newreg;
		826	}
		827	cont2:
		828	if(reg1==-1){
		829	reg1=reg2;
		830	zoom1=zoom2;
		831	reg2=-1;
		832	zoom2=0;
		833	}
		834	}
		835	else reg2=-1;
		836	// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
		837	if(base0==-1){
		838	if(reg1!=-1&&zoom1==0){
		839	base0=reg1;
		840	reg1=reg2;
		841	zoom1=zoom2;
		842	reg2=-1;
		843	zoom2=0;
		844	}
		845	else if(reg2!=-1&&zoom2==0){
		846	base0=reg2;
		847	reg2=-1;
		848	}
		849	}
		850	if(idx0==-1){
		851	if(zoom1){
		852	zoom0=zoom1;
		853	zoom1=0;//zoom2;
		854	idx0=reg1;
		855	reg1=reg2;
		856	reg2=-1;
		857	}
		858	else{
		859	if(reg1!=-1){
		860	idx0=reg1;
		861	reg1=reg2;
		862	zoom1=zoom2;
		863	reg2=-1;
		864	zoom2=0;
		865	}
		866	}
		867	}
		868	// printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
		869	if(reg2!=-1){
		870	if(zoom1==0&&zoom2==0){
		871	op(3);
		872	op(0xC0+reg1*8+reg2); //add reg1,reg2
		873	}
		874	else{
		875	if(zoom1==0){
		876	op(0x8d); //lea reg1,[reg1+reg2*zoom2]
		877	op(reg1*8+4);
		878	op((zoom2<<6)+(reg2<<3)+reg1);
		879	}
		880	else{
		881	op(0x8d); //lea reg1,[reg2+reg1*zoom1]
		882	op(reg1*8+4);
		883	op((zoom1<<6)+(reg1<<3)+reg2);
		884	zoom1=0;
		885	}
		886	}
		887	ClearReg(reg1);
		888	}
		889	if(reg1!=-1){
		890	if(base0!=-1){
		891	if(zoom1==0){
		892	op(3);
		893	op(0xC0+reg1*8+base0); //add reg1,base0
		894	}
		895	else{
		896	op(0x8d); //lea reg1,[base0+reg1*zoom1]
		897	op(reg1*8+4);
		898	op((zoom1<<6)+(reg1<<3)+base0);
		899	}
		900	}
		901	else if(zoom1){
		902	op(0xC1);
		903	op(0xE0+reg1); //shl reg2,zoom2
		904	op(zoom1);
		905	}
		906	base0=reg1;
		907	}
		908	if(razr==r32){
		909	ctok->sib=CODE32;
		910	if(idx0!=-1){
		911	ctok->rm=4;
		912	if(base0!=-1){
		913	ctok->sib=(zoom0<<6)+(idx0<<3)+base0;
		914	ctok->rm\|=rm_mod10;
		915	}
		916	else ctok->sib=(zoom0<<6)+(idx0<<3)+5;
		917	}
		918	else{
		919	ctok->rm=base0;
		920	if(pv==FALSE)ctok->rm\|=rm_mod10;
		921	}
		922	}
		923	else{
		924	if(base0==SI\|\|base0==DI){
		925	if(idx0==BX\|\|idx0==BP\|\|idx0==-1){
		926	newreg=idx0;
		927	idx0=base0;
		928	base0=newreg;
		929	}
		930	else{
		931	op(3);
		932	op(0xC0+base0*8+idx0); //add base0,idx0
		933	idx0=base0;
		934	base0=-1;
		935	}
		936	}
		937	if(idx0==BX\|\|idx0==BP){
		938	if(base0==-1){
		939	newreg=idx0;
		940	idx0=base0;
		941	base0=newreg;
		942	}
		943	else{
		944	op(3);
		945	op(0xC0+base0*8+idx0); //add base0,idx0
		946	idx0=base0;
		947	base0=-1;
		948	}
		949	}
		950	ctok->rm=CalcRm16(base0,idx0)\|rm_mod10;
		951	}
		952	if(ctok->post==0&&(ctok->flag&f_reloc)==0)compressoffset(ctok);
		953	}
		954
		955
		956	{
		957	ITOK oitok;
		958	SINFO ostr;
		959	unsigned char *oldinput;
		960	unsigned int oldinptr,oldendinptr;
		961	unsigned char bcha;
		962	int otok;
		963	char *ostring;
		964	char *ofsst;
		965	int retcode=-1;
		966
		967
		968	COM_MOD *ocurmod=cur_mod;
		969	cur_mod=NULL;
		970	/////////////////
		971	ostring=BackString((char *)string);
		972	ofsst=BackString(buf);
		973	free(buf);
		974	buf=NULL;
		975	oldinput=input; //�� ६��
		976	oldinptr=inptr2;
		977	bcha=cha2;
		978	oldendinptr=endinptr;
		979	otok=tok;
		980	oitok=itok;
		981	ostr=strinf;
		982	strinf.bufstr=NULL;
		983
		984
		985	char *tbuf;
		986	int i;
		987	int idx0,base0;
		988	long numr;
		989	int operand;
		990	int startptr,skipvar;
		991	int firsttok;
		992	i=0;
		993	idx0=base0=-1;
		994	numr=0;
		995	if(*ofsst=='&')i++;
		996	tbuf=BackString(ofsst+i);
		997	// puts(tbuf);
		998	input=(unsigned char *)tbuf;
		999	inptr2=1;
		1000	cha2=input[0];
		1001	endinptr=strlen((char *)input);
		1002	operand=tk_plus;
		1003	startptr=0;
		1004	firsttok=tk_eof;
		1005	do{
		1006	skipvar=FALSE;
		1007	getoperand();
		1008	if(operand==tk_plus){
		1009	if(tok==tk_reg32){
		1010	if(itok.number!=treg){
		1011	skipvar=TRUE;
		1012	if(idx0==-1)idx0=itok.number;
		1013	else if(base0==-1)base0=itok.number;
		1014	else skipvar=FALSE;
		1015	}
		1016	else if(firsttok==tk_eof)firsttok=tk_reg32;
		1017	}
		1018	else if(tok==tk_number){
		1019	numr+=itok.number;
		1020	skipvar=TRUE;
		1021	}
		1022	else if(firsttok==tk_eof)firsttok=tok;
		1023	}
		1024	if(operand==tk_minus&&tok==tk_number){
		1025	numr-=itok.number;
		1026	skipvar=TRUE;
		1027	}
		1028	if(skipvar){
		1029	for(;startptr
		1030	}
		1031	startptr=inptr2-1;
		1032	nexttok();
		1033	if(tok==tk_plus\|\|tok==tk_minus){
		1034	if(firsttok==tk_eof){
		1035	if(tok==tk_minus)break;
		1036	for(;startptr
		1037	startptr=inptr2-1;
		1038	firsttok=tok;
		1039	}
		1040	operand=tok;
		1041	}
		1042	else break;
		1043	}while(1);
		1044	// printf("%s (%u) >%s\n",(startfileinfo+currentfileinfo)->filename,linenumber,tbuf);
		1045	if(tok==tk_semicolon/&&(idx0!=-1\|\|base0!=-1)/){
		1046	*idx=idx0;
		1047	*base=base0;
		1048	*num+=numr;
		1049	free(ofsst);
		1050	ofsst=tbuf;
		1051	// printf("idx0=%d base0=%d num=%d\n",idx0,base0,numr);
		1052	}
		1053	else free(tbuf);
		1054	}
		1055
		1056
		1057	inptr2=1;
		1058	cha2=input[0];
		1059	if(cha2=='&'){
		1060	inptr2=2;
		1061	cha2=input[1];
		1062	}
		1063	endinptr=strlen((char *)input);
		1064	getoperand();
		1065	if(am32&&sizeel==1&&tok==tk_reg32&&itok2.type==tp_stopper)retcode=itok.number;
		1066	else{
		1067	warningreg(regs[am32][treg]);
		1068	if((chip==7\|\|chip==8)&&am32==FALSE&&((sizeel>1&&sizeel<6)\|\|sizeel==8\|\|sizeel==9)){
		1069	//�� 饭�� ⭮�� ॣ��
		1070	op(0x31);
		1071	op(0xC0+treg*9);
		1072	}
		1073	ofsst=NULL;
		1074	if(treg==AX)do_e_axmath(0,(am32+1)*2,&ofsst);
		1075	else getintoreg(treg,(am32+1)*2,0,&ofsst);
		1076	IDXToReg((char *)input,sizeel,treg);
		1077	}
		1078	strinf=ostr;
		1079	tok=otok;
		1080	itok=oitok;
		1081	endoffile=0;
		1082	free(input);
		1083	input=oldinput;
		1084	inptr2=oldinptr;
		1085	cur_mod=ocurmod; //07.09.04 22:45
		1086	cha2=bcha;
		1087	endinptr=oldendinptr;
		1088	otok=0;
		1089	strcpy((char *)string,ostring);
		1090	free(ostring);
		1091	if(sizeel>1)RegMulNum(treg,sizeel,(am32+1)*2,0,&otok,0);
		1092	return retcode;
		1093	}
		1094
		1095
		1096	{
		1097	if(inptr
		1098	cha=input[inptr];
		1099	endoffile=0;
		1100	if(savestring3)string3[posstr3++]=cha;
		1101	inptr++;
		1102	precha=0;
		1103	if(inptr==endinptr&&cur_mod&&displaytokerrors){
		1104	precha=cur_mod->input[cur_mod->inptr];
		1105	// printf("cha=%02X\n",cha);
		1106	}
		1107	}
		1108	else{
		1109	if(cur_mod){
		1110	if(displaytokerrors){
		1111	inptr=cur_mod->inptr;
		1112	input=cur_mod->input;
		1113	// printf("last cha=%02X\n",input[inptr]);
		1114
		1115
		1116
		1117
		1118	linenumber=cur_mod->linenumber;
		1119	currentfileinfo=cur_mod->currentfileinfo;
		1120	COM_MOD *temp=cur_mod;
		1121	cur_mod=cur_mod->next;
		1122	if(temp->freze==FALSE){
		1123	if(temp->paramdef)free(temp->paramdef);
		1124	// if(debug)printf("Free curmod %08X new cur_mod %08X\n",temp,cur_mod);
		1125	free(temp);
		1126	}
		1127	// else if(debug)printf("Freze curmod %08X\n",temp);
		1128	nextchar();
		1129	// printf("%c\n",cha);
		1130	if(!cur_mod)notdef=TRUE;
		1131	}
		1132	else{
		1133	cha=cur_mod->input[cur_mod->inptr2];
		1134	cur_mod->inptr2++;
		1135	}
		1136	}
		1137	else{
		1138	cha=26;
		1139	endoffile++;
		1140	if(endoffile>2)unexpectedeof();
		1141	}
		1142	}
		1143	}
		1144
		1145
		1146	{
		1147	inptr2=inptr;
		1148	linenum2=linenumber;
		1149	cha2=cha;
		1150	displaytokerrors=0;
		1151	tokscan(&tok2,&itok2,string2);
		1152	}
		1153
		1154
		1155	{
		1156	unsigned int oinptr,oline,otok,rtok;
		1157	unsigned char ocha;
		1158	ITOK oitok;
		1159	ocha=cha;
		1160	oinptr=inptr;
		1161	oline=linenumber;
		1162	otok=tok;
		1163	oitok=itok;
		1164	do{
		1165	FastTok(1);
		1166	if(tok==tk_id\|\|tok==tk_ID){
		1167	char disp=displaytokerrors;
		1168	displaytokerrors=0;
		1169	strcpy((char *)string3,itok.name);
		1170	searchtree(&itok,&tok,string3); //NEW 09.06.06 20:29
		1171	// searchtree2(definestart,&itok,&tok,string3);
		1172	displaytokerrors=disp;
		1173	}
		1174	}while(tok==tk_endline);
		1175	rtok=tok;
		1176	tok=otok;
		1177	cha=ocha;
		1178	itok=oitok;
		1179	inptr=oinptr;
		1180	linenumber=oline;
		1181	return rtok;
		1182	}
		1183
		1184
		1185
		1186
		1187	{
		1188	#ifdef DEBUGMODE
		1189	if(debug)puts("start nexttok");
		1190	#endif
		1191	inptr=inptr2;
		1192	linenumber=linenum2;
		1193	cha=cha2;
		1194	displaytokerrors=1;
		1195	tokscan(&tok,&itok,string); //ࠧ��
		1196	// printf("input=%08X inptr=%08X tok=%d %s\n",input,inptr,tok,itok.name);
		1197	if(tok==tk_dblcolon&&numblocks){
		1198	skiplocals=TRUE;
		1199	tokscan(&tok,&itok,string); //ࠧ��
		1200	}
		1201	ScanTok2();
		1202	if(tok2==tk_dblcolon&&numblocks){
		1203	skiplocals=TRUE;
		1204	tokscan(&tok2,&itok2,string2);
		1205	}
		1206	if(tok2==tk_tilda){
		1207	if(ScanTok3()==tk_number){
		1208	tok2=tk_number;
		1209	// puts("tok2=tk_tilda tok3=tk_number");
		1210	}
		1211	}
		1212	linenumber=linenum2;
		1213	// new !!! 02.04.02 20:22
		1214	if(tok==tk_int&&idasm==TRUE&&tok2==tk_number){
		1215	tok=tk_idasm;
		1216	itok.rm=a_int;
		1217	}
		1218	// new !!! 02.04.02 20:22
		1219
		1220
		1221	if(debug)printdebuginfo();
		1222	#endif
		1223	if(tok2==tk_number){
		1224	if(tok==tk_not){
		1225	nexttok();
		1226	if(itok.rm!=tk_float&&itok.rm!=tk_double){
		1227	if(scanlexmode==RESLEX){
		1228	if(itok.number)itok.number=0;
		1229	else itok.number=1;
		1230	}
		1231	else itok.lnumber^=-1;
		1232	}
		1233	else illegalfloat();
		1234	return;
		1235	}
		1236	if(tok==tk_tilda){
		1237	// puts("tok=tk_tilda tok2=tk_number");
		1238	nexttok();
		1239	if(itok.rm!=tk_float&&itok.rm!=tk_double)itok.lnumber=~itok.lnumber;
		1240	else illegalfloat();
		1241	return;
		1242	}
		1243	}
		1244	if(idasm==TRUE&&tok==tk_loop&&tok2!=tk_openbracket){
		1245	tok=tk_idasm;
		1246	itok.rm=a_loop;
		1247	return;
		1248	}
		1249	if(tok==tk_dollar){
		1250	if(itok2.type==tp_opperand\|\|itok2.type==tp_stopper\|\|tok2==tk_dollar){
		1251	tok=tk_number;
		1252	itok.number=outptr;
		1253	if(FixUp)itok.flag\|=f_reloc; //new!!!
		1254	return;
		1255	}
		1256
		1257
		1258	if((qq=CheckAsmName(itok2.name))!=-1){
		1259	tok=tk_idasm;
		1260	itok.rm=qq;
		1261	strcpy(itok.name,itok2.name);
		1262	ScanTok2();
		1263	}
		1264
		1265
		1266	if(tok>=tk_charvar&&tok<=tk_doublevar){
		1267	localrec *ptr;
		1268	ptr=itok.locrec;
		1269	switch(itok.type){
		1270	case tp_paramvar:
		1271	// case tp_ppointer:
		1272	// case tp_pfpointer:
		1273	if(ptr->fuse==NOTINITVAR&&tok2==tk_assign&&(!asmparam))warningnotused(itok.name,4);
		1274	goto llq;
		1275	case tp_localvar:
		1276	// case tp_lpointer:
		1277	// case tp_lfpointer:
		1278	if(ptr->fuse==NOTINITVAR&&tok2!=tk_assign){
		1279	if(asmparam)ptr->fuse\|=INITVAR;
		1280	else warningusenotintvar(itok.name);
		1281	}
		1282	llq:
		1283	ptr->fuse\|=(unsigned char)(tok2==tk_assign?INITVAR:USEDVAR);
		1284	break;
		1285	}
		1286	#ifdef OPTVARCONST
		1287	if(calcnumber&&CheckConstVar(&itok))tok=tk_number;
		1288	#endif
		1289	}
		1290	#ifdef OPTVARCONST
		1291	if(tok2>=tk_charvar&&tok2<=tk_doublevar){
		1292	if(calcnumber&&CheckConstVar(&itok2))tok2=tk_number;
		1293	}
		1294	#endif
		1295	if(usedirectiv==FALSE&&calcnumber==FALSE)while(tok==tk_question)directive();
		1296	//16.08.04 00:23
		1297	if(tok==tk_at&&tok2==tk_macro){
		1298	nexttok();
		1299	}
		1300	#ifdef OPTVARCONST
		1301	displaytokerrors=1;
		1302	#endif
		1303
		1304
		1305
		1306
		1307
		1308
		1309	{
		1310	while(isspace(cha)\|\|cha==255\|\|cha==0){
		1311	if(cha==13){
		1312	linenumber++;
		1313	if((dbg&2)&&displaytokerrors&¬def)startline=(char*)(input+inptr+1);
		1314	if(scanlexmode==RESLEX\|\|scanlexmode==DEFLEX\|\|scanlexmode==ASMLEX)break;
		1315	}
		1316	nextchar();
		1317	}
		1318	}
		1319
		1320
		1321	//Returns the value of the current character. Parses \n and \x00 etc.
		1322	//cha equals the last character used.
		1323	{
		1324	int hold=0;
		1325	int i;
		1326	unsigned char c;
		1327	if(cha!='\\'){
		1328	if(cha==13){
		1329	linenumber++;
		1330	if((dbg&2)&&displaytokerrors&¬def)startline=(char*)(input+inptr+1);
		1331	}
		1332	return(cha);
		1333	}
		1334	nextchar(); // move past '\\'
		1335	switch(cha){
		1336	case 'a': return('\a'); // what is \a anyway?
		1337	case 'b': return('\b');
		1338	case 'f': return('\f');
		1339	case 'l': return(10);
		1340	case 'n': return(13);
		1341	// case 'p': return('�');
		1342	case 'r': return(13);
		1343	case 't': return('\t');
		1344	case 'v': return('\v');
		1345	case 'x':
		1346	for(i=0;i<2;i++){
		1347	c=cha;
		1348	nextchar();
		1349	hold*=16;
		1350	if(isdigit(cha))hold+=cha-'0';
		1351	else if(isxdigit(cha))hold+=(cha&0x5f)-'7';
		1352	else{
		1353	// expectederror("hexadecimal digit");
		1354	if(savestring3)posstr3--;
		1355	inptr--;
		1356	cha=c;
		1357	break;
		1358	}
		1359	}
		1360	return (unsigned char)hold;
		1361	default:
		1362	if(isdigit(cha)){
		1363	hold=cha-'0';
		1364	for(i=0;i<2;i++){
		1365	c=cha;
		1366	nextchar();
		1367	if(isdigit(cha))hold=hold*10+(cha-'0');
		1368	else{
		1369	// expectederror("decimal digit");
		1370	if(savestring3)posstr3--;
		1371	inptr--;
		1372	cha=c;
		1373	break;
		1374	}
		1375	}
		1376	return (unsigned char)hold;
		1377	}
		1378	return cha;
		1379	}
		1380	}
		1381
		1382
		1383	{
		1384	int k,j,i;
		1385	unsigned char c;
		1386	unsigned char hold;
		1387	for(k=0,j=0;;k++,j++){
		1388	c=str[k];
		1389	if(c=='\\'){
		1390	c=str[++k];
		1391	switch(c){
		1392	case 'a': hold='\a'; break; // what is \a anyway?
		1393	case 'b': hold='\b'; break;
		1394	case 'f': hold='\f'; break;
		1395	case 'l': hold=10; break;
		1396	case 'n': str[j++]=13; hold=10; break;
		1397	case 'r': hold=13; break;
		1398	case 't': hold='\t'; break;
		1399	case 'v': hold='\v'; break;
		1400	case 'x':
		1401	hold=0;
		1402	for(i=0;i<2;i++){
		1403	c=str[++k];
		1404	hold*=(unsigned char)16;
		1405	if(isdigit(c))hold+=(unsigned char)(c-'0');
		1406	else if(isxdigit(c))hold+=(unsigned char)((c&0x5f)-'7');
		1407	else{
		1408	k--;
		1409	break;
		1410	}
		1411	}
		1412	break;
		1413	default:
		1414	hold=c;
		1415	if(isdigit(c)){
		1416	hold-='0';
		1417	for(i=0;i<2;i++){
		1418	c=str[++k];
		1419	if(isdigit(c))hold=(unsigned char)(hold*10+(c-'0'));
		1420	else{
		1421	k--;
		1422	break;
		1423	}
		1424	}
		1425	}
		1426	}
		1427	str[j]=hold;
		1428	}
		1429	else str[j]=c;
		1430	if(c==0)break;
		1431	}
		1432	}
		1433
		1434
		1435	{
		1436	if(isalnum(cha)\|\|cha=='_'\|\|cha>=0x80)return TRUE;
		1437	return FALSE;
		1438	}
		1439
		1440
		1441	{
		1442	int strptr=0;
		1443	if(displaytokerrors){
		1444	savestring3=TRUE;
		1445	posstr3=0;
		1446	}
		1447	nextstr:
		1448	nextchar(); //��ப�� ⠭�
		1449	while(cha!='\"'&&!endoffile&&strptr
		1450	string4[strptr++]=convert_char();
		1451	if((char)cha=='n'&&string4[strptr-1]==13){//have to add char 10 for \n value
		1452	string4[strptr++]=10;
		1453	}
		1454	nextchar();
		1455	}
		1456	if(displaytokerrors){
		1457	savestring3=FALSE;
		1458	string3[posstr3-1]=0;
		1459	}
		1460	if(strptr>=(STRLEN-1)&&displaytokerrors)preerror("Maximum String Length Exceeded");
		1461	string4[strptr]=0;
		1462	*tok4=tk_string;
		1463	// itok4->number=strptr;
		1464	itok4->rm=1; //�� ਣ�� ப�
		1465	if(cha!='\"')expected('\"');
		1466	while(cha!='\"'&&!endoffile)nextchar(); //scan until closing '\"'
		1467	nextchar();
		1468	if(dosstring)itok4->flag=dos_term;
		1469	CheckConvertString((char *)string4);
		1470	switch(cha){
		1471	case 'z':
		1472	itok4->flag=zero_term;
		1473	nextchar();
		1474	break;
		1475	case 'n':
		1476	itok4->flag=no_term;
		1477	nextchar();
		1478	break;
		1479	case '$':
		1480	itok4->flag=dos_term;
		1481	nextchar();
		1482	break;
		1483	}
		1484	CheckConvertString((char *)string4);
		1485
		1486
		1487	whitespace(); //�ய�� ᨬ��
		1488	if(cha=='\"'){
		1489	if(displaytokerrors)savestring3=TRUE;
		1490	goto nextstr;
		1491	}
		1492
		1493
		1494	char *bak;
		1495	bak=BackString((char *)string4);
		1496	strptr=MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,bak,-1,(wchar_t *)string4,STRLEN)-1;
		1497	// printf("size string=%d\n",strptr);
		1498	// if(itok4->flag==no_term)strptr--;
		1499	strptr*=2;
		1500	// string4[strptr-2]=string4[strptr-1]=0;
		1501	itok4->flag\|=s_unicod;
		1502	free(bak);
		1503	}
		1504	itok4->number=strptr;
		1505	}
		1506
		1507
		1508	// �� 䨪��஢, ��४⨢ ...
		1509	{
		1510	int useme;
		1511	unsigned int strptr=0;
		1512	char uppercase=1,next=1;
		1513	//��⠭�� 㬮�砭��
		1514	#ifdef DEBUGMODE
		1515	if(debug)printf("start tokscan input=%08X inptr=%08X %c%s\n",input,inptr,cha,input+inptr);
		1516	#endif
		1517	if(am32==FALSE){
		1518	itok4->rm=rm_d16;
		1519	itok4->sib=CODE16;
		1520	}
		1521	else{
		1522	itok4->rm=rm_d32;
		1523	itok4->sib=CODE32;
		1524	}
		1525	itok4->segm=DS;
		1526	itok4->lnumber=0;
		1527	itok4->post=0;
		1528	itok4->flag=0;
		1529	itok4->size=0;
		1530	itok4->rec=NULL;
		1531	itok4->type=tp_ucnovn;
		1532	itok4->npointr=0;
		1533	itok4->name[0]=0;
		1534	whitespace(); //�ய�� ᨬ��
		1535	// if(displaytokerrors)printf("%c ",cha);
		1536	if(isalpha(cha)\|\|(cha=='_')\|\|(cha>=0x80)){ //��䨪��
		1537	do{
		1538	string4[strptr++]=cha;
		1539	if(islower(cha))uppercase=0;
		1540	nextchar();
		1541	}while((strptr
		1542	if(strptr>=IDLENGTH){ //�� 32
		1543	if(displaytokerrors)preerror("Maximum length for an identifier exceeded");
		1544	while(CheckChar2()==TRUE)nextchar(); //�� ᫮��
		1545	strptr=IDLENGTH-1; //��१�� 32
		1546	}
		1547	if(cha=='~'&&strptr
		1548	string4[strptr++]=cha;
		1549	nextchar();
		1550	if(cha!='('){
		1551	inptr--;
		1552	strptr--;
		1553	cha='~';
		1554	}
		1555	}
		1556	string4[strptr]=0;
		1557	strcpy(itok4->name,(char *)string4);
		1558	// if(displaytokerrors)printf("%s (%u) >%s\n",(startfileinfo+currentfileinfo)->filename,linenumber,itok4->name);
		1559	#ifdef DEBUGMODE
		1560	if (debug)printf("ID: '%s' cur_mod=%08X prev cur_mod=%08X\n",itok4->name,cur_mod,cur_mod==NULL?0:cur_mod->next);
		1561	#endif
		1562	if(scanlexmode==RESLEX){
		1563	if(stricmp((char )string4,"not")==0)tok4=tk_not;
		1564	else if(stricmp((char )string4,"or")==0)tok4=tk_or;
		1565	else if(stricmp((char )string4,"xor")==0)tok4=tk_xor;
		1566	else if(stricmp((char )string4,"and")==0)tok4=tk_and;
		1567	else{
		1568	if(uppercase)*tok4=tk_ID;
		1569	else *tok4=tk_id;
		1570	searchtree(itok4,tok4,string4);
		1571	if(tok4==tk_id\|\|tok4==tk_ID){
		1572	if((useme=CheckResName(itok4->name))!=-1){
		1573	*tok4=tk_rescommand;
		1574	itok4->number=useme;
		1575	}
		1576	}
		1577	}
		1578	return;
		1579	}
		1580	if(uppercase){ //��孨� ॣ��
		1581	if(strptr==1&&string4[0]=='L'&&cha=='"'){
		1582	itok4->name[0]=0;
		1583	GetTokString(tok4,itok4,string4,TRUE);
		1584	return;
		1585	}
		1586	*tok4=tk_ID;
		1587	if(string4[1]=='S'&&strptr>=5&&strptr<=8){
		1588	for(useme=0;useme
		1589	if(strcmp((char *)string4,id2[useme])==0){
		1590	*tok4=tk_charvar+useme%DATATYPES;
		1591	itok4->segm=useme/DATATYPES;
		1592	itok4->number=0;
		1593	itok4->post=POINTER;
		1594	goto yesid;
		1595	}
		1596	}
		1597	}
		1598	}
		1599	else *tok4=tk_id;
		1600	if(strptr==2){ //�� 2 ᨬ�� check for AX, CX, DX, ...
		1601	if((string4[0]&0x5f)=='S'&&(string4[1]&0x5f)=='T'){
		1602	if(cha=='('){
		1603	nextchar();
		1604	if(cha>='0'&&cha<='7'){
		1605	itok4->number=cha-'0';
		1606	nextchar();
		1607	if(cha!=')')expected(')');
		1608	nextchar();
		1609	*tok4=tk_fpust;
		1610	}
		1611	}
		1612	else{
		1613	itok4->number=0;
		1614	*tok4=tk_fpust;
		1615	}
		1616	return;
		1617	}
		1618	if(asmparam\|\|*tok4==tk_ID){
		1619	for(useme=0;useme<8;useme++){
		1620	int i;
		1621	if(asmparam)i=stricmp((char *)string4,regs[0][useme]);
		1622	else i=strcmp((char *)string4,regs[0][useme]);
		1623	if(i==0){
		1624	*tok4=tk_reg;
		1625	itok4->number=useme;
		1626	extreg:
		1627	if(cha=='.'){
		1628	tag_massiv(tok4,itok4,string4);
		1629	goto yesid;
		1630	}
		1631	return;
		1632	}
		1633	if(asmparam)i=stricmp((char *)string4,begs[useme]);
		1634	else i=strcmp((char *)string4,begs[useme]);
		1635	if(i==0){
		1636	*tok4=tk_beg;
		1637	itok4->number=useme;
		1638	return;
		1639	}
		1640	}
		1641	if(string4[1]=='S'\|\|(asmparam&&string4[1]=='s')){
		1642	for(useme=0;useme<6;useme++){ // check for CS, SS, ...
		1643	if(string4[0]==segs[useme][0]\|\|(asmparam&&(string4[0]&0x5F)==segs[useme][0])){
		1644	if(cha==':'){
		1645	int oinptr=inptr;
		1646	unsigned char ocha=cha;
		1647	int oline=linenumber;
		1648	nextchar();
		1649	/* switch(cha&(asmparam==FALSE?0xFF:0x5F)){
		1650	case 'E':
		1651	case 'B':
		1652	case 'S':
		1653	case 'D':*/
		1654	tokscan(tok4,itok4,string4);
		1655	if(tok4>=tk_bits&&tok4<=tk_doublevar){
		1656	itok4->segm=useme;
		1657	goto yesid;
		1658	}
		1659	// }
		1660	inptr=oinptr;
		1661	cha=ocha;
		1662	linenumber=oline;
		1663	}
		1664	*tok4=tk_seg;
		1665	itok4->number=useme;
		1666	return;
		1667	}
		1668	}
		1669	}
		1670	}
		1671	}
		1672	if(strptr==3&&(string4[0]=='E'\|\|(asmparam&&string4[0]=='e'))){// check for EAX, ECX, EDX, ...
		1673	for(useme=0;useme<8;useme++){
		1674	int i;
		1675	if(asmparam)i=stricmp((char *)&string4[1],regs[0][useme]);
		1676	else i=strcmp((char *)&string4[1],regs[0][useme]);
		1677	if(i==0){
		1678	*tok4=tk_reg32;
		1679	itok4->number=useme;
		1680	extreg32:
		1681	if(cha=='.'){
		1682	tag_massiv(tok4,itok4,string4);
		1683	goto yesid;
		1684	}
		1685	if(cha==':'){
		1686	int oinptr=inptr;
		1687	unsigned char ocha=cha;
		1688	int oline=linenumber;
		1689	nextchar();
		1690	tokscan(tok4,itok4,string4);
		1691	if(tok4==tk_reg32\|\|tok4==tk_reg){
		1692	itok4->number\|=useme*256;
		1693	*tok4=tk_reg64;
		1694	goto yesid;
		1695	}
		1696	inptr=oinptr;
		1697	cha=ocha;
		1698	linenumber=oline;
		1699	}
		1700	return;
		1701	}
		1702	}
		1703	}
		1704	if(asmparam){
		1705	if((string4[1]&0x5f)=='R'){
		1706	if(string4[2]>='0'&&string4[2]<='7'){
		1707	itok4->number=string4[2]-'0';
		1708	switch((string4[0]&0x5f)){
		1709	case 'C': *tok4=tk_controlreg; return;// check for CR0, CR1, ...
		1710	case 'D': *tok4=tk_debugreg; return;//check for DR0, DR1, ...
		1711	case 'T': *tok4=tk_testreg; return;//check for TR0, TR1, ...
		1712	default: itok4->number=0; break;
		1713	}
		1714	}
		1715	}
		1716	else if(((short )&string[0]&0x5f5f)==0x4d4d){
		1717	if(string4[2]>='0'&&string4[2]<='7'){
		1718	itok4->number=string4[2]-'0';
		1719	*tok4=tk_mmxreg;
		1720	return;
		1721	}
		1722	}
		1723	else if(((short )&string[1]&0x5f5f)==0x4d4d&&(string4[0]&0x5f)=='X'){
		1724	if(string4[3]>='0'&&string4[3]<='7'){
		1725	itok4->number=string4[3]-'0';
		1726	*tok4=tk_xmmreg;
		1727	return;
		1728	}
		1729	}
		1730	}
		1731	if(useasm==FALSE){
		1732	if((useme=FastSearch(id,idofs,2,(char )string4))!=-1)tok4=useme;
		1733	else if(idasm==TRUE&&(useme=CheckAsmName((char *)string4))!=-1){
		1734	*tok4=tk_idasm;
		1735	itok4->rm=useme;
		1736	return;
		1737	}
		1738	}
		1739	if(tok4==tk_id\|\|tok4==tk_ID){
		1740	if(cur_mod&&cur_mod->numparamdef&&(displaytokerrors\|\|scanalltoks)){//18.03.05 15:12
		1741	/* if(debug&&cur_mod){
		1742	printf("Find %s in %d entries curmod=%08X\n",itok4->name,cur_mod->numparamdef,cur_mod);
		1743	COM_MOD *nmod;
		1744	nmod=cur_mod;
		1745	while(nmod){
		1746	printf("\tinput=%08X inptr=%08X\n",nmod->input,nmod->inptr);
		1747	nmod=nmod->next;
		1748	}
		1749	}*/
		1750	if(CheckDefPar(itok4->name)){
		1751	tokscan(tok4,itok4,string4);
		1752	if(displaytokerrors==0){
		1753	inptr=cur_mod->inptr;
		1754	input=cur_mod->input;
		1755	endinptr=cur_mod->endinptr;
		1756	linenumber=cur_mod->linenumber;
		1757	currentfileinfo=cur_mod->currentfileinfo;
		1758	COM_MOD *temp=cur_mod;
		1759	cur_mod=cur_mod->next;
		1760	free(temp);
		1761	nextchar();
		1762	}
		1763	#ifdef DEBUGMODE
		1764	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*/);
		1765	#endif
		1766	return;
		1767	}
		1768	}
		1769	if(searchlocals(itok4,tok4,string4)==FALSE){//�� ।� �� ⮪
		1770	//�᫨ ��祣� �� ॢ� ��६��
		1771	searchtree(itok4,tok4,string4);
		1772	if(*tok4==tk_endline){
		1773	if(scanlexmode!=DEFLEX){
		1774	tokscan(tok4,itok4,string4);
		1775	#ifdef DEBUGMODE
		1776	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*/);
		1777	#endif
		1778	return;
		1779	}
		1780	*tok4=tk_macro;
		1781	}
		1782	if(tok4==tk_number\|\|tok4==tk_idasm)return;
		1783	if((tok4>=tk_bits&&tok4<=tk_doublevar)\|\|*tok4==tk_pointer){
		1784	if(itok4->rm==rm_d16\|\|itok4->rm==rm_d32){
		1785	if(am32==FALSE){
		1786	itok4->rm=rm_d16;
		1787	itok4->sib=CODE16;
		1788	}
		1789	else{
		1790	itok4->rm=rm_d32;
		1791	itok4->sib=CODE32;
		1792	}
		1793	}
		1794	if(itok4->post==DYNAMIC_POST){ //�८�ࠧ��
		1795	if(alignword&&tok4!=tk_charvar&&tok4!=tk_bytevar){ //��஢��
		1796	switch(*tok4){
		1797	case tk_intvar:
		1798	case tk_wordvar:
		1799	if(postsize%2==1)postsize++;
		1800	break;
		1801	default:
		1802	if(postsize%4!=0)postsize+=4-(postsize%4);
		1803	break;
		1804	}
		1805	}
		1806	idrec *ptr=itok4->rec;
		1807	itok4->post=ptr->recpost=1;
		1808	itok4->number=ptr->recnumber=postsize;
		1809	if(am32==FALSE&&(postsize+itok4->size)>0xFFFFL)tobigpost();
		1810	postsize+=itok4->size;
		1811	}
		1812	else if(itok4->post==DYNAMIC_VAR){
		1813	idrec *ptr=itok4->rec;
		1814	itok4->post=ptr->recpost=USED_DIN_VAR;
		1815	}
		1816	}
		1817	}
		1818	if(tok==tk_reg)goto extreg;
		1819	if(tok==tk_reg32)goto extreg32;
		1820	}
		1821	switch(*tok4){
		1822	int len;
		1823	case tk_dataptr: *tok4=tk_number; itok4->number=outptrdata;
		1824	if(FixUp)itok.flag\|=f_reloc; //new!!!
		1825	break;
		1826	case tk_codeptr: *tok4=tk_number; itok4->number=outptr;
		1827	if(FixUp)itok.flag\|=f_reloc; //new!!!
		1828	break;
		1829	case tk_postptr: *tok4=tk_number; itok4->number=postsize; break;
		1830	case tk_line: *tok4=tk_number; itok4->number=linenumber; break;
		1831	case tk_file:
		1832	*tok4=tk_string;
		1833	strcpy((char *)string4,(startfileinfo+currentfileinfo)->filename);
		1834	itok4->number=strlen((char *)string4);
		1835	break;
		1836	case tk_structvar:
		1837	struct idrec *ptrs;
		1838	ptrs=itok4->rec;
		1839	// puts(itok4->name);
		1840	dostructvar2(tok4,itok4,(structteg *)ptrs->newid,string4);
		1841	break;
		1842	case tk_sizeof:
		1843	dosizeof(itok4);
		1844	if(itok4->post)*tok4=tk_postnumber;
		1845	else *tok4=tk_number;
		1846	break;
		1847	case tk_signed:
		1848	case tk_unsigned:
		1849	case tk_int:
		1850	case tk_long:
		1851	case tk_short:
		1852	if(itok4->type!=tp_modif){
		1853	GetTypeVar(tok4);
		1854	itok4->type=tp_modif;
		1855	}
		1856	break;
		1857	case tk_ID:
		1858	// printf("%s %s %d %c\n",itok.name,string4,strptr,cha);
		1859	if(strlen(itok4->name)==1&&itok4->name[0]=='L'&&cha=='"'){
		1860	itok4->name[0]=0;
		1861	GetTokString(tok4,itok4,string4,TRUE);
		1862	return;
		1863	}
		1864	case tk_id:
		1865	if(findofset==FALSE){
		1866	struct structteg *tteg;
		1867	// if(displaytokerrors)printf("find teg %s cha=%02X\n",itok4->name,cha);
		1868	if(((tteg=FindTeg(FALSE,itok4->name))!=NULL\|\|
		1869	(tteg=FindTeg(TRUE,itok4->name))!=NULL)&&(cha=='.'\|\|precha=='.')){
		1870	// if(displaytokerrors)puts("finding");
		1871	dostructvar2(tok4,itok4,tteg,string4);
		1872	// printf("tok=%d\n",*tok4);
		1873	if(displaytokerrors&&(tok4==tk_proc\|\|tok4==tk_declare\|\|
		1874	*tok4==tk_undefproc)&&(itok4->flag&f_static)==0)unknownobj(itok4->name);
		1875	}
		1876	}
		1877	break;
		1878
		1879
		1880	if(*tok4==tk_string&&displaytokerrors){
		1881	strcpy((char )string3,(char )string4);
		1882	if(itok4->rm==2){
		1883	convert_string(string4);
		1884	itok4->rm--;
		1885	}
		1886	if(dosstring)itok.flag=dos_term;
		1887	}
		1888	yesid:
		1889	if((tok4>=tk_bits&&tok4<=tk_doublevar)\|\|*tok4==tk_pointer){
		1890	whitespace();//�ய�� ᨬ��
		1891	if(cha=='[')calcrm(itok4,*tok4);//��ࠡ�⪠ ��ࠦ�� []
		1892	}
		1893	if(itok4->rm!=rm_d16&&tok4!=tk_proc&&tok4!=tk_undefproc&&
		1894	tok4!=tk_apiproc&&tok4!=tk_declare&&(!(*tok4==tk_pointer&&itok4->type==tk_proc)))
		1895	if(itok4->post==0&&(itok4->flag&f_reloc)==0){ // cannot compress if POST var
		1896	compressoffset(itok4);
		1897	}
		1898	next=0;
		1899	}
		1900	else if(isdigit(cha)){//�᫠
		1901	inptr--;
		1902	itok4->lnumber=scannumber(&itok4->rm);
		1903	*tok4=tk_number;
		1904	next=0;
		1905	}
		1906	else switch(cha){
		1907	case '\"':
		1908	GetTokString(tok4,itok4,string4,FALSE);
		1909	next=0;
		1910	break;
		1911	case '\'': //ᨬ��쭠� ��⠭� �� 1 ᨬ��
		1912	nextchar();
		1913	next=0;
		1914	if(scanlexmode==RESLEX){
		1915	*tok4=tk_singlquote;
		1916	break;
		1917	}
		1918	*tok4=tk_number;
		1919	itok4->number=0;
		1920	while(cha!='\''&&!endoffile){ // special character
		1921	itok4->lnumber=itok4->lnumber*256+convert_char();
		1922	nextchar();
		1923	}
		1924	if(cha!='\''){
		1925	if(displaytokerrors)expected('\'');
		1926	}
		1927	else nextchar();
		1928	next=0;
		1929	break;
		1930	case '-':
		1931	nextchar();
		1932	switch(cha){
		1933	case '=': *tok4=tk_minusequals; break; //�� ࠢ��
		1934	case '-': *tok4=tk_minusminus; break; //��-��
		1935	default: *tok4=tk_minus; next = 0; itok4->type=tp_opperand; break;//��
		1936	}
		1937	break;
		1938	case '+':
		1939	nextchar();
		1940	switch(cha){
		1941	case '=': *tok4=tk_plusequals; break; //�� ࠢ��
		1942	case '+': *tok4=tk_plusplus; break; //��-��
		1943	default: whitespace(); // spaces allowed between
		1944	if(cha=='-')*tok4=tk_minus; // optimization of + -
		1945	else{
		1946	*tok4=tk_plus; //��
		1947	next=0;
		1948	}
		1949	itok4->type=tp_opperand;
		1950	break;
		1951	}
		1952	break;
		1953	case '*':
		1954	nextchar();
		1955	switch(cha){
		1956	case '=': *tok4=tk_multequals; break;
		1957	case '-': *tok4=tk_multminus; break; //㬭��
		1958	default:
		1959	*tok4=tk_mult; //㬭��
		1960	next=0;
		1961	}
		1962	itok4->type=tp_opperand;
		1963	break;
		1964	case '/': nextchar();
		1965	switch(cha){
		1966	case '*': nextchar(); //ᮬ��਩
		1967	useme=1;
		1968	while(!endoffile&&useme>0){
		1969	whitespace();
		1970	if(cha=='*'){
		1971	nextchar();
		1972	if(cha=='/'){
		1973	nextchar();
		1974	if(cha=='/')nextchar();
		1975	else useme--;
		1976	}
		1977	continue;
		1978	}
		1979	else if(cha=='/'){
		1980	nextchar();
		1981	if(cha=='*')useme++;
		1982	else if(cha=='/'){
		1983	nextchar();
		1984	continue;
		1985	}
		1986	else continue;
		1987	}
		1988	nextchar();
		1989	}
		1990	if(endoffile){
		1991	*tok4=tk_eof;
		1992	if(useme>0&&displaytokerrors)unexpectedeof();
		1993	}
		1994	else tokscan(tok4,itok4,string4);
		1995	break;
		1996	case '/':
		1997	do{
		1998	nextchar();
		1999	}while(!endoffile&&cha!=13); //��ப� ��
		2000	if(endoffile)*tok4=tk_eof;
		2001	else{
		2002	if(scanlexmode==DEFLEX)*tok4=tk_endline;
		2003	else{
		2004	whitespace();
		2005	if(cha==13)nextchar();
		2006	tokscan(tok4,itok4,string4);
		2007	}
		2008	}
		2009	break;
		2010	case '=': *tok4=tk_divequals; nextchar(); return;
		2011	default:
		2012	whitespace();
		2013	if(cha=='-'){
		2014	*tok4=tk_divminus; //��
		2015	nextchar();
		2016	}
		2017	else *tok4=tk_div;
		2018	itok4->type=tp_opperand;
		2019	break;
		2020	}
		2021	next=0;
		2022	break;
		2023	case '%':
		2024	nextchar();
		2025	whitespace();
		2026	if(cha=='-')*tok4=tk_modminus; //��⮪ ��
		2027	else{
		2028	*tok4=tk_mod;
		2029	next=0;
		2030	}
		2031	itok4->type=tp_opperand;
		2032	break;
		2033	case '\|':
		2034	nextchar();
		2035	switch(cha){
		2036	case '=': *tok4=tk_orequals; break; //OR=
		2037	case '\|': *tok4=tk_oror; break; //OR-OR
		2038	default:
		2039	whitespace();
		2040	if(cha=='-')*tok4=tk_orminus; //OR-
		2041	else{
		2042	*tok4=tk_or;
		2043	if(cha==13)nextchar(); //OR
		2044	next=0;
		2045	}
		2046	itok4->type=tp_opperand;
		2047	break;
		2048	}
		2049	break;
		2050	case '&':
		2051	nextchar();
		2052	switch(cha){
		2053	case '=': *tok4=tk_andequals; break; //AND=
		2054	case '&': *tok4=tk_andand; break;
		2055	default:
		2056	whitespace();
		2057	if(cha=='-')*tok4=tk_andminus;
		2058	else{
		2059	*tok4=tk_and;
		2060	next=0;
		2061	}
		2062	itok4->type=tp_opperand;
		2063	break;
		2064	}
		2065	break;
		2066	case '!':
		2067	nextchar();
		2068	if(cha=='='){
		2069	*tok4=tk_notequal; //!=
		2070	itok4->type=tp_compare;
		2071	}
		2072	else{
		2073	*tok4=tk_not;
		2074	next=0;
		2075	}
		2076	break;
		2077	case '^':
		2078	nextchar();
		2079	if(cha=='=')*tok4=tk_xorequals; //XOR=
		2080	else{
		2081	whitespace();
		2082	if(cha=='-')*tok4=tk_xorminus;
		2083	else{
		2084	*tok4=tk_xor;
		2085	next=0;
		2086	}
		2087	itok4->type=tp_opperand;
		2088	}
		2089	break;
		2090	case '=':
		2091	nextchar();
		2092	if(cha=='='){
		2093	*tok4=tk_equalto; //==
		2094	itok4->type=tp_compare;
		2095	}
		2096	else{
		2097	*tok4=tk_assign; //��᢮��
		2098	next=0;
		2099	}
		2100	break;
		2101	case '>':
		2102	nextchar();
		2103	switch(cha){
		2104	case '>':
		2105	nextchar();
		2106	if(cha=='=')*tok4=tk_rrequals; //ᤢ�� ࠢ� � ��᢮��
		2107	else{
		2108	whitespace();
		2109	if(cha=='-')*tok4 = tk_rrminus;
		2110	else{
		2111	*tok4=tk_rr; //ᤢ�� ࠢ�
		2112	next=0;
		2113	}
		2114	itok4->type=tp_opperand;
		2115	}
		2116	break;
		2117	case '<': *tok4=tk_swap; break; //��
		2118	case '=': *tok4=tk_greaterequal; itok4->type=tp_compare; break; //�� ࠢ��
		2119	default: *tok4=tk_greater; next=0; itok4->type=tp_compare; break; //��
		2120	}
		2121	break;
		2122	case '<':
		2123	nextchar();
		2124	switch(cha){
		2125	case '<':
		2126	nextchar();
		2127	if(cha=='=')*tok4=tk_llequals; //ᤢ�� ᢮��
		2128	else{
		2129	whitespace();
		2130	if(cha=='-')*tok4=tk_llminus;
		2131	else{
		2132	*tok4=tk_ll; //ᤢ��
		2133	next=0;
		2134	}
		2135	itok4->type=tp_opperand;
		2136	}
		2137	break;
		2138	case '>': *tok4=tk_notequal; itok4->type=tp_compare; break; //!=
		2139	case '=': *tok4=tk_lessequal; itok4->type=tp_compare; break; //�� ࠢ��
		2140	default: *tok4=tk_less; next=0; itok4->type=tp_compare; break;//��
		2141	}
		2142	break;
		2143	case '#':
		2144	next=0;
		2145	nextchar();
		2146	findofset=TRUE;
		2147	tokscan(tok4,itok4,string4);
		2148	findofset=FALSE;
		2149	if((useme=GetDirective((char *)string4))!=-1){
		2150	itok4->number=useme;
		2151	*tok4=tk_question;
		2152	break;
		2153	}
		2154	if(*tok4==tk_dblcolon){
		2155	skiplocals=TRUE;
		2156	tokscan(tok4,itok4,string4);
		2157	}
		2158	/* char buf[16];
		2159	strncpy(buf,(char *)(input+inptr),15);
		2160	buf[15]=0;*/
		2161	// 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*/);
		2162	// printf("skiplocals=%d skipfind=%d searchteg=%08X\n",skiplocals,skipfind,searchteg);
		2163	switch(*tok4){
		2164	case tk_structvar:
		2165	// printf("%08X %s\n",itok4->sib,itok4->name);
		2166	if((itok4->sib&1)==0){
		2167	ofsstr(tok4,itok4);
		2168	// 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*/);
		2169	break;
		2170	}
		2171	itok4->rm=(am32==0?rm_d16:rm_d32);
		2172	case tk_struct:
		2173	*tok4=tk_number;
		2174	if(bufrm){
		2175	*tok4=tk_rmnumber;
		2176	if(itok4->type==tp_classvar)itok4->flag\|=f_useidx;
		2177	}
		2178	break;
		2179	case tk_apiproc: //!!!16.12.06 23:06
		2180	itok4->rm=tk_undefofs;
		2181	*tok4=tk_apioffset;
		2182	if(FixUp)itok4->flag\|=f_reloc; //new!!! 27.06.05 22:25
		2183	strcpy((char *)string4,itok4->name);
		2184	// 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*/);
		2185	break;
		2186	case tk_proc:
		2187	case tk_interruptproc:
		2188	if(cha=='.')goto structofs;
		2189	procofs:
		2190	if(itok4->segm!=NOT_DYNAMIC){
		2191	if(displaytokerrors){
		2192	idrec *ptr=itok4->rec;
		2193	itok4->segm=ptr->recsegm=DYNAMIC_USED;
		2194	}
		2195	itok4->rm=*tok4=tk_undefofs; //ᬥ饭�� ⭮� ��⪨
		2196	itok4->number=0;
		2197	// if(FixUp)itok4->flag\|=f_reloc; //new!!! 27.06.05 22:25
		2198	}
		2199	else{
		2200	*tok4=tk_number;
		2201	itok4->segm=CS;//(splitdata==FALSE)?DS:CS;
		2202	// if(FixUp)itok4->flag\|=f_reloc;
		2203	}
		2204	if(FixUp)itok4->flag\|=f_reloc; //new!!! 27.06.05 22:25
		2205	strcpy((char *)string4,itok4->name);
		2206	// 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*/);
		2207	break;
		2208	case tk_id:
		2209	case tk_ID:
		2210	structofs:
		2211	struct structteg *tteg;
		2212	if(((tteg=FindTeg(FALSE,itok4->name))!=NULL\|\|
		2213	(tteg=FindTeg(TRUE,itok4->name))!=NULL)/&&cha=='.'/){
		2214	dostructvar2(tok4,itok4,tteg,string4);
		2215	// 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*/);
		2216
		2217
		2218
		2219
		2220	// printf("tok=%d segm=%d %s\n",*tok4,itok4->segm,itok4->name);
		2221	if(strinf.bufstr){
		2222	*tok4=tk_rmnumber;
		2223	if(itok4->type==tp_classvar)itok4->flag\|=f_useidx;
		2224	}
		2225	else{
		2226	if(FixUp&&*tok4==tk_proc)itok4->flag\|=f_reloc; //new!!!
		2227	else itok4->flag&=~f_reloc;
		2228	// else itok4->flag&=!f_reloc; 16.08.04 18:51
		2229
		2230
		2231	if(itok4->post){
		2232	*tok4=tk_postnumber;
		2233	itok4->rm=tk_undefofs;
		2234	}
		2235	else
		2236	/////
		2237
		2238
		2239	}
		2240	}
		2241	else{
		2242	undefofs:
		2243	itok4->rm=*tok4=tk_undefofs; //ᬥ饭�� ⭮� ��⪨
		2244	itok4->number=0;
		2245	if(FixUp)itok4->flag\|=f_reloc; //new!!!
		2246	}
		2247	case tk_number:
		2248	case tk_rmnumber:
		2249	break;
		2250	case tk_reg:
		2251	case tk_reg32:
		2252	itok4->rm=RegToRM(itok4->number,tok4)/\|rm_mod10*/;
		2253	*tok4=(am32==0?tk_wordvar:tk_dwordvar);//tk_rmnumber;
		2254	itok4->number=0;
		2255	break;
		2256	default:
		2257	if(cha=='.')goto structofs;
		2258	if((tok4>=tk_bits&&tok4<=tk_doublevar)\|\|tok==tk_pointer){
		2259	#ifdef OPTVARCONST
		2260	if(displaytokerrors)ClearVarByNum(itok4);
		2261	#endif
		2262	switch(itok4->type){
		2263	case tp_localvar:
		2264	case tp_paramvar:
		2265	localrec *ptr;
		2266	ptr=itok4->locrec;
		2267	ptr->fuse\|=(unsigned char)(INITVAR\|USEDVAR);
		2268	break;
		2269	case tk_proc:
		2270	itok4->rm=itok4->sib;
		2271	itok4->sib=am32==0?CODE16:CODE32;
		2272	break;
		2273	}
		2274	itok4->size=GetVarSize(*tok4);
		2275	if((itok4->sib==CODE16&&itok4->rm==rm_d16)\|\|
		2276	(itok4->sib==CODE32&&itok4->rm==rm_d32)){
		2277	if(itok4->post==0){
		2278	*tok4=tk_number;
		2279	itok4->segm=DS;
		2280	if(FixUp)itok4->flag\|=f_reloc;
		2281	itok4->rm=am32==FALSE?tk_word:tk_dword;
		2282	}
		2283	else{
		2284	*tok4=tk_postnumber;
		2285	itok4->rm=tk_undefofs;
		2286	}
		2287	}
		2288	else{
		2289	*tok4=tk_rmnumber;
		2290	if(itok4->type==tp_classvar)itok4->flag\|=f_useidx;
		2291	}
		2292	}
		2293	else{
		2294	itok4->rm=*tok4=tk_undefofs; //ᬥ饭�� ⭮� ��⪨
		2295	itok4->number=0;
		2296	strcpy((char *)string4,itok4->name);
		2297	}
		2298	break;
		2299	}
		2300	itok4->type=tp_ofs;
		2301	// if(displaytokerrors)printf("name=%s tok=%d post=%d flag=%08X rm=%d\n",itok4->name,*tok4,itok4->post,itok4->flag,itok4->rm);
		2302	break;
		2303	case '(':
		2304	if((unsigned short )&(input[inptr])==
		2305	#ifdef _WC_
		2306	')E'
		2307	#else
		2308	'E)'
		2309	#endif
		2310	\|\|
		2311	((unsigned short )&(input[inptr])==
		2312	#ifdef _WC_
		2313	')e'
		2314	#else
		2315	'e)'
		2316	#endif
		2317	)){
		2318	for(useme=0;useme<8;useme++){
		2319	int i;
		2320	if(asmparam)i=strnicmp((char *)input+inptr+2,regs[0][useme],2);
		2321	else i=strncmp((char *)input+inptr+2,regs[0][useme],2);
		2322	if(i==0){
		2323	inptr+=4;
		2324	nextchar();
		2325	itok4->number=useme;
		2326	if(am32){
		2327	*tok4=tk_reg32;
		2328	goto extreg32;
		2329	}
		2330	*tok4=tk_reg;
		2331	goto extreg;
		2332	}
		2333	}
		2334	}
		2335	*tok4=tk_openbracket;
		2336	break;
		2337	case ':':
		2338	nextchar();
		2339	if(cha!=':'){
		2340	next=0;
		2341	*tok4=tk_colon;
		2342	}
		2343	else *tok4=tk_dblcolon;
		2344	break;
		2345	case ';': itok4->type=tp_stopper; *tok4=tk_semicolon; break;
		2346	case ')': itok4->type=tp_stopper; *tok4=tk_closebracket; break;
		2347	case '{': *tok4=tk_openbrace; break;
		2348	case '}': itok4->type=tp_stopper; *tok4=tk_closebrace; break;
		2349	case '[': *tok4=tk_openblock; break;
		2350	case ']': itok4->type=tp_stopper; *tok4=tk_closeblock; break;
		2351	case ',': itok4->type=tp_stopper; *tok4=tk_camma; break;
		2352	case '.':
		2353	next=0;
		2354	nextchar();
		2355	if(cha!='.'){
		2356	*tok4=tk_period;
		2357	break;
		2358	}
		2359	nextchar();
		2360	if(cha!='.'){
		2361	badtoken();
		2362	nextchar();
		2363	tokscan(tok4,itok4,string4);
		2364	break;
		2365	}
		2366	nextchar();
		2367	*tok4=tk_multipoint;
		2368	break;
		2369	case '@': *tok4=tk_at; break;
		2370	case '$': *tok4=tk_dollar; break;
		2371	case '?':
		2372	nextchar();
		2373	tokscan(tok4,itok4,string4);
		2374	*tok4=tk_question;
		2375	itok4->number=GetDirective((char *)string4);
		2376	return;
		2377	case '~': *tok4=tk_tilda; break;
		2378	case 26: *tok4=tk_eof; return;
		2379	case 13: *tok4=tk_endline; break;
		2380	case '\\':
		2381	nextchar();
		2382	if(cha==13){
		2383	tokscan(tok4,itok4,string4);
		2384	if(*tok4==tk_endline)tokscan(tok4,itok4,string4);
		2385	return;
		2386	}
		2387	default:
		2388	badtoken();
		2389	nextchar();
		2390	tokscan(tok4,itok4,string4);
		2391	return;
		2392	}
		2393	if(next)nextchar();
		2394	#ifdef DEBUGMODE
		2395	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);
		2396	#endif
		2397	}
		2398
		2399
		2400
		2401	{
		2402	COM_MOD *newm;
		2403	int oline;
		2404	int numpar=0,ns,i,size,nsize;
		2405	char *buf=NULL;
		2406	newm=(COM_MOD *)MALLOC(sizeof(COM_MOD));
		2407	newm->numparamdef=numipar;
		2408	newm->freze=FALSE;
		2409	size=0;
		2410	whitespace();
		2411	if(cha=='('){
		2412	nextchar();
		2413	whitespace();
		2414	if(cha!=')'){
		2415	inptr--;
		2416	oline=linenumber;
		2417	for(i=inptr,ns=1;ns>0;i++){ //�� ࠬ��஢
		2418	switch(input[i]){
		2419	case '(': ns++; break;
		2420	case ')': ns--; break;
		2421	case ',':
		2422	if(ns==1){
		2423	numpar++;
		2424	nsize=i-inptr;
		2425	if(!buf)buf=(char *)MALLOC(nsize+1);
		2426	else buf=(char *)REALLOC(buf,size+nsize+1);
		2427	strncpy(buf+size,(char *)(input+inptr),nsize);
		2428	buf[size+nsize]=0;
		2429	strbtrim(buf+size);
		2430	// puts(buf+size);
		2431	size+=strlen(buf+size)+1;
		2432	inptr+=nsize+1;
		2433	}
		2434	break;
		2435	case '/':
		2436	i=skipcomment(i);
		2437	break;
		2438	case '"':
		2439	case 0x27:
		2440	i=skipstring(i,input[i]);
		2441	break;
		2442	}
		2443	if((unsigned int)i>=endinptr){
		2444	unexpectedeof();
		2445	break;
		2446	}
		2447	}
		2448	linenumber=oline;
		2449	numpar++;
		2450	nsize=i-inptr;
		2451	if(!buf)buf=(char *)MALLOC(nsize);
		2452	else buf=(char *)REALLOC(buf,size+nsize);
		2453	strncpy(buf+size,(char *)(input+inptr),nsize-1);
		2454	buf[size+nsize-1]=0;
		2455	strbtrim(buf+size);
		2456	// puts(buf+size);
		2457	inptr=i;
		2458	}
		2459	if(numipar>numpar)missingpar(itok.name);
		2460	else if(numipar
		2461	newm->numparamdef=numpar;
		2462	}
		2463	else inptr--;
		2464	newm->input=input;
		2465	newm->inptr2=newm->inptr=inptr;
		2466	newm->endinptr=endinptr;
		2467	newm->linenumber=linenumber;
		2468	newm->currentfileinfo=currentfileinfo;
		2469	newm->paramdef=buf;
		2470	newm->next=cur_mod;
		2471	cur_mod=newm;
		2472	// if(debug)printf("New curmod %08X numpar=%d input=%08X prev curmod=%08X\n",cur_mod,numipar,input,cur_mod->next);
		2473	nextchar();
		2474	/* char *temp=buf;
		2475	for(i=0;i
		2476	nsize=strlen(temp)+1;
		2477	puts(temp);
		2478	temp+=nsize;
		2479	}*/
		2480	}
		2481
		2482
		2483	{
		2484	if(cur_mod){
		2485	inptr=cur_mod->inptr;
		2486	inptr2=cur_mod->inptr2;
		2487	input=cur_mod->input;
		2488	endinptr=cur_mod->endinptr;
		2489	linenumber=cur_mod->linenumber;
		2490	currentfileinfo=cur_mod->currentfileinfo;
		2491	cur_mod=cur_mod->next;
		2492	cha2=input[inptr2];
		2493	}
		2494	}
		2495
		2496
		2497	{
		2498	char *temp;
		2499	int i,numpar,nsize=0;
		2500	numpar=cmod->numparamdef;
		2501	temp=cmod->declareparamdef;
		2502	// if(debug)printf("check for %s\n",name);
		2503	for(i=0;i
		2504	nsize=strlen(temp)+1;
		2505	// if(debug)printf("\t%s\n",temp);
		2506	if(strcmp(name,temp)==0){
		2507	temp=cmod->paramdef;
		2508	for(;i>0;i--){
		2509	temp+=strlen(temp)+1;
		2510	}
		2511	return temp;
		2512	}
		2513	temp+=nsize;
		2514	}
		2515	return NULL;
		2516	}
		2517
		2518
		2519	{
		2520	char temp,nname;
		2521	COM_MOD *fmod;
		2522	fmod=cur_mod;
		2523	nname=name;
		2524	while((temp=FindDefPar(nname,fmod))!=NULL){
		2525	nname=temp;
		2526	if(fmod->next==NULL)break;
		2527	fmod=fmod->next;
		2528	}
		2529	if(fmod==cur_mod&&temp==NULL)return FALSE;
		2530	SetNewStr(nname);
		2531	return TRUE;
		2532	}
		2533
		2534
		2535	{
		2536	COM_MOD *fmod;
		2537	fmod=(COM_MOD *)MALLOC(sizeof(COM_MOD));
		2538	fmod->next=cur_mod;
		2539	fmod->numparamdef=0;
		2540	fmod->paramdef=NULL;
		2541	fmod->freze=FALSE;
		2542	fmod->input=input;
		2543	fmod->inptr2=fmod->inptr=inptr-1;
		2544	fmod->endinptr=endinptr;
		2545	fmod->linenumber=linenumber;
		2546	fmod->currentfileinfo=currentfileinfo;
		2547	cur_mod=fmod;
		2548	// if(debug)printf("new curmod %08X prev cur_mod=%08X old input %08X %s\n",cur_mod,cur_mod->next,input,name);
		2549	input=(unsigned char*)(name);
		2550	inptr=1;
		2551	cha=input[0];
		2552	endinptr=strlen(name)+1;
		2553	}
		2554
		2555
		2556	//�� ॢ� ��६��
		2557	{
		2558	struct idrec *ptr;
		2559	int cmpresult;
		2560	for(ptr=fptr;ptr!=NULL;){
		2561	if((cmpresult=strcmp(ptr->recid,(char *)string4))==0){
		2562	if(scanlexmode==RESLEX&&ptr->rectok!=tk_number&&ptr->rectok!=tk_string)break;
		2563	itok4->lnumber=ptr->reclnumber;
		2564	itok4->rm=ptr->recrm;
		2565	*tok4=ptr->rectok;
		2566	itok4->post=ptr->recpost;
		2567	itok4->segm=ptr->recsegm;
		2568	itok4->flag\|=ptr->flag;
		2569	itok4->size=ptr->recsize;
		2570	itok4->sib=ptr->recsib;
		2571	itok4->rec=ptr;
		2572	itok4->type=ptr->type;
		2573	itok4->npointr=ptr->npointr;
		2574	// if(debug)printf("Find: tok=%d\n",*tok4);
		2575	if(displaytokerrors){
		2576	ptr->count++;
		2577	// printf("%s notdoneprestuff=%d tok=%d segm=%d\n",itok4->name,notdoneprestuff,*tok4,itok4->segm);
		2578	if(notdoneprestuff==2&&*tok4==tk_proc&&itok4->segm==DYNAMIC)AddDynamicList(ptr);
		2579	}
		2580	if(*tok4==tk_macro){
		2581	// printf("tok=%d %s %s\n",*tok4,itok4->name,input);
		2582	if(dirmode==dm_if)return TRUE;
		2583	if(scanlexmode==DEFLEX\|\|scanlexmode==DEFLEX2)*tok4=tk_id;
		2584	else if(displaytokerrors){
		2585	NewMod(itok4->size);
		2586	notdef=FALSE;
		2587	cur_mod->declareparamdef=ptr->newid;
		2588	input=(unsigned char*)(ptr->sbuf);
		2589	inptr=1;
		2590	cha=input[0];
		2591	endinptr=strlen((char *)input);
		2592	// if(debug)printf("New cur_mod tok=%d numpar=%d %s %s\n",*tok4,cur_mod->numparamdef,itok4->name,input);
		2593	// debug=TRUE;
		2594	clearregstat();
		2595	*tok4=tk_endline;
		2596	return TRUE;
		2597	}
		2598	}
		2599	else if(ptr->newid){
		2600	switch(*tok4){
		2601	case tk_string:
		2602	memcpy((char *)string4,ptr->newid,itok4->number);
		2603	if(displaytokerrors&&itok4->rm==1&&ptr->sbuf)strcpy((char *)string3,ptr->sbuf);
		2604	break;
		2605	case tk_structvar:
		2606	itok4->segm=0;
		2607	if(ptr->recpost==DYNAMIC_POST){
		2608	ptr->recpost=itok4->post=1;
		2609	if(alignword){ //��஢��
		2610	if(postsize%2==1)postsize++;
		2611	}
		2612	itok4->number=ptr->recnumber=postsize;
		2613	if(am32==FALSE&&(ptr->recsize+postsize)>0xFFFFL)tobigpost();
		2614	postsize+=ptr->recsize;
		2615	}
		2616	else if(ptr->recpost==DYNAMIC_VAR)itok4->post=ptr->recpost=USED_DIN_VAR;
		2617	return TRUE;
		2618	case tk_proc:
		2619	case tk_apiproc:
		2620	case tk_declare:
		2621	case tk_undefproc:
		2622	strcpy((char *)string4,ptr->newid);
		2623	break;
		2624	default:
		2625	if(scanlexmode==DEFLEX2){
		2626	*tok4=tk_id;
		2627	return TRUE;
		2628	}
		2629	strcpy((char *)string4,ptr->newid);
		2630	if(strcmp((char *)string4,ptr->recid)!=0){ // see if ID has changed
		2631	// searchtree2(fptr,itok4,tok4,string4); // search again
		2632	searchtree(itok4,tok4,string4); // search again
		2633	switch(*tok4){
		2634	case tk_proc:
		2635	case tk_apiproc:
		2636	case tk_declare:
		2637	case tk_undefproc:
		2638	strcpy(itok4->name,ptr->recid); //�� 㦭� �� undefine
		2639	break;
		2640	default:
		2641	strncpy(itok4->name,(char *)string4,IDLENGTH-1); //�� 㦭� �� undefine
		2642	break;
		2643	}
		2644	return TRUE;
		2645	}
		2646	break;
		2647	}
		2648	}
		2649	else string4[0]=0;
		2650	strcpy(itok4->name,ptr->recid); //�� 㦭� �� undefine
		2651	if(displaytokerrors)ptr->count++;
		2652	break;
		2653	}
		2654	else if(cmpresult<0)ptr=ptr->left;
		2655	else ptr=ptr->right;
		2656	}
		2657	if(ptr==NULL)return FALSE;
		2658	else return TRUE;
		2659	}
		2660
		2661
		2662	{
		2663	int retval=FALSE;
		2664	if(skipfind==FALSE){
		2665	if(staticlist)retval=searchtree2(staticlist,itok4,tok4,string4);
		2666	if(!retval)retval=searchtree2(treestart,itok4,tok4,string4);
		2667	if(!retval){
		2668	if((retval=searchtree2(definestart,itok4,tok4,string4))==TRUE){
		2669	if(scanlexmode==DEFLEX2)*tok4=tk_id;
		2670	}
		2671	}
		2672	}
		2673	return retval;
		2674	}
		2675
		2676
		2677	{
		2678	// printf("Add dinamic list %s %08X seg=%d tok=%d\n",ptr->recid,ptr,ptr->recsegm,ptr->rectok);
		2679	if(DynamicList==NULL){
		2680	sizeDL=STEPDL;
		2681	DynamicList=(volatile idrec )MALLOC(sizeof(idrec )*sizeDL);
		2682	countDP=0;
		2683	}
		2684	else if(sizeDL==(countDP+1)){
		2685	sizeDL+=STEPDL;
		2686	DynamicList=(volatile idrec )REALLOC(DynamicList,sizeof(idrec )*sizeDL);
		2687	}
		2688	for(int i=0;i
		2689	DynamicList[countDP]=ptr;
		2690	countDP++;
		2691	}
		2692
		2693
		2694
		2695	/* extract any procedures required from interal library and insert any
		2696	dynamic procedures that have been called.*/
		2697	{
		2698	if(ptr!=NULL){
		2699	// printf("%s\n",ptr->recid);
		2700	tok=ptr->rectok;
		2701	if(sdp_mode==FALSE&&(ptr->flag&f_export)!=0&&tok==tk_proc){
		2702	if(lexport==NULL){
		2703	lexport=(struct listexport *)MALLOC(sizeof(struct listexport));
		2704	lexport->address=ptr->recnumber;
		2705	strcpy(lexport->name,ptr->recid);
		2706	numexport=1;
		2707	}
		2708	else{
		2709	int cmpname,i;
		2710	for(i=0;i
		2711	if((cmpname=strcmp(ptr->recid,(lexport+i)->name))<=0)break;
		2712	}
		2713	if(cmpname!=0){
		2714	lexport=(struct listexport )REALLOC(lexport,sizeof(struct listexport)(numexport+1));
		2715	if(cmpname<0){
		2716	for(int j=numexport;j>i;j--){
		2717	memcpy(&(lexport+j)->address,&(lexport+j-1)->address,sizeof(struct listexport));
		2718	}
		2719	}
		2720	numexport++;
		2721	(lexport+i)->address=ptr->recnumber;
		2722	strcpy((lexport+i)->name,ptr->recid);
		2723	}
		2724	}
		2725	}
		2726	if(!(ptr->flag&f_extern)){
		2727	if(tok==tk_undefproc){
		2728	strcpy(itok.name,ptr->recid);
		2729	if(sdp_mode){
		2730	int boutptr=outptr;
		2731	int i;
		2732	if((ptr->flag&f_typeproc)==tp_fastcall){
		2733	if((i=includeit(1))!=-1){
		2734	if(updatecall((unsigned int)ptr->recnumber,boutptr,0)>0){
		2735	ptr->rectok=tk_proc;
		2736	ptr->recnumber=boutptr; // record location placed
		2737	ptr->recrm=i;
		2738	ptr->count++;
		2739	}
		2740	}
		2741	}
		2742	else{
		2743	if((i=includeproc())!=-1){
		2744	if(updatecall((unsigned int)ptr->recnumber,boutptr,0)>0){
		2745	ptr->rectok=tk_proc;
		2746	ptr->recnumber=boutptr; // record location placed
		2747	ptr->recrm=i;
		2748	ptr->count++;
		2749	}
		2750	}
		2751	}
		2752	}
		2753	else{
		2754	if(updatecall((unsigned int)ptr->recnumber,outptr,0)>0){
		2755	ptr->recnumber=outptr; // record location placed
		2756	linenumber=ptr->line;
		2757	currentfileinfo=ptr->file;
		2758	if((ptr->flag&f_typeproc)==tp_fastcall){
		2759	if(includeit(1)==-1)thisundefined(itok.name);
		2760	}
		2761	else{
		2762	if(includeproc()==-1)thisundefined(itok.name);
		2763	}
		2764	ptr->rectok=tk_proc;
		2765	ptr->count++;
		2766	}
		2767	}
		2768	}
		2769	else if(tok==tk_proc){
		2770	// printf("%08X %s\n",ptr->recpost,ptr->recid);
		2771	itok.segm=ptr->recsegm;
		2772	if(itok.segm==DYNAMIC_USED){
		2773	// printf("%08X %s\n",ptr->recpost,ptr->recid);
		2774	// if(updatecall((unsigned int)ptr->recnumber,outptr,0)>0){
		2775	itok.number=ptr->recnumber;
		2776	itok.flag=ptr->flag;
		2777	itok.post=ptr->recpost;
		2778	strcpy(itok.name,ptr->recid);
		2779	if(ptr->newid==NULL)string[0]=0;
		2780	else strcpy((char )string,(char )ptr->newid);
		2781	itok.rm=ptr->recrm;
		2782	itok.size=ptr->recsize;
		2783	itok.rec=ptr;
		2784	insert_dynamic();
		2785	// }
		2786	}
		2787	}
		2788	// else printf("tok=%d %s\n",tok,ptr->recid);
		2789	}
		2790	docals(ptr ->left);
		2791	docals(ptr ->right);
		2792	}
		2793	}
		2794
		2795
		2796	{
		2797	// puts("start docalls2");
		2798	docals(treestart);
		2799	for(unsigned int i=0;istlist);
		2800	// puts("end docalls2");
		2801	}
		2802
		2803
		2804	{
		2805	int numdinproc;
		2806	// puts("start docalls");
		2807	notdoneprestuff=2;
		2808	docalls2();
		2809	while(DynamicList!=NULL){
		2810	idrec *ptr;
		2811	numdinproc=0;
		2812	// printf("%d dinamic proc\n",countDP);
		2813	for(int i=0;i
		2814	ptr=(idrec *)DynamicList[i];
		2815	tok=ptr->rectok;
		2816	itok.segm=ptr->recsegm;
		2817	// printf("%d %08X seg=%d tok=%d %s\n",i+1,ptr,itok.segm,ptr->rectok,ptr->recid);
		2818	if(itok.segm==DYNAMIC_USED){
		2819	itok.number=ptr->recnumber;
		2820	itok.flag=ptr->flag;
		2821	strcpy(itok.name,ptr->recid);
		2822	if(ptr->newid==NULL)string[0]=0;
		2823	else strcpy((char )string,(char )ptr->newid);
		2824	itok.rm=ptr->recrm;
		2825	itok.size=ptr->recsize;
		2826	itok.rec=ptr;
		2827	insert_dynamic();
		2828	numdinproc++;
		2829	}
		2830	}
		2831	docalls2();
		2832	if(numdinproc==0)break;
		2833	}
		2834	free(DynamicList);
		2835	DynamicList=NULL;
		2836	countDP=0;
		2837	// puts("end docalls");
		2838	}
		2839
		2840
		2841	{
		2842	if(am32==FALSE){
		2843	structadr.rm=rm_d16;
		2844	structadr.sib=CODE16;
		2845	}
		2846	else{
		2847	structadr.rm=rm_d32;
		2848	structadr.sib=CODE32;
		2849	}
		2850	structadr.segm=DS;
		2851	structadr.number=ptrs->recnumber;
		2852	structadr.flag=0;
		2853	structadr.size=0; //addofs
		2854	structadr.rec=NULL;
		2855	structadr.type=tp_ucnovn;
		2856	structadr.npointr=0;
		2857	structadr.post=ptrs->recpost;
		2858	if(ptrs->recsegm==USEDSTR)structadr.sib++;
		2859	if(structadr.post==LOCAL){
		2860	if(ESPloc&&am32){
		2861	structadr.rm=rm_mod10\|rm_sib;
		2862	structadr.sib=0x24;
		2863	structadr.number+=addESP;
		2864	}
		2865	else{
		2866	structadr.rm=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP);
		2867	}
		2868	structadr.segm=SS;
		2869	compressoffset(&structadr);
		2870	}
		2871	}
		2872
		2873
		2874	{
		2875	int oinptr2;
		2876	char ocha2;
		2877	int oldendinptr=endinptr;
		2878	unsigned char odbg;
		2879	int otok,otok2;
		2880	unsigned char *oinput;
		2881	ITOK oitok; //18.08.04 19:07
		2882	oinptr2=inptr2;
		2883	ocha2=cha2;
		2884	odbg=dbg;
		2885	dbg=0;
		2886	otok=tok;
		2887	otok2=tok2;
		2888	oitok=itok; //18.08.04 19:07
		2889	oinput=input;
		2890	string[0]=0;
		2891	if(ptr->newid)strcpy((char *)string,ptr->newid);
		2892	itok.type=ptr->type;
		2893	itok.npointr=ptr->npointr;
		2894	itok.rm=ptr->recrm;
		2895	itok.flag=ptr->flag;
		2896	itok.rec=ptr;
		2897	strcpy(itok.name,ptr->recid);
		2898	itok.number=ptr->recnumber;
		2899	tok=ptr->rectok;
		2900	itok.post=ptr->recpost;
		2901	itok.segm=ptr->recsegm;
		2902	itok.sib=ptr->recsib;
		2903	ptr->count++;
		2904	if(itok.segm==DYNAMIC)AddDynamicList(ptr);
		2905	tok2=tk_openbracket;
		2906	input=(unsigned char*)"();";
		2907	inptr2=1;
		2908	cha2='(';
		2909	endinptr=3;
		2910	docommand();
		2911	tok=otok;
		2912	input=oinput;
		2913	inptr2=oinptr2;
		2914	cha2=ocha2;
		2915	tok2=otok2;
		2916	endinptr=oldendinptr;
		2917	dbg=odbg;
		2918	itok=oitok;//18.08.04 19:07
		2919	}
		2920
		2921
		2922	{
		2923	elementteg bazael=searcht->baza,retrez=NULL;
		2924	idrec *ptrs;
		2925	int i;
		2926	/// new!
		2927	for(i=0;inumoper;i++){
		2928	ptrs=(bazael+i)->rec;
		2929	if((bazael+i)->tok==tk_proc&&(ptrs->flag&fs_destructor)!=0)return(bazael+i);
		2930	}
		2931	for(i=0;inumoper;i++){
		2932	ptrs=(bazael+i)->rec;
		2933	if((bazael+i)->tok==tk_baseclass
		2934	\|\|(bazael+i)->tok==tk_struct //new 20.06.05 21:32
		2935	){
		2936	if((retrez=FindOneDestr((structteg *)ptrs))!=NULL)break;
		2937	}
		2938	}
		2939	return retrez;
		2940	}
		2941
		2942
		2943	{
		2944	char name[IDLENGTH];
		2945	struct elementteg *bazael;
		2946	int addofs;
		2947	structteg *tteg;
		2948	tteg=(structteg *)ptrs->newid;
		2949	sprintf(name,"%s~",tteg->name);
		2950	if((bazael=FindClassEl(tteg,(unsigned char *)name,&addofs,NULL))==NULL){
		2951	if((bazael=FindOneDestr(tteg))==NULL)preerror("destructor not defined");
		2952	}
		2953	if(ptrs->recsize)CreatParamDestr(ptrs);
		2954	else structadr.sib=THIS_ZEROSIZE;
		2955	CallDestr(bazael->rec);
		2956	}
		2957
		2958
		2959	{
		2960	char buf[128];
		2961	int oinptr2;
		2962	char ocha2;
		2963	int oldendinptr=endinptr;
		2964	unsigned char odbg;
		2965	int otok,otok2;
		2966	unsigned char *oinput;
		2967	oinptr2=inptr2;
		2968	ocha2=cha2;
		2969	odbg=dbg;
		2970	sprintf(buf,"__new(%u);}",size);
		2971	dbg=0;
		2972	otok=tok;
		2973	otok2=tok2;
		2974	oinput=input;
		2975	input=(unsigned char*)buf;
		2976	inptr2=1;
		2977	cha2='_';
		2978	tok=tk_openbrace;
		2979	endinptr=strlen(buf);
		2980	doblock();
		2981	tok=otok;
		2982	tok2=otok2;
		2983	input=oinput;
		2984	inptr2=oinptr2;
		2985	cha2=ocha2;
		2986	endinptr=oldendinptr;
		2987	dbg=odbg;
		2988	}
		2989
		2990
		2991	{
		2992	structteg *tteg;
		2993	elementteg *bazael;
		2994	int addofs=0;
		2995	struct idrec *ptr;
		2996	nexttok();
		2997	if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
		2998	tegnotfound();
		2999	er:
		3000	while(tok2!=tk_semicolon&&tok!=tk_eof)nexttok();
		3001	return;
		3002	}
		3003	// printf("flag=%08X\n",tteg->flag);
		3004	if((tteg->flag&fs_constructor)==0){
		3005	RunNew(tteg->size);
		3006	goto er;
		3007	}
		3008	bazael=FindClassEl(tteg,(unsigned char *)tteg->name,&addofs,NULL);
		3009	structadr.sib=THIS_NEW;
		3010	structadr.number=tteg->size;
		3011	ptr=bazael->rec;
		3012	string[0]=0;
		3013	if(ptr->newid!=NULL)strcpy((char *)string,ptr->newid);
		3014	itok.type=ptr->type;
		3015	itok.npointr=ptr->npointr;
		3016	itok.rm=ptr->recrm;
		3017	itok.flag=ptr->flag;
		3018	itok.rec=ptr;
		3019	strcpy(itok.name,ptr->recid);
		3020	itok.number=ptr->recnumber;
		3021	tok=ptr->rectok;
		3022	itok.post=ptr->recpost;
		3023	itok.segm=ptr->recsegm;
		3024	itok.sib=ptr->recsib;
		3025	ptr->count++;
		3026	if(itok.segm==DYNAMIC)AddDynamicList(ptr);
		3027	// docommand();
		3028	if(dbg)AddLine();
		3029	int oflag=current_proc_type;
		3030	current_proc_type&=~f_static;
		3031	if(tok==tk_proc)doanyproc();
		3032	else doanyundefproc();
		3033	current_proc_type=oflag;
		3034	}
		3035
		3036
		3037	{
		3038	int addofs=0;
		3039	int oinptr,oinptr2;
		3040	char ocha2;
		3041	int oldendinptr=endinptr;
		3042	unsigned char odbg;
		3043	unsigned char *oinput;
		3044	structteg *tteg=NULL;
		3045	elementteg *bazael;
		3046	char buf[128];
		3047	getoperand();
		3048	if(tok==tk_structvar){
		3049	oinptr=tok2;
		3050	// if((itok.flag&fs_useconstr)!=0){
		3051	if((itok.flag&fs_destructor)!=0){
		3052	Destructor(itok.rec);
		3053	}
		3054	else if(itok.rec->newid&&AskUseDestr((structteg *)itok.rec->newid))Destructor(itok.rec);
		3055	// }
		3056	if(oinptr!=tk_semicolon)nexttok();
		3057	}
		3058	else{
		3059	ITOK wtok;
		3060	char *wbuf;
		3061	wbuf=bufrm;
		3062	bufrm=NULL;
		3063	wtok=itok;
		3064	SINFO wstr;
		3065	wstr=strinf;
		3066	strinf.bufstr=NULL;
		3067	getinto_e_ax(0,tok,&wtok,wbuf,&wstr,(am32+1)*2);
		3068	bufrm=NULL;
		3069	strinf.bufstr=NULL;
		3070	if(tok2!=tk_semicolon){
		3071	nexttok();
		3072	if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
		3073	tegnotfound();
		3074	while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
		3075	return;
		3076	}
		3077	}
		3078	oinptr2=inptr2;
		3079	ocha2=cha2;
		3080	odbg=dbg;
		3081	dbg=0;
		3082	oinput=input;
		3083	int oflag=current_proc_type;
		3084	current_proc_type&=~f_static;
		3085	if(tteg){
		3086	structadr.number=0;
		3087	if((tteg->flag&fs_destructor)!=0){
		3088	op(0x50);
		3089	addESP+=am32==FALSE?2:4;
		3090	sprintf(buf,"%s~",tteg->name);
		3091	bazael=FindClassEl(tteg,(unsigned char *)buf,&addofs,NULL);
		3092
		3093
		3094	structadr.rm=AX;
		3095	structadr.size=addofs; // ???? 19.08.04 12:54 �� ᯮ��
		3096	CallDestr(bazael->rec);
		3097	addESP-=am32==FALSE?2:4;
		3098	op(0x58);
		3099	}
		3100	else if(AskUseDestr(tteg)){
		3101	bazael=FindOneDestr(tteg);
		3102	op(0x50);
		3103	addESP+=am32==FALSE?2:4;
		3104	structadr.sib=THIS_REG;
		3105	structadr.rm=AX;
		3106	structadr.size=0;//addofs;
		3107	CallDestr(bazael->rec);
		3108	addESP-=am32==FALSE?2:4;
		3109	op(0x58);
		3110	}
		3111	}
		3112	input=(unsigned char*)"__delete((E)AX);}";
		3113	inptr2=1;
		3114	cha2='_';
		3115	endinptr=strlen((char *)input);
		3116	tok=tk_openbrace;
		3117	doblock();
		3118	input=oinput;
		3119	inptr2=oinptr2;
		3120	cha2=ocha2;
		3121	endinptr=oldendinptr;
		3122	dbg=odbg;
		3123	current_proc_type=oflag;
		3124	}
		3125	nextseminext();
		3126	}
		3127
		3128
		3129	{
		3130	elementteg *bazael=searcht->baza;
		3131	if((searcht->flag&fs_destructor)!=0)return TRUE;
		3132	for(int i=0;inumoper;i++){
		3133	// printf("tok=%d\n",(bazael+i)->tok);
		3134	if((bazael+i)->tok==tk_baseclass
		3135	\|\|(bazael+i)->tok==tk_struct //new 20.06.05 21:33
		3136	){
		3137	if(AskUseDestr((structteg *)(bazael+i)->rec))return TRUE;
		3138	}
		3139	}
		3140	return FALSE;
		3141	}
		3142
		3143
		3144	{
		3145	struct localrec *ptrs;
		3146	int calldestruct=FALSE;
		3147	int zerosize=FALSE;
		3148	treelocalrec *ftlr;
		3149	for(ftlr=tlr;ftlr!=NULL;ftlr=ftlr->next){
		3150	for(ptrs=ftlr->lrec;ptrs!=NULL;ptrs=ptrs->rec.next){
		3151	if(ptrs->rec.rectok==tk_structvar){
		3152	if((ptrs->rec.flag&fs_destructor)!=0\|\|AskUseDestr((structteg *)ptrs->rec.newid)){
		3153	if(!calldestruct){
		3154	calldestruct=TRUE;
		3155	if(ptrs->rec.recsize==0\|\|returntype==tk_void)zerosize=TRUE;
		3156	else{
		3157	op66(r32);
		3158	op(0x50);
		3159	addESP+=4;
		3160	}
		3161	}
		3162	Destructor(&ptrs->rec);
		3163	}
		3164	}
		3165	}
		3166	}
		3167	if(calldestruct&&zerosize==FALSE){
		3168	op66(r32);
		3169	op(0x58);
		3170	addESP-=4;
		3171	}
		3172	}
		3173
		3174
		3175	structteg *subteg)
		3176	{
		3177	struct elementteg *bazael=searcht->baza;
		3178	int numclass=0;
		3179	void **listclass;
		3180	//11.08.04 22:54
		3181	char name[IDLENGTH];
		3182	strcpy(name,searcht->name);
		3183
		3184
		3185	if((bazael+i)->tok==tk_baseclass){
		3186	if(!numclass)listclass=(void )MALLOC(sizeof(void ));
		3187	else listclass=(void )REALLOC(listclass,sizeof(void )*(numclass+1));
		3188	listclass[numclass]=(void *)(bazael+i)->nteg;
		3189	numclass++;
		3190	continue;
		3191	}
		3192	if(strcmp((bazael+i)->name,(char *)string4)==0){
		3193	if(subteg&&subteg!=searcht)continue;
		3194	if(numclass)free(listclass);
		3195	//11.08.04 22:54
		3196	strcpy((char *)string4,name);
		3197
		3198
		3199	}
		3200	}
		3201	if(numclass){
		3202	structteg *ssubteg=subteg;
		3203	for(int i=numclass-1;i>=0;i--){
		3204	structteg s=(structteg )listclass[i];
		3205	if(subteg==searcht)ssubteg=s;
		3206	if((bazael=FindClassEl(s,string4,addofs,ssubteg))!=NULL){
		3207	i--;
		3208	while(i>=0){
		3209	s=(structteg *)listclass[i];
		3210	*addofs+=s->size;
		3211	i--;
		3212	}
		3213	free(listclass);
		3214	return bazael;
		3215	}
		3216	}
		3217	free(listclass);
		3218	}
		3219	return NULL;
		3220	}
		3221
		3222
		3223	{
		3224	elementteg *bazael=searcht->baza;
		3225	idrec *ptrs;
		3226	for(int i=0;inumoper;i++){
		3227	ptrs=(bazael+i)->rec;
		3228	if((searcht->flag&fs_destructor)==0){
		3229	if((bazael+i)->tok==tk_baseclass){
		3230	if(CallDestructor((structteg *)ptrs))return TRUE;
		3231	}
		3232	}
		3233	else if((bazael+i)->tok==tk_proc&&(ptrs->flag&fs_destructor)!=0){
		3234	structadr.sib=THIS_PARAM;
		3235	structadr.number=0;//addofs;
		3236	CallDestr(ptrs);
		3237	return TRUE;
		3238	}
		3239	}
		3240	return FALSE;
		3241	}
		3242
		3243
		3244	{
		3245	itok4->number=ptr->recnumber;
		3246	itok4->rm=ptr->recrm;
		3247	*tok4=ptr->rectok;
		3248	itok4->post=ptr->recpost;
		3249	itok4->segm=ptr->recsegm;
		3250	itok4->flag=ptr->flag;
		3251	itok4->size=ptr->recsize;
		3252	itok4->sib=ptr->recsib;
		3253	itok4->rec=ptr;
		3254	itok4->type=ptr->type;
		3255	itok4->npointr=ptr->npointr;
		3256	}
		3257
		3258
		3259	//�� ६�� 易�� ᯨ᪠
		3260	{
		3261	if(skiplocals){
		3262	skiplocals=FALSE;
		3263	return FALSE;
		3264	}
		3265	if(skipfind==LOCAL)return FALSE;
		3266	treelocalrec *ftlr;
		3267	struct localrec *ptr;
		3268	for(ftlr=tlr;ftlr!=NULL;ftlr=ftlr->next){
		3269	for(ptr=ftlr->lrec;ptr!=NULL;ptr=ptr->rec.next){
		3270	// puts(ptr->rec.recid);
		3271	if(strcmp(ptr->rec.recid,(char *)string4)==0){
		3272	itok4->number=ptr->rec.recnumber;
		3273	*tok4=ptr->rec.rectok;
		3274	itok4->locrec=ptr;
		3275	if(displaytokerrors){
		3276	if(mapfile){
		3277	if(ptr->li.count==0)ptr->li.usedfirst=linenumber;
		3278	else ptr->li.usedlast=linenumber;
		3279	ptr->li.count++;
		3280	}
		3281	if(*tok4==tk_structvar)ptr->rec.count++;
		3282	}
		3283	// printf("type=%d num=%08X %s\n",ptr->rec.type,ptr->rec.recnumber,ptr->rec.recid);
		3284	if(ptr->rec.type==tp_postvar){
		3285	itok4->segm=DS;
		3286	itok4->flag=ptr->rec.flag;
		3287	itok4->size=ptr->rec.recsize;
		3288	itok4->rm=(am32==FALSE?rm_d16:rm_d32);
		3289	itok4->npointr=ptr->rec.npointr;
		3290	itok4->type=tp_localvar;
		3291	itok4->post=1;
		3292	if(*tok4==tk_structvar){
		3293	itok4->rec=&ptr->rec;
		3294	itok4->post=ptr->rec.recpost;
		3295	// itok4->segm=0;
		3296	}
		3297	return TRUE;
		3298	}
		3299	if(ptr->rec.type==tp_gvar){
		3300	itok4->number=0;
		3301	itok4->rm=(am32==FALSE?rm_d16:rm_d32);
		3302	itok4->segm=DS;
		3303	itok4->size=ptr->rec.recsize;
		3304	itok4->npointr=ptr->rec.npointr;
		3305	itok4->type=ptr->rec.recsib; //????01.09.05 15:58
		3306	itok4->post=USED_DIN_VAR;
		3307	if(ptr->rec.recpost==DYNAMIC_VAR)ptr->rec.recpost=USED_DIN_VAR;
		3308	itok4->rec=&ptr->rec;
		3309	ptr->fuse=USEDVAR;
		3310	if(*tok4==tk_structvar){
		3311	itok4->number=ptr->rec.recnumber;
		3312	itok4->flag\|=ptr->rec.flag;
		3313	}
		3314	return TRUE;
		3315	}
		3316	itok4->type=ptr->rec.type;
		3317	if(ptr->rec.type==tp_paramvar\|\|ptr->rec.type==tp_localvar){
		3318	if(ESPloc&&am32){
		3319	itok4->rm=rm_mod10\|rm_sib;
		3320	itok4->sib=0x24;
		3321	if(ptr->rec.type==tp_paramvar)itok4->number+=localsize+addESP;
		3322	else itok4->number+=-4+addESP;
		3323	}
		3324	else itok4->rm=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP);
		3325	itok4->segm=SS;
		3326	itok4->npointr=ptr->rec.npointr;
		3327	if(ptr->rec.npointr){
		3328	itok4->type=(unsigned short)*tok4-tk_charvar+tk_char;
		3329	*tok4=tk_pointer;
		3330	}
		3331	if(*tok4==tk_structvar){
		3332	itok4->rec=&ptr->rec;
		3333	itok4->post=ptr->rec.recpost;
		3334	itok4->segm=0;
		3335	}
		3336	}
		3337	else if(!(ptr->rec.rectok==tk_locallabel\|\|ptr->rec.rectok==tk_number)){
		3338	internalerror("Bad *tok4 value in searchlocals");
		3339	}
		3340	itok4->size=ptr->rec.recsize;
		3341	itok4->flag=ptr->rec.flag;
		3342	return TRUE;
		3343	}
		3344	}
		3345	}
		3346	if(searchteg){
		3347	struct elementteg *bazael;
		3348	int addofs=0;
		3349	structteg *subteg=NULL;
		3350	if(cha==':'&&cha2==':'){
		3351	nextchar();
		3352	nextchar();
		3353	if((subteg=FindTeg(TRUE,itok4->name))==NULL&&displaytokerrors)undefclass(itok4->name);
		3354	tokscan(tok4,itok4,string4);
		3355	whitespace();
		3356	}
		3357	if(destructor){
		3358	destructor=FALSE;
		3359	strcat((char *)string4,"~");
		3360	}
		3361	if((bazael=FindClassEl(searchteg,string4,&addofs,subteg))!=NULL){
		3362	*tok4=bazael->tok;
		3363	itok4->type=tp_classvar;
		3364	// printf("tok=%d bazael->rec=%08X %s\n",*tok4,bazael->rec,itok4->name);
		3365	if(tok4==tk_proc\|\|tok4==tk_pointer){
		3366	idrec *ptr=bazael->rec;
		3367	if(strchr(itok4->name,'@')==NULL){
		3368	strcat(itok4->name,"@");
		3369	strcat(itok4->name,(char *)string4);
		3370	}
		3371	// }
		3372	// printf("tok=%d %s %s\n",*tok4,ptr->recid,ptr->newid);
		3373	if(tok4==tk_proc&&ptr->newid!=NULL)strcpy((char )string4,ptr->newid);
		3374	CopyTok(tok4,itok4,bazael->rec);
		3375	structadr.sib=THIS_PARAM;
		3376	structadr.number=0;//addofs;
		3377	if(displaytokerrors){
		3378	ptr->count++;
		3379	if(*tok4==tk_proc){
		3380	if(itok4->segm==DYNAMIC)AddDynamicList(ptr);
		3381	}
		3382	}
		3383	if(*tok4==tk_pointer)goto locvar;
		3384	}
		3385	else if(*tok4==tk_struct){
		3386	*tok4=tk_structvar;
		3387	// printf("teg=%08X\n",bazael->nteg);
		3388	dostructvar2(tok4,itok4,(structteg *)bazael->nteg,string4);
		3389	if(*tok4==tk_structvar){
		3390	itok4->rec=(idrec *)bazael->nteg;
		3391	itok4->number+=(itok4->post==0?0:itok4->rm((structteg )bazael->nteg)->size);
		3392	itok4->size=(itok4->post==0?bazael->numel:1)((structteg )bazael->nteg)->size;
		3393
		3394
		3395	if(displaytokerrors){
		3396	if(strinf.bufstr!=NULL)free(strinf.bufstr);
		3397	strinf.bufstr=(char *)MALLOC(7);
		3398	strcpy(strinf.bufstr,"&this;");
		3399	strinf.size=1;
		3400	}
		3401	// itok4->flag\|=f_useidx;
		3402	// if(itok4->sib>=CODE16)itok4->sib++;
		3403	return TRUE;
		3404
		3405
		3406	else if(*tok4==tk_proc){
		3407	structadr.sib=THIS_PARAM;
		3408	structadr.number+=bazael->ofs+addofs;
		3409
		3410
		3411	return TRUE;
		3412	}
		3413
		3414
		3415	}
		3416	else{
		3417	if(bazael->rec){ //static var
		3418	CopyTok(tok4,itok4,bazael->rec);
		3419	return TRUE;
		3420	}
		3421
		3422
		3423	itok4->number+=bazael->ofs+addofs;
		3424	if(displaytokerrors){
		3425	if(bufrm!=NULL)free(bufrm);
		3426	bufrm=(char *)MALLOC(7);
		3427	strcpy(bufrm,"&this;");
		3428	}
		3429	// itok4->flag\|=f_useidx;
		3430	if(itok4->sib>=CODE16)itok4->sib++;
		3431	// 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);
		3432	}
		3433	return TRUE;
		3434	}
		3435	}
		3436	return FALSE;
		3437	}
		3438
		3439
		3440	{
		3441	struct elementteg *bazael;
		3442	int numel=0;
		3443	int usenumstruct=FALSE;
		3444	int sopenb;
		3445	long cnum;
		3446	ITOK cstok;
		3447	char *cstring;
		3448	char c=0;
		3449	int i;
		3450	structteg *subteg=NULL;
		3451	structadr=*itok4;
		3452	// bazael=tteg->baza;
		3453	whitespace();//�ய�� ᨬ��
		3454	cstring=(char *)MALLOC(STRLEN);
		3455	if(cha=='['){ //[ ��
		3456	usenumstruct=TRUE;
		3457	nextchar();
		3458	sopenb=inptr;
		3459	unsigned char bcha=cha;
		3460	tokscan(&i,&cstok,(unsigned char *)cstring);
		3461	if(bufrm){
		3462	free(bufrm);
		3463	bufrm=NULL;
		3464	}
		3465	if(i==tk_number){ //�᫮��
		3466	ITOK dstok;
		3467	memcpy(&dstok,itok4,sizeof(ITOK));
		3468	calcnum(&i,&cstok,cstring,&cnum);
		3469	memcpy(itok4,&dstok,sizeof(ITOK));
		3470	if(i!=tk_closeblock)goto notnum;
		3471	numel=cnum;
		3472	}
		3473	else{
		3474	notnum:
		3475	//new!!!
		3476	if(displaytokerrors){
		3477	if(itok4->segm==USEDSTR)preerror("only once possible use variable an index structure");
		3478
		3479
		3480	itok4->segm=USEDSTR;
		3481	SRBackBuf(0);
		3482	AddBackBuf(sopenb,bcha);
		3483	CharToBackBuf(';');
		3484	CharToBackBuf(0);
		3485	if(cha!=']')blockerror();
		3486	if(strinf.bufstr!=NULL)free(strinf.bufstr);//internalerror("Previous block was not used");
		3487	strinf.bufstr=(char *)REALLOC(BackTextBlock,SizeBackBuf+1);
		3488	SRBackBuf(1);
		3489	nextchar();
		3490	//new!!!
		3491	}
		3492	else{
		3493	do{
		3494	tokscan(&i,&cstok,(unsigned char *)cstring);
		3495	if(i==tk_eof)break;
		3496	}while(i!=tk_closeblock);
		3497	}
		3498
		3499
		3500	strinf.size=tteg->size;
		3501	}
		3502	itok4->flag\|=f_useidx;
		3503	whitespace();//�ய�� ᨬ��
		3504	}
		3505	if(cha=='.'){
		3506	int fdestr=FALSE;
		3507	nextchar();
		3508	if(cha=='~'){
		3509	nextchar();
		3510	fdestr=TRUE;
		3511	}
		3512	skipfind=LOCAL;
		3513	do{
		3514	tokscan(&i,&cstok,(unsigned char *)cstring);
		3515	// puts(cstok.name);
		3516	if(cha=='.')searchtree2(definestart,&cstok,&i,(unsigned char *)cstring);
		3517	}while(i==tk_endline);
		3518	whitespace();
		3519	if(cha==':'){
		3520	nextchar();
		3521	if(cha!=':')expectederror("::");
		3522	nextchar();
		3523	if((subteg=FindTeg(TRUE,cstok.name))==NULL&&displaytokerrors)undefclass(cstok.name);
		3524	tokscan(&i,&cstok,(unsigned char *)cstring);
		3525	whitespace();
		3526	}
		3527	skipfind=FALSE;
		3528	int addofs=0;
		3529	if(fdestr)strcat(cstok.name,"~");
		3530	if((bazael=FindClassEl(tteg,(unsigned char *)cstok.name,&addofs,subteg))==NULL){
		3531	if(displaytokerrors)unknownstruct(cstok.name,tteg->name);
		3532	*tok4=tk_number;
		3533	free(cstring);
		3534	return;
		3535	}
		3536	free(cstring);
		3537	*tok4=bazael->tok;
		3538	itok4->size=bazael->numelGetVarSize(tok4);
		3539	cnum=(c==0?tteg->size*numel:0);
		3540	if((itok4->flag&f_extern)!=0)itok4->number+=((bazael->ofs+cnum)<<16);
		3541	else itok4->number+=bazael->ofs+cnum;
		3542	if(*tok4==tk_struct){
		3543	*tok4=tk_structvar;
		3544	itok4->size=bazael->numel((structteg )bazael->nteg)->size;
		3545	dostructvar2(tok4,itok4,(structteg *)bazael->nteg,string4);
		3546	return;
		3547	}
		3548	if((itok4->flag&f_extern)!=0)itok4->number+=addofs<<16;
		3549	else itok4->number+=addofs;
		3550	// printf("tok=%d %s\n",*tok4,bufrm);
		3551	if(tok4==tk_proc\|\|tok4==tk_pointer){
		3552	idrec *ptr;//=NULL;
		3553	if(*tok4==tk_proc){
		3554	if(am32==FALSE){
		3555	structadr.rm=rm_d16;
		3556	structadr.sib=CODE16;
		3557	}
		3558	else{
		3559	structadr.rm=rm_d32;
		3560	structadr.sib=CODE32;
		3561	}
		3562	structadr.segm=DS;
		3563	structadr.number=itok4->number;
		3564	// structadr.number=0;
		3565	structadr.flag=0;
		3566	structadr.size=addofs;
		3567	structadr.type=tp_ucnovn;
		3568	structadr.npointr=0;
		3569	structadr.post=itok4->post;
		3570	structadr.rec=(structadr.post==USED_DIN_VAR?itok4->rec:NULL);
		3571	if(itok4->segm==USEDSTR)structadr.sib++;
		3572	if(structadr.post==LOCAL){
		3573	if(ESPloc&&am32){
		3574	structadr.rm=rm_mod10\|rm_sib;
		3575	structadr.sib=0x24; //???
		3576	structadr.number+=addESP;
		3577	}
		3578	else{
		3579	structadr.rm=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP);
		3580	}
		3581	structadr.segm=SS;
		3582	compressoffset(&structadr);
		3583	if(tteg->size==0)structadr.sib=THIS_ZEROSIZE; //14.11.05 13:51
		3584	}
		3585	/* if(strcmp(bazael->name,tteg->name)==0&&itok4->rec){ //�맮� ��
		3586	ptr=itok4->rec;
		3587	// printf("constructor %08X\n",ptr);
		3588	}*/
		3589	}
		3590	// if(ptr)printf("new address constructor %08X\n",bazael->rec);
		3591	ptr=bazael->rec;
		3592	itok4->type=ptr->type;
		3593	itok4->npointr=ptr->npointr;
		3594	itok4->rm=ptr->recrm;
		3595	itok4->flag=ptr->flag;
		3596	itok4->rec=ptr;
		3597	strcpy(itok4->name,ptr->recid);
		3598	if(*tok4==tk_pointer){
		3599	// puts("Check this code");
		3600	string4[0]=0;
		3601	if(ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
		3602	*tok4=ptr->rectok;
		3603	//!!!
		3604	if(itok4->type==tk_proc&&cha!='('){
		3605	itok4->type=(am32==FALSE?tk_wordvar:tk_dwordvar);
		3606	goto notbit;
		3607	}
		3608
		3609
		3610	// printf("post=%08X %s\n",itok4->post,itok4->name);
		3611	if(itok4->post==LOCAL){
		3612	if(ESPloc&&am32){
		3613	itok4->rm=rm_mod10\|rm_sib;
		3614	itok4->sib=0x24;
		3615	itok4->number+=addESP;
		3616	}
		3617	else{
		3618	itok4->sib=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP); //???rm
		3619	}
		3620	itok4->segm=SS;
		3621	itok4->post=FALSE;
		3622	}
		3623	else{
		3624	itok4->sib=(am32==FALSE?rm_d16:rm_d32); //��⠭�� 㬮�砭��
		3625	itok4->segm=DS;
		3626	}
		3627	// itok4->post=0;
		3628	itok4->flag\|=f_useidx;
		3629	return;
		3630	}
		3631	itok4->number=ptr->recnumber;
		3632	*tok4=ptr->rectok;
		3633	itok4->post=ptr->recpost;
		3634	itok4->segm=ptr->recsegm;
		3635	itok4->sib=ptr->recsib;
		3636	itok4->size=ptr->recsize; //11.08.04 00:24
		3637	//11.09.04 00:28
		3638	if(strchr(itok4->name,'@')==NULL){
		3639	strcat(itok4->name,"@");
		3640	strcat(itok4->name,(char *)string4);
		3641	}
		3642	string4[0]=0;
		3643	if(ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
		3644	////////////////////
		3645
		3646
		3647	if(displaytokerrors){
		3648	ptr->count++;
		3649	if(*tok4==tk_proc&&itok4->segm==DYNAMIC)AddDynamicList(ptr);
		3650	if(tok4!=tk_proc&&tok4!=tk_undefproc&&*tok4!=tk_declare)thisundefined(ptr->recid,FALSE);
		3651	}
		3652	return;
		3653	}
		3654	// if((itok4->flag&f_extern)!=0)itok4->number+=addofs;
		3655	// else itok4->number+=addofs;
		3656	if(*tok4==tk_bits){
		3657	itok4->flag\|=f_useidx;
		3658	itok4->number+=bazael->bit.ofs/8;
		3659	if((bazael->bit.ofs%8)==0){
		3660	switch(bazael->bit.siz){
		3661	case 8:
		3662	*tok4=tk_bytevar;
		3663	goto notbit;
		3664	case 16:
		3665	*tok4=tk_wordvar;
		3666	goto notbit;
		3667	case 32:
		3668	*tok4=tk_dwordvar;
		3669	goto notbit;
		3670	}
		3671	}
		3672	itok4->bit.siz=bazael->bit.siz;
		3673	itok4->bit.ofs=bazael->bit.ofs%8;
		3674	}
		3675	else if(bazael->rec){ //static var
		3676	CopyTok(tok4,itok4,bazael->rec);
		3677	return;
		3678	}
		3679	notbit:
		3680	itok4->sib=cstok.sib;
		3681	if(itok4->post==LOCAL){
		3682	if(ESPloc&&am32){
		3683	itok4->rm=rm_mod10\|rm_sib;
		3684	// printf("sib=%x tok=%d name=%s\n",itok4->sib,*tok4,itok4->name);
		3685	itok4->sib=0x24;
		3686	itok4->number+=addESP;
		3687	}
		3688	else{
		3689	itok4->rm=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP);
		3690	if(itok4->segm==USEDSTR&&itok4->sib>=CODE16)itok4->sib++;
		3691	}
		3692	itok4->segm=SS;
		3693	itok4->post=FALSE;
		3694	itok4->flag=f_useidx;
		3695	}
		3696	else{
		3697	itok4->rm=(am32==FALSE?rm_d16:rm_d32); //��⠭�� 㬮�砭��
		3698	if(itok4->segm==USEDSTR&&itok4->sib>=CODE16)itok4->sib++;
		3699	itok4->segm=DS;
		3700	itok4->flag=FixUp\|f_useidx;
		3701	}
		3702	return;
		3703	}
		3704	// itok4->size=(numel==0?bazael->numel:1)((structteg )bazael->nteg)->size;
		3705	// itok4->rec=(idrec *)tteg;
		3706	itok4->rm=numel;
		3707	itok4->post=usenumstruct;
		3708	free(cstring);
		3709	}
		3710
		3711
		3712	{
		3713	struct structteg *tteg;
		3714	int i,brase=FALSE;
		3715	ITOK cstok;
		3716	whitespace();//�ய�� ᨬ��
		3717	itok4->number=0;
		3718	if(cha=='('){
		3719	nextchar();
		3720	brase=TRUE;
		3721	}
		3722	// if((cha!='(')&&(displaytokerrors))expected('(');
		3723	// nextchar();
		3724	cstok.name[0]=0;
		3725	// if(displaytokerrors)puts("start sizeof");
		3726	tokscan(&i,&cstok,string2);
		3727	// if(displaytokerrors)printf("tok=%d findoffset=%d %s\n",i,findofset,cstok.name);
		3728	if(i==tk_dblcolon&&numblocks){
		3729	skiplocals=TRUE;
		3730	tokscan(&i,&cstok,string2);
		3731	}
		3732	if(strcmp(cstok.name,"__CODESIZE")==0){
		3733	itok4->post=CODE_SIZE+am32;
		3734	}
		3735	else if(strcmp(cstok.name,"__DATASIZE")==0){
		3736	itok4->post=DATA_SIZE+am32;
		3737	}
		3738	else if(strcmp(cstok.name,"__POSTSIZE")==0){
		3739	itok4->post=POST_SIZE+am32;
		3740	}
		3741	else if(strcmp(cstok.name,"__STACKSIZE")==0){
		3742	itok4->post=STACK_SIZE+am32;
		3743	}
		3744	else{
		3745	switch(i){
		3746	case tk_char:
		3747	case tk_byte:
		3748	case tk_beg:
		3749	itok4->number=1;
		3750	break;
		3751	case tk_int:
		3752	case tk_word:
		3753	case tk_reg:
		3754	case tk_seg:
		3755	itok4->number=2;
		3756	break;
		3757	case tk_float:
		3758	case tk_reg32:
		3759	case tk_long:
		3760	case tk_dword:
		3761	itok4->number=4;
		3762	break;
		3763	case tk_double:
		3764	case tk_qword:
		3765	itok4->number=8;
		3766	break;
		3767	case tk_string:
		3768	itok4->number=cstok.number;
		3769	if(/itok4->/cstok.flag!=no_term)itok4->number++;
		3770	break;
		3771	case tk_bits:
		3772	itok4->number=cstok.bit.siz;
		3773	break;
		3774	case tk_proc:
		3775	case tk_charvar:
		3776	case tk_bytevar:
		3777	case tk_intvar:
		3778	case tk_wordvar:
		3779	case tk_longvar:
		3780	case tk_dwordvar:
		3781	case tk_floatvar:
		3782	case tk_structvar:
		3783	case tk_qwordvar:
		3784	case tk_doublevar:
		3785	case tk_interruptproc:
		3786	if(cstok.size==0)if(displaytokerrors)preerror("unknown size");
		3787	itok4->number=cstok.size;
		3788	break;
		3789	default:
		3790	if((tteg=FindTeg(FALSE,cstok.name))!=NULL\|\|(tteg=FindTeg(TRUE,cstok.name))!=NULL){
		3791	if(cha=='.'){
		3792	dostructvar2(&i,itok4,tteg,string2);
		3793	itok4->number=itok4->size;
		3794	if(bufrm){
		3795	free(bufrm);
		3796	bufrm=NULL;
		3797	}
		3798	}
		3799	else itok4->number=tteg->size;
		3800	itok4->flag=0;
		3801	break;
		3802	}
		3803	if(strcmp("file",(char *)string2)==0){
		3804	displaytokerrors=1;
		3805	tokscan(&i,&cstok,string2);
		3806	if(i==tk_string){
		3807	struct stat statbuf;
		3808	if(stat((char )string3,&statbuf)!=0)unableopenfile((char )string3);
		3809	else itok4->number=statbuf.st_size;
		3810	}
		3811	else stringexpected();
		3812	}
		3813	else if(displaytokerrors)preerror("illegal use of sizeof");
		3814	break;
		3815	}
		3816	}
		3817	whitespace();//�ய�� ᨬ��
		3818	if(brase){
		3819	if(cha!=')'&&displaytokerrors)expected(')');
		3820	nextchar();
		3821	}
		3822	}
		3823
		3824
		3825	{
		3826	struct structteg *tteg;
		3827	int newreg=(idxregs[4]==255?idxregs[0]:idxregs[4]); //14.06.06 20:06
		3828	int poststr;
		3829	int flagstr;
		3830	if(itok4->type==tp_classvar){
		3831	tteg=(structteg *)itok4->rec;
		3832	poststr=0;
		3833	flagstr=f_useidx;
		3834	}
		3835	else{
		3836	struct idrec *ptrs;
		3837	ptrs=itok4->rec;
		3838	tteg=(structteg *)ptrs->newid;
		3839	poststr=ptrs->recpost;
		3840	flagstr=ptrs->flag;
		3841	}
		3842	if(tteg==NULL){
		3843	if(displaytokerrors){
		3844	unknowntagstruct(itok4->name);
		3845	}
		3846	return;
		3847	}
		3848	if(strinf.bufstr==NULL&&itok4->post==TRUE)itok4->number+=(tteg->size*(itok4->rm));
		3849	itok4->size=tteg->size;
		3850	itok4->sib=(am32==FALSE?CODE16:CODE32);
		3851	char ocha=cha;
		3852	int binptr=inptr;
		3853	if(poststr==LOCAL){
		3854	itok4->rm=rm_mod10;
		3855	if(strinf.bufstr==NULL){
		3856	if(ESPloc&&am32){
		3857	itok4->rm\|=rm_sib;
		3858	itok4->sib=0x24;
		3859	}
		3860	else{
		3861	itok4->rm\|=(am32==FALSE?rm_BP:rm_EBP);
		3862	}
		3863	}
		3864	else{
		3865	if(displaytokerrors){
		3866	if((newreg=CheckIDXReg(strinf.bufstr,strinf.size,idxregs[0]))!=NOINREG){
		3867	if(newreg==SKIPREG){
		3868	newreg=idxregs[0];
		3869	}
		3870	else{
		3871	if(am32==FALSE&&newreg!=DI)goto noopt1;
		3872	waralreadinitreg(regs[am32][idxregs[0]],regs[am32][newreg]);
		3873	}
		3874	free(strinf.bufstr);
		3875	strinf.bufstr=NULL;
		3876	goto cont1;
		3877	}
		3878	newreg=idxregs[0];
		3879	noopt1:
		3880	CheckMassiv(strinf.bufstr,strinf.size,idxregs[0]);
		3881	cont1: ;
		3882	}
		3883	if(am32==FALSE)itok4->rm\|=CalcRm16(BP,newreg);
		3884	else{
		3885	itok4->sib=(newreg<<3)+(ESPloc?ESP:EBP);
		3886	itok4->rm=4\|rm_mod10;
		3887	}
		3888	}
		3889	itok4->segm=SS;
		3890	if(ESPloc&&am32)itok4->number+=addESP;
		3891	// else itok4->number-=localsize;
		3892	*tok4=tk_rmnumber;
		3893	if(itok4->type==tp_classvar)itok4->flag\|=f_useidx;
		3894	itok4->post=FALSE;
		3895	compressoffset(itok4);
		3896	}
		3897	else{
		3898	itok4->post=poststr;
		3899	if(strinf.bufstr==NULL){
		3900	itok4->rm=(am32==FALSE?rm_d16:rm_d32); //��⠭�� 㬮�砭��
		3901	if(itok4->post!=0)*tok4=tk_postnumber;
		3902	else *tok4=tk_number;
		3903	}
		3904	else{
		3905	if(displaytokerrors){
		3906	if((newreg=CheckIDXReg(strinf.bufstr,strinf.size,idxregs[0]))!=NOINREG){
		3907	if(newreg==SKIPREG){
		3908	newreg=idxregs[0];
		3909	}
		3910	else{
		3911	if(am32==FALSE&&newreg!=DI&&newreg!=BX)goto noopt2;
		3912	waralreadinitreg(regs[am32][idxregs[0]],regs[am32][newreg]);
		3913	}
		3914	free(strinf.bufstr);
		3915	strinf.bufstr=NULL;
		3916	goto cont2;
		3917	}
		3918	newreg=(idxregs[4]==255?idxregs[0]:idxregs[4]); //14.06.06 20:06
		3919	noopt2:
		3920	CheckMassiv(strinf.bufstr,strinf.size,(idxregs[4]==255?idxregs[0]:idxregs[4]));
		3921	cont2: ;
		3922	}
		3923	itok4->rm=RegToRM(newreg,(am32==FALSE?tk_reg:tk_reg32))\|rm_mod10;
		3924	*tok4=tk_rmnumber;
		3925	}
		3926	itok4->segm=DS;
		3927	}
		3928	if(itok4->post==0&&(itok4->flag&f_reloc)==0){ // cannot compress if POST var
		3929	compressoffset(itok4);
		3930	}
		3931	// compressoffset(itok4);
		3932	itok4->flag\|=flagstr;
		3933	inptr=binptr;
		3934	cha=ocha;
		3935	}
		3936
		3937
		3938	/*segm - ᥣ�� 㤠 �� 饭��
		3939	0 - ᥣ��
		3940
		3941	2 - ᥣ�� , �� ᥭ�� ⠡�� ६�饭��
		3942	3 - ᥣ�� , �� ᥭ�� ⠡�� ६�饭��
		3943	*/
		3944	{
		3945	UNDEFOFF *curptr;
		3946	if(undefoffstart==NULL){ //�᫨ �� 뫮 �� ⮪
		3947	undefoffstart=(UNDEFOFF *)MALLOC(sizeof(UNDEFOFF));
		3948	memset(undefoffstart,0,sizeof(UNDEFOFF));
		3949	strcpy(undefoffstart->name,ostring);
		3950	}
		3951	for(curptr=undefoffstart;;curptr=curptr->next){
		3952	if(strcmp(curptr->name,ostring)==0){ //࠭�� 㦥 ��頫��
		3953	//⠡�� 饭�� undef
		3954	if(curptr->pos==NULL)curptr->pos=(IOFS )MALLOC(sizeof(IOFS)(curptr->num+1));
		3955	else curptr->pos=(IOFS )REALLOC(curptr->pos,sizeof(IOFS)(curptr->num+1));
		3956	(curptr->pos+curptr->num)->ofs=segm==0?outptr:outptrdata;
		3957	(curptr->pos+curptr->num)->dataseg=(unsigned char)segm;
		3958	(curptr->pos+curptr->num)->line=linenumber;
		3959	(curptr->pos+curptr->num)->file=currentfileinfo;
		3960	curptr->num++;
		3961	return;
		3962	}
		3963	if(curptr->next==NULL)break; //�� ᯨ᪠
		3964	}
		3965	curptr=curptr->next=(UNDEFOFF *)MALLOC(sizeof(UNDEFOFF)); //�� undef
		3966	memset(curptr,0,sizeof(UNDEFOFF));
		3967	strcpy(curptr->name,ostring);
		3968	curptr->num=1;
		3969	curptr->pos=(IOFS *)MALLOC(sizeof(IOFS));
		3970	curptr->pos->ofs=segm==0?outptr:outptrdata;
		3971	curptr->pos->dataseg=(unsigned char)segm;
		3972	curptr->pos->line=linenumber;
		3973	curptr->pos->file=currentfileinfo;
		3974	}
		3975
		3976
		3977	{
		3978	UNDEFOFF *curptr;
		3979	int count=0;
		3980	if(undefoffstart==NULL)return 0; //�� 뫮 ��饭�� undef
		3981	for(curptr=undefoffstart;;curptr=curptr->next){
		3982	if(strcmp(curptr->name,(char *)name)==0){ //��諨
		3983	count=curptr->num;
		3984	break;
		3985	}
		3986	if(curptr->next==NULL)break;
		3987	}
		3988	return count;
		3989	}
		3990
		3991
		3992	{
		3993	/*-----------------13.08.00 23:48-------------------
		3994	��ᬮ�� 楤�� ࠧ��
		3995	--------------------------------------------------*/
		3996	UNDEFOFF curptr,prev;
		3997	unsigned char segm;
		3998	unsigned int ofs,valofs;
		3999	int count=0;
		4000	if(undefoffstart==NULL)return 0; //�� 뫮 ��饭�� undef
		4001	for(curptr=undefoffstart;;curptr=curptr->next){
		4002	if(strcmp(curptr->name,(char *)name)==0){ //��諨
		4003	for(int i=0;inum;i++){
		4004	ofs=(curptr->pos+i)->ofs;
		4005	segm=(curptr->pos+i)->dataseg;
		4006	if(base==DS&&dynamic_flag){ //�뫮 ��饭�� ᪨� ��. ��६��
		4007	CheckPosts();
		4008	(postbuf+posts)->type=(unsigned short)(am32==0?DIN_VAR:DIN_VAR32);
		4009	(postbuf+posts)->num=(int)itok.rec;
		4010	(postbuf+posts)->loc=ofs;
		4011	}
		4012	else{
		4013	if((segm&1)==0\|\|modelmem==TINY){ //� ᥣ��
		4014	if(base!=VARPOST){
		4015	// if(am32==FALSE)valofs=(unsigned short )&output[ofs];
		4016	// else valofs=(unsigned long )&output[ofs];
		4017	// valofs+=(base==CS?outptr:outptrdata);
		4018	valofs=(base==CS?outptr:outptrdata);
		4019	}
		4020	else valofs=postsize;
		4021	if(am32==FALSE)(unsigned short )&output[ofs]+=(unsigned short)valofs;
		4022	else (unsigned long )&output[ofs]+=valofs;
		4023	}
		4024	else{
		4025	if(am32==FALSE)(unsigned short )&outputdata[ofs]+=(unsigned short)(base==CS?outptr:outptrdata);
		4026	else (unsigned long )&outputdata[ofs]+=(unsigned long)(base==CS?outptr:outptrdata);
		4027	}
		4028	if((FixUp!=FALSE&&(segm&2)==0)/\|\|base==VARPOST/){
		4029	CheckPosts();
		4030	(postbuf+posts)->type=(unsigned char)
		4031	// (base==VARPOST?(am32==FALSE?POST_VAR:POST_VAR32):
		4032	((segm&1)==0?(am32==FALSE?FIX_VAR:FIX_VAR32):
		4033	(am32==FALSE?FIX_CODE:FIX_CODE32)
		4034	// )
		4035	);
		4036	(postbuf+posts)->loc=ofs;
		4037	posts++;
		4038	}
		4039	if(base==VARPOST){
		4040	unsigned int i;
		4041	for(i=0;i
		4042	if(ofs==(postbuf+i)->loc)break;
		4043	}
		4044	if(i==posts){
		4045	CheckPosts();
		4046	posts++;
		4047	(postbuf+i)->loc=ofs;
		4048	}
		4049	(postbuf+i)->type=(unsigned char)(am32==FALSE?POST_VAR:POST_VAR32);
		4050	}
		4051	}
		4052	}
		4053	free(curptr->pos);
		4054	if(undefoffstart->next==NULL)undefoffstart=NULL;
		4055	else if(undefoffstart==curptr)undefoffstart=curptr->next;
		4056	else{
		4057	for(prev=undefoffstart;prev->next!=curptr;prev=prev->next);
		4058	prev->next=curptr->next;
		4059	}
		4060	count=curptr->num;
		4061	free(curptr);
		4062	break;
		4063	}
		4064	if(curptr->next==NULL)break;
		4065	}
		4066	return count;
		4067	}
		4068
		4069
		4070	{
		4071	UNDEFOFF *curptr;
		4072	if(undefoffstart){
		4073	for(curptr=undefoffstart;;curptr=curptr->next){
		4074	if(strcmp(curptr->name,(char *)name)==0){ //��諨
		4075	return curptr->num;
		4076	}
		4077	if(curptr->next==NULL)break;
		4078	}
		4079	}
		4080	return 0;
		4081	}
		4082
		4083
		4084	{
		4085	int i;
		4086	i=FastSearch(dirlist,ofsdir,1,str);
		4087	// printf("i=%d %s\n",i,str);
		4088	if(i!=-1&&i
		4089	char buf[80];
		4090	sprintf(buf,"Too late to change %s",str);
		4091	preerror(buf);
		4092	}
		4093	return i;
		4094	}
		4095
		4096
		4097	{
		4098	if((strlen(str)-1)>0){
		4099	short offs=-1;
		4100	unsigned char c;
		4101	c=str[0];
		4102	switch(type){
		4103	case 0:
		4104	if(c>='A'&&c<='Z')offs=ofs[c-'A'];
		4105	break;
		4106	case 1:
		4107	if(c=='D')offs=ofs[0];
		4108	else if(c>='a'&&c<='z')offs=ofs[c-0x60];
		4109	break;
		4110	case 2:
		4111	if(c=='_')offs=ofs[26];
		4112	else if(c>='a'&&c<='z')offs=ofs[c-'a'+27];
		4113	else offs=ofs[c-'A'];
		4114	break;
		4115	case 3:
		4116	if(c>='a'&&c<='z')offs=ofs[c-0x61];
		4117	break;
		4118	}
		4119	// if(type==0)printf("%s\n",str);
		4120	if(offs!=-1){
		4121	for(unsigned char ii=(unsigned char )(list+offs);;ii++){
		4122	short types;
		4123	if((types=(short )&*ii)==-1)break;
		4124	ii+=2;
		4125	unsigned char c=*ii;
		4126	int i;
		4127	i=1;
		4128	while(c==str[i]){
		4129	if(c==0)return types;
		4130	ii++;
		4131	i++;
		4132	c=*ii;
		4133	}
		4134	if(c>str[i])break;
		4135	while(*ii!=0)ii++;
		4136	}
		4137	}
		4138	}
		4139	return -1;
		4140	}
		4141
		4142
		4143	�� ࠬ�
		4144	--------------------------------------------------*/
		4145
		4146
		4147	{
		4148	switch(var){
		4149	case tk_reg:
		4150	case tk_intvar:
		4151	case tk_seg:
		4152	case tk_wordvar: return 2;
		4153	case tk_bits:
		4154	case tk_charvar:
		4155	case tk_beg:
		4156	case tk_bytevar: return 1;
		4157	case tk_pointer:
		4158	if(am32==0)return 2;
		4159	case tk_longvar:
		4160	case tk_dwordvar:
		4161	case tk_reg32:
		4162	case tk_floatvar: return 4;
		4163	case tk_doublevar:
		4164	case tk_qwordvar: return 8;
		4165	default:
		4166	if(am32)return 4;
		4167	}
		4168	return 2;
		4169	}
		4170
		4171
		4172	{
		4173	unsigned long num;
		4174	nexttok();
		4175	if(tok!=tk_number)numexpected();
		4176	num=doconstdwordmath();
		4177	if(num>(unsigned int)(size*8))preerror("Bit field to large");
		4178	return num;
		4179	}
		4180
		4181
		4182	{
		4183	elementteg *bazael=searcht->baza;
		4184	idrec *ptrs;
		4185	if((searcht->flag&fs_destructor)!=0)return TRUE;
		4186	for(int i=0;inumoper;i++){
		4187	ptrs=(bazael+i)->rec;
		4188	if((bazael+i)->tok==tk_baseclass){
		4189	if(GetFirstDestr((structteg *)ptrs))return TRUE;
		4190	}
		4191	}
		4192	return FALSE;
		4193	}
		4194
		4195
		4196	{
		4197	struct structteg *tteg;
		4198	int i;
		4199	tteg=(Global==TRUE?tegtree:ltegtree);
		4200	if(tteg==NULL)(Global==TRUE?tegtree:ltegtree)=newteg;
		4201	else{
		4202	while(((i=strcmp(tteg->name,newteg->name))<0&&tteg->left!=NULL)\|\|(i>0&&tteg->right!=NULL))
		4203	tteg=(i<0?tteg->left:tteg->right);
		4204	(i<0?tteg->left:tteg->right)=newteg;
		4205	}
		4206	}
		4207
		4208
		4209	{
		4210	elementteg *bazael=searcht->baza;
		4211	if((searcht->flag&fs_destructor)!=0)return TRUE;
		4212	for(int i=0;inumoper;i++){
		4213	if((bazael+i)->tok==tk_baseclass)return TRUE;
		4214	// if(IsClass((structteg *)(bazael+i)->rec))return TRUE;
		4215	else if((bazael+i)->tok==tk_proc){
		4216	if((bazael+i)->rec&&((bazael+i)->rec->flag&f_classproc))return TRUE;
		4217	}
		4218	}
		4219	return FALSE;
		4220	}
		4221
		4222
		4223	{
		4224	struct structteg newteg,tteg;
		4225	struct elementteg *bazael;
		4226	int ssize=0,numel=0,localtok,size,numt,nameid=FALSE,tsize;
		4227	int bitofs=0,bitsize=0,i,type;
		4228	int isdestr=FALSE,isbase=0;
		4229	int unionsize=0;
		4230	newteg=(struct structteg *)MALLOC(sizeof(struct structteg));
		4231	newteg->left=newteg->right=NULL;
		4232	newteg->baza=NULL;
		4233	newteg->flag=useunion;
		4234	newteg->name[0]=0;
		4235	if(tok==tk_ID\|\|tok==tk_id){
		4236	strcpy(newteg->name,itok.name);
		4237	AddTegToTree(newteg,Global);
		4238	nexttok();
		4239	nameid=TRUE;
		4240	}
		4241	if(tok==tk_colon){
		4242	nexttok();
		4243	do{
		4244	if((tteg=FindTeg(TRUE))==NULL)undefclass(itok.name);
		4245	else{
		4246	size=tteg->size;
		4247	if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg));
		4248	else bazael=(struct elementteg )REALLOC(bazael,sizeof(struct elementteg)(numel+1));
		4249	for(i=0;i
		4250	if(strcmp((bazael+i)->name,itok.name)==0){
		4251	sprintf((char *)string,"Dublicate base class '%s'",itok.name);
		4252	preerror((char *)string);
		4253	}
		4254	}
		4255	strcpy((bazael+numel)->name,itok.name);
		4256	(bazael+numel)->tok=tk_baseclass;
		4257	(bazael+numel)->ofs=ssize;
		4258	(bazael+numel)->numel=1;
		4259	ssize+=size;
		4260	(bazael+numel)->nteg=tteg;
		4261	numel++;
		4262	isbase++;
		4263	}
		4264	nexttok();
		4265	if(tok==tk_openbrace)break;
		4266	expecting(tk_camma);
		4267	}while(tok!=tk_eof);
		4268	if(useunion)preerror("union cannot have a base type");
		4269	}
		4270	expecting(tk_openbrace);
		4271	while(tok!=tk_closebrace&&tok!=tk_eof){
		4272	int oflag,orm,npointr;
		4273	int utestInitVar=FALSE;
		4274	orm=tokens;
		4275	npointr=oflag=0;
		4276	type=variable;
		4277	if(tok==tk_tilda){
		4278	newteg->flag\|=fs_destructor;
		4279	oflag\|=fs_destructor;
		4280	// oflag=newteg->flag;
		4281	nexttok();
		4282	isdestr=TRUE;
		4283	}
		4284	//13.09.04 00:08
		4285	if(tok==tk_static){
		4286	oflag\|=f_static;
		4287	nexttok();
		4288	}
		4289	/////////////
		4290	switch(tok){
		4291	case tk_int: orm=tok; localtok=tk_intvar; size=2; break;
		4292	case tk_word: orm=tok; localtok=tk_wordvar; size=2; break;
		4293	case tk_char: orm=tok; localtok=tk_charvar; size=1; break;
		4294	case tk_byte: orm=tok; localtok=tk_bytevar; size=1; break;
		4295	case tk_long: orm=tok; localtok=tk_longvar; size=4; break;
		4296	case tk_dword: orm=tok; localtok=tk_dwordvar; size=4; break;
		4297	case tk_float: orm=tok; localtok=tk_floatvar; size=4; break;
		4298	case tk_qword: orm=tok; localtok=tk_qwordvar; size=8; break;
		4299	case tk_double: orm=tok; localtok=tk_doublevar; size=8; break;
		4300	case tk_union:
		4301	nexttok();
		4302	i=FALSE;
		4303	if(bitofs&&(!useunion)){
		4304	ssize+=(bitofs+7)/8;
		4305	bitofs=0;
		4306	}
		4307	if(tok==tk_openbrace)i=TRUE;
		4308	if((tteg=CreatTeg(Global,TRUE,i))!=NULL){
		4309	if(tok==tk_semicolon){
		4310	if(numel==0)bazael=(struct elementteg )MALLOC(sizeof(struct elementteg)tteg->numoper);
		4311	else bazael=(struct elementteg )REALLOC(bazael,sizeof(struct elementteg)(numel+tteg->numoper));
		4312	for(i=0;inumoper;i++)(tteg->baza+i)->ofs+=ssize;
		4313	memcpy((elementteg )(bazael+numel),tteg->baza,sizeof(struct elementteg)tteg->numoper);
		4314	tsize=tteg->size;
		4315	if(useunion==FALSE)ssize+=tsize;
		4316	else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
		4317	numel+=tteg->numoper;
		4318	free(tteg->baza);
		4319	free(tteg);
		4320	size=0;
		4321	nexttok();
		4322	break;
		4323	}
		4324	else{
		4325	tsize=size=tteg->size;
		4326	localtok=tk_struct;
		4327	goto dproc2;
		4328	}
		4329	}
		4330	else declareunion();
		4331	break;
		4332	case tk_struct:
		4333	nexttok();
		4334	case tk_id:
		4335	case tk_ID:
		4336	if(bitofs&&(!useunion)){
		4337	ssize+=(bitofs+7)/8;
		4338	bitofs=0;
		4339	}
		4340	i=0;
		4341	if(tok==tk_openbrace\|\|tok2==tk_openbrace){
		4342	if(tok==tk_openbrace)i=TRUE;
		4343	if((tteg=CreatTeg(Global,FALSE,i))!=NULL){
		4344	if(tok!=tk_semicolon){
		4345	tsize=size=tteg->size;
		4346	localtok=tk_struct;
		4347	// printf("tok=%d %s\n",tok,itok.name);
		4348	goto dproc2;
		4349	}
		4350	else{
		4351	if(numel==0)bazael=(struct elementteg )MALLOC(sizeof(struct elementteg)tteg->numoper);
		4352	else bazael=(struct elementteg )REALLOC(bazael,sizeof(struct elementteg)(numel+tteg->numoper));
		4353	for(i=0;inumoper;i++)(tteg->baza+i)->ofs+=ssize;
		4354	memcpy((elementteg )(bazael+numel),tteg->baza,sizeof(struct elementteg)tteg->numoper);
		4355	tsize=tteg->size;
		4356	if(useunion==FALSE)ssize+=tsize;
		4357	else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
		4358	numel+=tteg->numoper;
		4359	free(tteg->baza);
		4360	free(tteg);
		4361	size=0;
		4362	nexttok();
		4363	break;
		4364	}
		4365	}
		4366	datatype_expected();
		4367	}
		4368	if(strcmp(itok.name,newteg->name)==0&&tok2==tk_openbracket){
		4369	if(oflag==0){
		4370	newteg->flag\|=fs_constructor;
		4371	oflag\|=fs_constructor;
		4372	orm=am32==FALSE?tk_word:tk_dword;
		4373	}
		4374	else if(oflag==fs_destructor){
		4375	strcat(itok.name,"~");
		4376	orm=tk_void;
		4377	}
		4378	goto dproc2;
		4379	}
		4380	if((tteg=FindTeg(FALSE))!=NULL\|\|(tteg=FindTeg(TRUE))!=NULL){
		4381	if(tok2==tk_mult){
		4382	while(tok2==tk_mult)nexttok();
		4383	if(am32){
		4384	localtok=tk_dwordvar;
		4385	size=4;
		4386	orm=tk_dword;
		4387	}
		4388	else{
		4389	localtok=tk_wordvar;
		4390	size=2;
		4391	orm=tk_word;
		4392	}
		4393	warpointerstruct();
		4394	}
		4395	else{
		4396	size=tteg->size;
		4397	localtok=tk_struct;
		4398	}
		4399	goto locvar;
		4400	// break;
		4401	}
		4402	default:
		4403	skipfind=LOCAL; //�� 쭮� � ��쭮� ᯨ᪥
		4404	utestInitVar=TRUE;
		4405	if((i=testInitVar())==FALSE\|\|i==2){ //��।�� 楤�� ࠡ��뢠��
		4406	skipfind=FALSE; //ࠧ��
		4407	FindEndLex();
		4408	datatype_expected();
		4409	nexttok();
		4410	size=0;
		4411	break;
		4412	}
		4413	oflag\|=itok.flag;
		4414	npointr=itok.npointr;
		4415	if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
		4416	orm=itok.rm;
		4417	if(tok2==tk_openbracket&&strcmp(itok.name,newteg->name)==0){
		4418	newteg->flag\|=fs_constructor;
		4419	oflag\|=fs_constructor;
		4420	if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;
		4421	}
		4422	/* if(tok==tk_openbracket){
		4423	if(itok.npointr)orm=am32==FALSE?tk_word:tk_dword;
		4424	npointr=0;
		4425	nexttok();
		4426	while(tok==tk_mult){ //㪠��⥫� �� 楤��
		4427	npointr++;
		4428	nexttok();
		4429	}
		4430	type=pointer;
		4431	}*/
		4432	goto dproc2;
		4433	}
		4434	if(size!=0){
		4435	locvar:
		4436	do{
		4437	tsize=size;
		4438	skipfind=LOCAL; //�� 쭮� � ��쭮� ᯨ᪥
		4439	nexttok();
		4440	if(tok==tk_colon){
		4441	numt=getsizebit(size);
		4442	if(numt==0)numt=size8-bitofs%(size8); //(am32==0?16:32)-bitofs%(am32==0?16:32);
		4443	bitofs+=numt;
		4444	continue;
		4445	}
		4446	dproc2:
		4447	if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg));
		4448	else bazael=(struct elementteg )REALLOC(bazael,sizeof(struct elementteg)(numel+1));
		4449	if(tok!=tk_ID&&tok!=tk_id){
		4450	utestInitVar=TRUE;
		4451	if(testInitVar()==FALSE){ //��।�� 楤�� ࠡ��뢠��
		4452	idalreadydefined();
		4453	}
		4454	else{
		4455	oflag\|=itok.flag;
		4456	npointr=itok.npointr;
		4457	if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
		4458	if(itok.rm!=tokens)orm=itok.rm;
		4459	if(tok==tk_openbracket){
		4460	if(itok.npointr)orm=am32==FALSE?tk_word:tk_dword;
		4461	npointr=0;
		4462	nexttok();
		4463	while(tok==tk_mult){ //㪠��⥫� �� 楤��
		4464	npointr++;
		4465	nexttok();
		4466	}
		4467	type=pointer;
		4468	}
		4469	for(i=0;i
		4470	if(strcmp((bazael+i)->name,itok.name)==0)idalreadydefined();
		4471	}
		4472	strcpy((bazael+numel)->name,itok.name);
		4473	if(tok2==tk_openbracket&&strcmp(itok.name,newteg->name)==0){
		4474	newteg->flag\|=fs_constructor;
		4475	oflag\|=fs_constructor;
		4476	if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;
		4477	}
		4478	nexttok();
		4479	if(tok==tk_openbracket\|\|type==pointer)goto dproc;
		4480	if(npointr){
		4481	idrec *nrec;
		4482	nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
		4483	strcpy(nrec->recid,(bazael+numel)->name);//᪮��
		4484	nrec->newid=NULL;
		4485	nrec->npointr=(unsigned short)npointr;
		4486	nrec->flag=oflag;
		4487	nrec->line=linenumber;
		4488	nrec->file=currentfileinfo;
		4489	nrec->rectok=(bazael+numel)->tok=tk_pointer;
		4490	nrec->type=(unsigned short)orm;
		4491	tsize=2;
		4492	if(am32\|\|(oflag&f_far))tsize=4;
		4493	goto endelteg;
		4494	}
		4495	else unuseableinput();
		4496	}
		4497	}
		4498	else{
		4499	for(i=0;i
		4500	if(strcmp((bazael+i)->name,itok.name)==0){
		4501	idalreadydefined();
		4502	FindEndLex();
		4503	break;
		4504	}
		4505	}
		4506	strcpy((bazael+numel)->name,itok.name/(char )string*/);
		4507	if(tok2==tk_openbracket&&utestInitVar==FALSE){
		4508	if(tok==tk_id)oflag\|=(comfile==file_w32?tp_stdcall:tp_pascal); //⨯ �� 㬮�砭��
		4509	else oflag=tp_fastcall;
		4510	}
		4511	// printf("tok=%d %s\n",tok,itok.name);
		4512	nexttok();
		4513	if(tok==tk_colon){
		4514	numt=getsizebit(size);
		4515	if(numt==0)preerror("Bit fields must contain at least one bit");
		4516	(bazael+numel)->ofs=ssize;
		4517	(bazael+numel)->tok=tk_bits;
		4518	(bazael+numel)->bit.siz=numt;
		4519	(bazael+numel)->bit.ofs=bitofs;
		4520	if(useunion==FALSE)bitofs+=numt;
		4521	else if(numt>bitsize)bitsize=numt;
		4522	// printf("n=%d size=%d %s\n",numel,numt,(bazael+numel)->name);
		4523	}
		4524	else if(tok==tk_openbracket){
		4525	dproc:
		4526	idrec *nrec;
		4527	param[0]=0;
		4528	if(type==pointer)expecting(tk_closebracket);
		4529	else{
		4530	if(npointr){
		4531	orm=am32==FALSE?tk_word:tk_dword;
		4532	npointr=0;
		4533	}
		4534	}
		4535	skipfind=FALSE; //ࠧ��
		4536	expecting(tk_openbracket);
		4537	if((oflag&f_typeproc)==tp_fastcall)declareparamreg();
		4538	else declareparamstack();
		4539	skipfind=LOCAL;
		4540	nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
		4541	strcpy(nrec->recid,(bazael+numel)->name);//᪮��
		4542	nrec->newid=NULL;
		4543	// printf("name=%s param=%s\n",nrec->recid,param);
		4544	if(param[0]!=0)nrec->newid=BackString((char *)param);
		4545	if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;//tk_void;
		4546	nrec->npointr=(unsigned short)npointr;
		4547	nrec->recrm=orm;
		4548	nrec->flag=oflag;
		4549	nrec->line=linenumber;
		4550	nrec->file=currentfileinfo;
		4551	nrec->count=0;
		4552	nrec->recpost=0;//itok.post;
		4553	nrec->recsize=0;//itok.size;
		4554	nrec->recsib=(am32==TRUE?CODE32:CODE16);//itok.sib;
		4555	nrec->sbuf=NULL;
		4556	if(npointr){
		4557	nrec->rectok=(bazael+numel)->tok=tk_pointer;
		4558	nrec->type=tk_proc;
		4559	nrec->recsib=am32==FALSE?rm_d16:rm_d32;
		4560	tsize=2;
		4561	if(am32\|\|(oflag&f_far))tsize=4;
		4562	if(bitofs&&(!useunion)){
		4563	ssize+=(bitofs+7)/8;
		4564	bitofs=0;
		4565	}
		4566	tsize=Align(tsize,strpackcur); //new 16.03.05 14:21
		4567	nrec->recnumber=(bazael+numel)->ofs=ssize;
		4568	if(useunion==FALSE)ssize+=tsize;
		4569	else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
		4570	}
		4571	else{
		4572	(bazael+numel)->tok=tk_proc;
		4573	nrec->rectok=tk_declare;
		4574	nrec->type=tp_ucnovn;
		4575	nrec->recsegm=NOT_DYNAMIC;
		4576	(bazael+numel)->ofs=0;
		4577	nrec->recnumber=secondcallnum++;
		4578	nrec->flag\|=f_classproc;
		4579	}
		4580	(bazael+numel)->numel=1;
		4581	nexttok();
		4582	if(tok==tk_openbracket)IsUses(nrec);
		4583	// printf("name=%s post=%08X\n",nrec->recid,nrec->recpost);
		4584	}
		4585	else{
		4586	(bazael+numel)->rec=NULL;
		4587	(bazael+numel)->tok=localtok;
		4588	endelteg:
		4589	if(bitofs&&(!useunion)){
		4590	ssize+=(bitofs+7)/8;
		4591	bitofs=0;
		4592	}
		4593	(bazael+numel)->ofs=ssize;
		4594	numt=1;
		4595	if(tok==tk_openblock){//[
		4596	skipfind=FALSE;
		4597	nexttok();
		4598	numt=doconstlongmath();
		4599	expecting(tk_closeblock);
		4600	skipfind=LOCAL;
		4601	}
		4602	(bazael+numel)->numel=numt;
		4603	// printf("%d: unionsize=%d elemsize=%d\n",numel,unionsize,tsize*numt);
		4604	if((oflag&f_static)){
		4605	idrec *nrec;
		4606	nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
		4607	strcpy(nrec->recid,(bazael+numel)->name);//᪮��
		4608	nrec->line=linenumber;
		4609	nrec->file=currentfileinfo;
		4610	nrec->count=0;
		4611	nrec->sbuf=NULL;
		4612	nrec->recsize=tsize*numt;
		4613	nrec->recsegm=DS;
		4614	if(localtok==tk_struct){
		4615	nrec->recsib=0;
		4616	nrec->newid=(char *)tteg;
		4617	(bazael+numel)->tok=nrec->rectok=tk_structvar;
		4618	nrec->flag=/flag\|/tteg->flag;
		4619	if(FixUp)nrec->flag\|=f_reloc;
		4620	nrec->recrm=numt;
		4621	}
		4622	else{
		4623	nrec->newid=NULL;
		4624	nrec->npointr=(unsigned short)npointr;
		4625	nrec->recrm=(am32==FALSE?rm_d16:rm_d32);
		4626	if(FixUp)oflag\|=f_reloc;
		4627	nrec->flag=oflag;
		4628	nrec->recsib=(am32==TRUE?CODE32:CODE16);//itok.sib;
		4629	nrec->rectok=localtok;
		4630	nrec->type=tp_ucnovn;
		4631	}
		4632	if(tok==tk_assign){
		4633	skipfind=FALSE; //ࠧ��
		4634	nrec->recpost=0;
		4635	if(localtok==tk_struct){
		4636	if(alignword)alignersize+=AlignCD(DS,2); //��஢��
		4637	nrec->recnumber=outptrdata; //�� 砫� ��
		4638	i=initstructvar(tteg,numt);
		4639	if(numt==0){
		4640	numt=i/tteg->size;
		4641	if((i%tteg->size)!=0){
		4642	numt++;
		4643	i=tteg->size-(i%tteg->size);
		4644	for(;i!=0;i--)opd(0);
		4645	i=numt*tteg->size;
		4646	}
		4647	nrec->recrm=numel;
		4648	nrec->recsize=i;
		4649	}
		4650	datasize+=i;
		4651	}
		4652	else{
		4653	if(alignword)alignersize+=AlignCD(DS,tsize);
		4654	nrec->recnumber=outptrdata;
		4655	initglobalvar(orm,numt,tsize,variable);
		4656	datasize+=tsize*numt;
		4657	}
		4658	}
		4659	else{
		4660	nrec->recpost=1;
		4661	if(localtok==tk_struct){
		4662	if(numt==0){
		4663	ZeroMassiv();
		4664	break;
		4665	}
		4666	}
		4667	if(alignword){ //��஢��
		4668	if(postsize%2==1)postsize++;
		4669	if(tsize==4&&postsize%4!=0)postsize+=2;
		4670	}
		4671	nrec->recnumber=postsize;
		4672	AddPostData(numt*tteg->size);
		4673	}
		4674	}
		4675	else{
		4676	tsize=Align(tsize*numt,strpackcur); //new 16.03.05 14:21
		4677	if(useunion==FALSE)ssize+=tsize;
		4678	else if(unionsize<(unsigned int)tsize)unionsize=tsize;
		4679	if(localtok==tk_struct)(bazael+numel)->nteg=tteg;
		4680	}
		4681	}
		4682	if(useunion)bitofs=0;
		4683	numel++;
		4684	}
		4685	newteg->size=ssize+unionsize;
		4686	}while(tok==tk_camma);
		4687	skipfind=FALSE; //ࠧ��
		4688	seminext();
		4689	}
		4690	};//while(tok!=tk_closebrace&&tok!=tk_eof);
		4691	if(bitofs&&useunion==FALSE)ssize+=(bitofs+7)/8;
		4692	else if(bitsize&&((unsigned int)((bitsize+7)/8)>unionsize))unionsize=(bitsize+7)/8;
		4693	// printf("bitofs=%d size=%d\n",bitofs,ssize);
		4694	if(isdestr==FALSE&&isbase>1){
		4695	char buf=(char )MALLOC(16);
		4696	strcpy(buf,"(){");
		4697	int j;
		4698	for(i=0,j=0;i
		4699	if(GetFirstDestr((structteg *)(bazael+i)->nteg))j++;
		4700	}
		4701	if(j>1){
		4702	strcat(buf,"};");
		4703	int oflag,oinptr2;
		4704	char ocha2;
		4705	int oldendinptr=endinptr;
		4706	char *oinput;
		4707	idrec *nrec;
		4708	oinptr2=inptr2;
		4709	ocha2=cha2;
		4710	oinput=(char*)input;
		4711	string[0]=0;
		4712	newteg->flag\|=fs_destructor;
		4713	strcpy(itok.name,newteg->name);
		4714	if(CidOrID()==tk_ID)oflag=tp_fastcall;
		4715	else oflag=(comfile==file_w32?tp_stdcall:tp_pascal);
		4716	bazael=(struct elementteg )REALLOC(bazael,sizeof(struct elementteg)(numel+1));
		4717	strcpy((bazael+numel)->name,itok.name);
		4718	strcat((bazael+numel)->name,"~");
		4719	itok.rec=nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
		4720	strcpy(nrec->recid,itok.name);//᪮��
		4721	nrec->newid=NULL;
		4722	itok.npointr=nrec->npointr=0;
		4723	itok.rm=nrec->recrm=tk_void;
		4724	itok.flag=nrec->flag=fs_destructor\|oflag\|f_classproc;
		4725	nrec->line=linenumber;
		4726	nrec->file=currentfileinfo;
		4727	nrec->count=0;
		4728	itok.post=nrec->recpost=0;
		4729	itok.size=nrec->recsize=0;
		4730	itok.sib=nrec->recsib=(am32==TRUE?CODE32:CODE16);
		4731	nrec->sbuf=NULL;
		4732	(bazael+numel)->tok=tk_proc;
		4733	tok=nrec->rectok=tk_declare;
		4734	itok.type=nrec->type=tp_ucnovn;
		4735	itok.segm=nrec->recsegm=NOT_DYNAMIC;
		4736	(bazael+numel)->ofs=0;
		4737	itok.number=nrec->recnumber=secondcallnum++;
		4738	(bazael+numel)->numel=1;
		4739	numel++;
		4740	input=(unsigned char*)buf;
		4741	inptr2=1;
		4742	cha2='(';
		4743	endinptr=strlen(buf);
		4744	searchteg=newteg;
		4745	dynamic_proc();
		4746	searchteg=NULL;
		4747	input=(unsigned char*)oinput;
		4748	inptr2=oinptr2;
		4749	cha2=ocha2;
		4750	endinptr=oldendinptr;
		4751	}
		4752	free(buf);
		4753	}
		4754	newteg->size=ssize+unionsize;
		4755	newteg->numoper=numel;
		4756	newteg->baza=bazael;
		4757	nexttok();
		4758	if(noname==FALSE&&nameid==FALSE){
		4759	if(tok==tk_ID\|\|tok==tk_id){
		4760	strcpy(newteg->name,itok.name);
		4761	AddTegToTree(newteg,Global);
		4762	}
		4763	else{
		4764	notstructname();
		4765	if(newteg->baza)free(newteg->baza);
		4766	free(newteg);
		4767	newteg=NULL;
		4768	}
		4769	}
		4770	return newteg;
		4771	}
		4772
		4773
		4774	{
		4775	struct structteg *tteg;
		4776	int i;
		4777	char *tn;
		4778	if((tn=strchr(name,'@'))!=NULL)*tn=0;
		4779	tteg=(Global==TRUE?tegtree:ltegtree);
		4780	while(tteg&&(i=strcmp(tteg->name,name))!=0)tteg=(i<0?tteg->left:tteg->right);
		4781	return tteg;
		4782	}
		4783
		4784
		4785	{
		4786	unsigned int loop=0;
		4787	switch(type){
		4788	case tk_bytevar:
		4789	case tk_charvar:
		4790	opd(val);
		4791	break;
		4792	case tk_wordvar:
		4793	case tk_intvar:
		4794	outwordd(val);
		4795	loop++;
		4796	break;
		4797	case tk_dwordvar:
		4798	case tk_longvar:
		4799	case tk_floatvar:
		4800	outdwordd(val);
		4801	loop+=3;
		4802	break;
		4803	case tk_qwordvar:
		4804	case tk_doublevar:
		4805	outqwordd(val);
		4806	loop+=7;
		4807	break;
		4808	case tk_pointer:
		4809	if(am32){
		4810	outdwordd(val);
		4811	loop+=3;
		4812	}
		4813	else{
		4814	outwordd(val);
		4815	loop++;
		4816	}
		4817	break;
		4818	case tk_proc:
		4819	loop--;
		4820	break;
		4821	default: internalerror("Bad type variable");
		4822	}
		4823	return loop;
		4824	}
		4825
		4826
		4827	/*-----------------03.10.99 00:20-------------------
		4828	�� 묨 ��稭��
		4829	--------------------------------------------------*/
		4830	{
		4831	struct elementteg *elem=tteg->baza;
		4832	int bitofs=0;
		4833	unsigned int startstruct;
		4834	if(dbg&2)AddDataLine(1/,variable/);
		4835	for(unsigned int j=0;j
		4836	startstruct=outptrdata;
		4837	for(unsigned int c=0;cnumoper;c++){
		4838	if((elem+c)->ofs)outptrdata=startstruct+(elem+c)->ofs;
		4839	if(splitdata==FALSE)outptr=outptrdata;
		4840	int type=(elem+c)->tok;
		4841	if(type==tk_bits){
		4842	opb(val,(elem+c)->bit.ofs,(elem+c)->bit.siz);
		4843	bitofs=(elem+c)->bit.ofs+(elem+c)->bit.siz;
		4844	}
		4845	else{
		4846	if(bitofs){
		4847	CorrectOfsBit(bitofs);
		4848	bitofs=0;
		4849	}
		4850	for(unsigned int i=0;i<(elem+c)->numel;i++){
		4851	if(type==tk_struct\|\|type==tk_baseclass){
		4852	FillTeg(val,(elem+c)->numel,(struct structteg *)(elem+c)->nteg);
		4853	break;
		4854	}
		4855	SaveVal(val,type);
		4856	}
		4857	}
		4858	}
		4859	}
		4860	if(bitofs)CorrectOfsBit(bitofs);
		4861	}
		4862
		4863
		4864	/*-----------------03.10.99 00:20-------------------
		4865	�� 稭��
		4866	--------------------------------------------------*/
		4867	{
		4868	unsigned long long hold;
		4869	struct elementteg *elem=tteg->baza;
		4870	unsigned int tnumel=0; //�� ⨯�
		4871	unsigned int ttype=0; //��
		4872	unsigned int nums=0; //��
		4873	unsigned int loop=0; //�� ࠧ��
		4874	int type=tokens;
		4875	int bitofs=0;
		4876	unsigned int startstruct=outptrdata;
		4877	scanalltoks=FALSE;
		4878	for(;;){
		4879	hold=0;
		4880	if(tnumel==(elem+ttype)->numel\|\|type==tk_bits){
		4881	tnumel=0;
		4882	ttype++;
		4883	if(ttype==tteg->numoper){
		4884	ttype=0;
		4885	nums++;
		4886	startstruct=outptrdata;
		4887	if(nums==numel){
		4888	scanalltoks=TRUE;
		4889	return loop;
		4890	}
		4891	}
		4892	loop=(elem+ttype)->ofs;
		4893	outptrdata=startstruct+loop;
		4894	if(splitdata==FALSE)outptr=outptrdata;
		4895	loop+=tteg->size*nums;
		4896	}
		4897	tnumel++;
		4898	type=(elem+ttype)->tok;
		4899	// puts((elem+ttype)->name);
		4900	if(type==tk_struct\|\|type==tk_baseclass){
		4901	tnumel=(elem+ttype)->numel;
		4902	loop+=Fill2Teg((elem+ttype)->numel,(struct structteg *)(elem+ttype)->nteg);
		4903	if(tok==tk_closebrace)break;
		4904	continue;
		4905	}
		4906	if(type==tk_proc)continue;
		4907	if((elem+ttype)->rec&&((elem+ttype)->rec->flag&f_static))continue;
		4908	if(dbg&2)AddDataLine((char)GetVarSize(type)/,variable/);
		4909	loopsw:
		4910	int htok=tok;
		4911	// printf("tok=%d\n",tok);
		4912	switch(tok){
		4913	case tk_camma:
		4914	hold=0;
		4915	goto strl3;
		4916	case tk_postnumber:
		4917	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		4918	itok.flag=0;
		4919	// goto strl1;
		4920	case tk_undefofs:
		4921	// AddUndefOff(1,itok.name);
		4922	//strl1:
		4923	tok=tk_number;
		4924	if(htok==tk_undefofs)AddUndefOff(3,itok.name);
		4925	hold+=doconstdwordmath();
		4926	if(tok==tk_plus&&tok2==tk_postnumber&&htok!=tk_undefofs){
		4927	nexttok();
		4928	goto loopsw;
		4929	}
		4930	goto strl2;
		4931	case tk_minus:
		4932	case tk_number:
		4933	if(type==tk_bytevar\|\|type==tk_wordvar\|\|type==tk_dwordvar\|\|type==tk_bits\|\|type==tk_pointer){
		4934	hold=doconstdwordmath();
		4935	}
		4936	else if(type==tk_charvar\|\|type==tk_intvar\|\|type==tk_longvar){
		4937	hold=doconstlongmath();
		4938	}
		4939	else if(type==tk_floatvar)hold=doconstfloatmath();
		4940	else if(type==tk_doublevar)hold=doconstdoublemath();
		4941	else if(type==tk_qwordvar)hold=doconstqwordmath();
		4942	// printf("tok=%d num=%08X\n",tok,hold);
		4943	strl2:
		4944	if((postnumflag&f_reloc)!=0)AddReloc();
		4945	strl3:
		4946	if(type==tk_bits){
		4947	opb(hold,(elem+ttype)->bit.ofs,(elem+ttype)->bit.siz);
		4948	bitofs=(elem+ttype)->bit.ofs+(elem+ttype)->bit.siz;
		4949	}
		4950	else{
		4951	if(bitofs){
		4952	CorrectOfsBit(bitofs);
		4953	loop+=(bitofs+7)/8;
		4954	bitofs=0;
		4955	}
		4956	loop+=SaveVal(hold,type);
		4957	}
		4958	break;
		4959	case tk_string:
		4960	if(type==tk_bytevar\|\|type==tk_charvar){
		4961	unsigned int i;
		4962	if((unsigned int)itok.number<(elem+ttype)->numel)i=itok.number;
		4963	else i=(elem+ttype)->numel;
		4964	tnumel=0;
		4965	for(;tnumel
		4966	opd(string[tnumel]);
		4967	}
		4968	if(tnumel<(elem+ttype)->numel){
		4969	switch(itok.flag&3){
		4970	case zero_term:
		4971	if(itok.flag&s_unicod)opd(0);
		4972	opd(0);
		4973	tnumel++;
		4974	break;
		4975	case dos_term:
		4976	if(itok.flag&s_unicod)opd(0);
		4977	opd('$');
		4978	tnumel++;
		4979	break;
		4980	}
		4981	while(tnumel<(elem+ttype)->numel){
		4982	opd(aligner);
		4983	tnumel++;
		4984	}
		4985	}
		4986	loop+=tnumel-1;
		4987	nexttok();
		4988	break;
		4989	}
		4990	if(am32==FALSE){
		4991	outwordd(addpoststring());
		4992	if(type==tk_longvar\|\|type==tk_dwordvar){
		4993	loop+=2;
		4994	outword(0);
		4995	}
		4996	loop++;
		4997	}
		4998	else{
		4999	if(type==tk_intvar\|\|type==tk_wordvar)dwordvalexpected();
		5000	outdwordd(addpoststring());
		5001	loop+=3;
		5002	}
		5003	nexttok();
		5004	break;
		5005	default:
		5006	numexpected();
		5007	nexttok();
		5008	break;
		5009	}
		5010	loop++;
		5011	if(tok==tk_closebrace)break;
		5012	// printf("tok=%d\n",tok);
		5013	expecting(tk_camma);
		5014	}
		5015	scanalltoks=TRUE;
		5016	if(bitofs){
		5017	CorrectOfsBit(bitofs);
		5018	loop+=(bitofs+7)/8;
		5019	}
		5020	return loop;
		5021	}
		5022
		5023
		5024	{
		5025	unsigned int loop=0;
		5026	nexttok();
		5027	switch(tok){ //�� 稭��
		5028	case tk_minus:
		5029	case tk_number:
		5030	if(numel==0)ZeroMassiv();
		5031	FillTeg(doconstqwordmath(),numel,tteg);
		5032	loop=numel*tteg->size;
		5033	break;
		5034	case tk_from: //�� 䠩� � ��묨
		5035	nexttok();
		5036	loop=dofrom();
		5037	for(;loopsize*numel;loop++)opd(aligner);
		5038	nexttok();
		5039	break;
		5040	case tk_extract: //�� ࠣ�� 䠩�� 묨
		5041	nexttok();
		5042	loop=doextract();
		5043	for(;loopsize*numel;loop++)opd(aligner);
		5044	break;
		5045	case tk_openbrace: //��ᨢ ��
		5046	nexttok();
		5047	loop=Fill2Teg(numel,tteg);
		5048	for(;loopsize*numel;loop++)opd(aligner);
		5049	if(tok!=tk_closebrace){
		5050	preerror("extra parameter at initialization of structure");
		5051	while(tok!=tk_closebrace&&tok!=tk_eof)nexttok();
		5052	}
		5053	nexttok();
		5054	break;
		5055	default:
		5056	// printf("tok=%d\n",tok);
		5057	numexpected(); nexttok(); break;
		5058	}
		5059	return loop;
		5060	}
		5061
		5062
		5063	{
		5064	struct idrec newrec=NULL,ptr;
		5065	int numel,count;
		5066	char done=0,dynamic;
		5067	unsigned int loop;
		5068	while(tok!=tk_eof&&done==0){
		5069	loop=0;
		5070	// printf("3 tok=%d %s\n",tok,itok.name);
		5071	switch(tok){
		5072	case tk_id:
		5073	case tk_ID: //��樠��஢��
		5074	//�뤥��
		5075	newrec=(struct idrec *)MALLOC(sizeof(struct idrec));
		5076
		5077
		5078
		5079
		5080	if(ptr==NULL)((flag&f_static)==0?treestart:staticlist)=newrec;//��砫� ��ॢ�
		5081	else{ //�� ப� � ��ॢ�
		5082	while(((numel=strcmp(ptr->recid,itok.name))<0&&ptr->left!=NULL)\|\|(numel>0&&ptr->right!=NULL)){
		5083	ptr=(numel<0?ptr->left:ptr->right);
		5084	}
		5085	(numel<0?ptr->left:ptr->right)=newrec; //��ப� ��
		5086	}
		5087	newrec->recsib=0;
		5088	strcpy(newrec->recid,itok.name);//᪮��
		5089	newrec->newid=(char *)tteg;
		5090	newrec->left=NULL;
		5091	newrec->right=NULL;
		5092	newrec->rectok=tk_structvar;
		5093	newrec->flag=flag\|tteg->flag;
		5094	newrec->line=linenumber;
		5095	newrec->file=currentfileinfo;
		5096	newrec->type=tp_gvar;
		5097	if(FixUp)newrec->flag\|=f_reloc;
		5098	numel=1;
		5099	nexttok();
		5100	if(tok==tk_openblock){//[
		5101	nexttok();
		5102	if(tok!=tk_closeblock)numel=doconstlongmath(); //�᫮ ��⮢
		5103	else numel=0;
		5104	expecting(tk_closeblock);//]
		5105	}
		5106	newrec->recrm=numel;
		5107	newrec->recsize=numel*tteg->size;
		5108	dynamic=FALSE;
		5109	if(tok==tk_assign\|\|notpost==TRUE){//=
		5110	if(useStartup==TRUE&&tok!=tk_assign&&numel!=0){
		5111	if(SaveStruct(numel*tteg->size,newrec)==TRUE)break;
		5112	}
		5113	if(alignword&&(!dynamic_flag))alignersize+=AlignCD(DS,2); //��஢��
		5114	// NotPostUnion();
		5115	itok.rec=newrec;
		5116	if((count=FindOff((unsigned char *)newrec->recid,DS))==0){
		5117	if(dynamic_flag)dynamic=DYNAMIC_VAR;
		5118	}
		5119	else if(dynamic_flag)dynamic=USED_DIN_VAR;
		5120	newrec->recnumber=(dynamic==0?outptrdata:0); //�� 砫� ��
		5121	newrec->recpost=dynamic;
		5122	if(notpost==TRUE&&tok!=tk_assign){
		5123	if(numel==0)ZeroMassiv();
		5124	for(;loopsize*numel;loop++)opd(aligner);
		5125	datasize+=loop;
		5126	break;
		5127	}
		5128	if(dynamic)newrec->sbuf=dynamic_var();
		5129	else{
		5130	loop=initstructvar(tteg,numel);
		5131	if(numel==0){
		5132	numel=loop/tteg->size;
		5133	if((loop%tteg->size)!=0){
		5134	numel++;
		5135	int i=tteg->size-(loop%tteg->size);
		5136	for(;i!=0;i--)opd(0);
		5137	loop=numel*tteg->size;
		5138	}
		5139	newrec->recrm=numel;
		5140	newrec->recsize=loop;
		5141	}
		5142	datasize+=loop;
		5143	}
		5144	}
		5145	else{
		5146	if(numel==0){
		5147	ZeroMassiv();
		5148	break;
		5149	}
		5150	if(CheckUseAsUndef((unsigned char *)newrec->recid)==0&&dynamic_flag)dynamic=TRUE;
		5151	switch(tok){ //��樠��஢��
		5152	default: expected(';');
		5153	case tk_semicolon: done=1;// ;
		5154	case tk_camma: //, post global type
		5155	// long longpostsize;
		5156	if(useStartup==TRUE){
		5157	if(SaveStruct(numel*tteg->size,newrec)==TRUE){
		5158	nexttok();
		5159	break;
		5160	}
		5161	}
		5162	newrec->recpost=dynamic+1;
		5163	loop=numel*tteg->size;
		5164	if((flag&f_extern)==0&&dynamic==0){
		5165	if(alignword){ //��஢��
		5166	if(postsize%2==1)postsize++;
		5167	}
		5168	newrec->recnumber=postsize;
		5169	}
		5170	else newrec->recnumber=externnum++;
		5171	count=FindOff((unsigned char *)newrec->recid,VARPOST);
		5172	if((flag&f_extern)==0&&dynamic==0)
		5173	/*-----------------10.09.02 23:21-------------------
		5174	�� 맮� �� ᫥ FindOff
		5175	--------------------------------------------------*/
		5176	AddPostData(loop);
		5177	nexttok();
		5178	break;
		5179	}
		5180	}
		5181	newrec->count=count;
		5182	break;
		5183	case tk_proc:
		5184	case tk_qwordvar:
		5185	case tk_doublevar:
		5186	case tk_floatvar:
		5187	case tk_dwordvar:
		5188	case tk_longvar:
		5189	case tk_charvar:
		5190	case tk_intvar:
		5191	case tk_bytevar:
		5192	case tk_wordvar: idalreadydefined(); nexttok(); break;
		5193	default:
		5194	if(newrec)expected(';');
		5195	else errstruct();
		5196	FindStopTok();
		5197	case tk_semicolon: done=1;
		5198	case tk_camma: nexttok(); break;
		5199	}
		5200	}
		5201	dopoststrings();
		5202	}
		5203
		5204
		5205	{
		5206	struct structteg *tteg;
		5207	unsigned int flag;
		5208	//if(debug)puts("start init struct");
		5209	flag=itok.flag;
		5210	if(fstatic){
		5211	flag\|=f_static;
		5212	fstatic=FALSE;
		5213	}
		5214	if(tok==tk_struct)nexttok();
		5215	else if(tok2!=tk_id&&tok2!=tk_ID){
		5216	if(tok2==tk_dblcolon){
		5217	itok.flag=f_classproc;
		5218	itok.rm=am32==FALSE?tk_word:tk_dword;//tk_void;
		5219	itok.npointr=0;
		5220	doclassproc(0/comfile==file_w32?tk_stdcall:tk_pascal 18.10.05 10:52/);
		5221	return;
		5222	}
		5223	notstructname();
		5224	}
		5225	tteg=FindTeg(TRUE);
		5226	if(tteg==NULL){
		5227	if(tok==tk_openbrace\|\|tok2==tk_openbrace\|\|tok==tk_colon\|\|tok2==tk_colon)
		5228	tteg=CreatTeg(TRUE); //�� ᮧ�� ⥣
		5229	else{
		5230	while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
		5231	tegnotfound();
		5232	return;
		5233	}
		5234	}
		5235	else{
		5236	if(tok2==tk_openbrace)idalreadydefined();
		5237	nexttok();
		5238	}
		5239	InitStruct2(flag,tteg);
		5240	}
		5241
		5242
		5243	{
		5244	int numel,first=FALSE;
		5245	struct localrec *newrec;
		5246	unsigned long size=0;
		5247	skipfind=TRUE; //�� ᪠�� 쭮� ��ॢ�
		5248	do{
		5249	if(first!=FALSE){
		5250	binptr=inptr2;
		5251	bcha=cha2;
		5252	nexttok();
		5253	}
		5254	first=TRUE;
		5255	if(tok!=tk_ID&&tok!=tk_id)idalreadydefined();
		5256	else{ //��樠��஢��
		5257	numel=1;
		5258	newrec=addlocalvar((char *)string,tk_structvar,localsize);
		5259	newrec->rec.newid=(char *)tteg;
		5260	newrec->rec.flag=tteg->flag;
		5261	newrec->rec.type=tp_localvar;
		5262	nexttok();
		5263	if(tok==tk_openblock){//[
		5264	skipfind=FALSE;
		5265	nexttok();
		5266	numel=doconstlongmath(); //�᫮ ��⮢
		5267	skipfind=TRUE;
		5268	expecting(tk_closeblock);//]
		5269	}
		5270	newrec->rec.recrm=numel;
		5271	size=numel*tteg->size;
		5272	newrec->rec.recsize=size;
		5273	if(flag&f_static){
		5274	// if(bcha==0)not_union_static();
		5275	if(tok==tk_assign){
		5276	// newrec->rec.rectok=tk_structvar;
		5277	newrec->rec.recnumber=0;
		5278	newrec->rec.recpost=DYNAMIC_VAR;
		5279	// newrec->rec.recsize=tteg->size;
		5280	// newrec->rec.recrm=numel;
		5281	newrec->rec.line=linenumber;
		5282	newrec->rec.file=currentfileinfo;
		5283	newrec->rec.npointr=0;
		5284	newrec->rec.sbuf=dynamic_var();
		5285	newrec->rec.recsib=newrec->rec.type=tp_gvar;
		5286	}
		5287	else{
		5288	newrec->rec.recpost=TRUE;
		5289	if(alignword){ //��஢��
		5290	if(postsize%2==1)postsize++;
		5291	}
		5292	newrec->rec.recnumber=postsize;
		5293	AddPostData(size);
		5294	}
		5295	size=0;
		5296	}
		5297	else{
		5298	size=Align(size,(am32==FALSE?2:4));
		5299	newrec->rec.recpost=LOCAL;
		5300	newrec->rec.recnumber=-localsize-size;
		5301	// localsize+=size;
		5302	if(tok==tk_assign){
		5303	if(localline==0)localline=linenumber;
		5304	AddBackBuf(binptr,bcha);
		5305	}
		5306	}
		5307	}
		5308	localsize+=size;
		5309	}while(tok==tk_camma);
		5310	skipfind=FALSE; //�� ᪠�� 쭮� ��ॢ�
		5311	// localsize+=size;
		5312	itok.name[0]=0;
		5313	seminext();
		5314	return size;
		5315	}
		5316
		5317
		5318	{
		5319	struct structteg *tteg;
		5320	int binptr;
		5321	char bcha;
		5322	structteg *osearchteg;
		5323	osearchteg=searchteg;
		5324	searchteg=NULL;
		5325	skipfind=TRUE; //�� ᪠�� 쭮� ��ॢ�
		5326	if(tok==tk_struct)nexttok();
		5327	binptr=inptr2;
		5328	bcha=cha2;
		5329	if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
		5330	skipfind=FALSE;
		5331	if(tok==tk_openbrace\|\|tok2==tk_openbrace){
		5332	tteg=CreatTeg(FALSE); //�� ᮧ�� ⥣
		5333	}
		5334	else{
		5335	while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
		5336	tegnotfound();
		5337	searchteg=osearchteg;
		5338	return 0;
		5339	}
		5340	}
		5341	else{
		5342	searchteg=osearchteg;
		5343	if(tok2==tk_openbrace){
		5344	idalreadydefined();
		5345	SkipBlock2();
		5346	return 0;
		5347	}
		5348	nexttok();
		5349	if(tok!=tk_id&&tok!=tk_ID){
		5350	notstructname();
		5351	FindStopTok();
		5352	return 0;
		5353	}
		5354	}
		5355	searchteg=osearchteg;
		5356	return LocalStruct2(flag,localline,binptr,bcha,tteg);
		5357	}
		5358
		5359
		5360	{
		5361	struct structteg *tteg;
		5362	int numel;
		5363	int usenumstr;
		5364	SINFO rstr;
		5365	char *ofsst=NULL;
		5366	int oneloop=FALSE;
		5367	unsigned long hnum;
		5368	unsigned int num,sized=0,sign=FALSE;
		5369	unsigned long adr;
		5370	int localstr=FALSE;
		5371	int poststr;
		5372	int flagstr;
		5373	struct idrec *ptrs;
		5374	if(tok2==tk_assign){
		5375	switch(ScanTok3()){
		5376	case tk_proc:
		5377	case tk_apiproc:
		5378	case tk_undefproc:
		5379	case tk_declare:
		5380	ptrs=itok.rec;
		5381	if(ptrs->recpost==LOCAL){
		5382	if(ESPloc&&am32){
		5383	itok.rm=rm_mod10\|rm_sib;
		5384	itok.sib=0x24;
		5385	itok.number+=addESP;
		5386	}
		5387	else{
		5388	itok.rm=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP);
		5389	}
		5390	itok.segm=SS;
		5391	itok.post=0;
		5392	compressoffset(&itok);
		5393	}
		5394	else{
		5395	itok.segm=DS;
		5396	itok.rm=(am32==FALSE?rm_d16:rm_d32); //��⠭�� 㬮�砭��
		5397	itok.post=ptrs->recpost;
		5398	}
		5399	itok.sib=(am32==FALSE?CODE16:CODE32);
		5400	itok.flag=ptrs->flag;
		5401	switch(itok.size){
		5402	case 1:
		5403	tok=tk_bytevar;
		5404	dobytevar(0);
		5405	break;
		5406	case 2:
		5407	case 3:
		5408	tok=tk_wordvar;
		5409	do_d_wordvar(0,r16);
		5410	break;
		5411	case 4:
		5412	case 5:
		5413	case 6:
		5414	case 7:
		5415	tok=tk_dwordvar;
		5416	do_d_wordvar(0,r32);
		5417	break;
		5418	default:
		5419	tok=tk_qwordvar;
		5420	doqwordvar();
		5421	break;
		5422	}
		5423	return;
		5424	}
		5425	}
		5426	adr=itok.number;
		5427	numel=itok.rm; //�᫮ ��
		5428	usenumstr=itok.post; //�뫮 㪠��
		5429	if(itok.type==tp_classvar){
		5430	tteg=(structteg *)itok.rec;
		5431	poststr=0;
		5432	flagstr=f_useidx;
		5433	}
		5434	else{
		5435	ptrs=itok.rec;
		5436	tteg=(structteg *)ptrs->newid;
		5437	if(ptrs->recpost==LOCAL)localstr=TRUE;
		5438	poststr=ptrs->recpost;
		5439	flagstr=ptrs->flag;
		5440	}
		5441	rstr=strinf;
		5442	strinf.bufstr=NULL;
		5443	num=itok.size;
		5444	// if(bufrm)printf("num=%d %s\n",adr,bufrm);
		5445	nexttok();
		5446	if(tok==tk_assign){
		5447	getoperand();
		5448	int starts=0; //ᬥ饭��
		5449	if(tok==tk_int\|\|tok==tk_word){
		5450	sized=2;
		5451	getoperand();
		5452	}
		5453	else if(tok==tk_long\|\|tok==tk_dword){
		5454	sized=4;
		5455	getoperand();
		5456	}
		5457	else if(tok==tk_char\|\|tok==tk_byte){
		5458	sized=1;
		5459	getoperand();
		5460	}
		5461	switch(tok){
		5462	case tk_charvar:
		5463	case tk_bytevar:
		5464	case tk_intvar:
		5465	case tk_wordvar:
		5466	case tk_longvar:
		5467	case tk_dwordvar:
		5468	int razr,retreg;
		5469	ITOK wtok;
		5470	char *wbuf;
		5471	wbuf=bufrm;
		5472	bufrm=NULL;
		5473	wtok=itok;
		5474	SINFO wstr;
		5475	wstr=strinf;
		5476	strinf.bufstr=NULL;
		5477	if((retreg=CheckIDZReg(itok.name,AX,razr=GetVarSize(tok)))!=NOINREG){
		5478	GenRegToReg(AX,retreg,razr);
		5479	IDZToReg(itok.name,AX,razr);
		5480	if(bufrm){
		5481	free(bufrm);
		5482	bufrm=NULL;
		5483	}
		5484	if(strinf.bufstr){
		5485	free(strinf.bufstr);
		5486	strinf.bufstr=NULL;
		5487	}
		5488	if(sized){
		5489	switch(razr){
		5490	case r8: tok=tk_beg; break;
		5491	case r16: tok=tk_reg; break;
		5492	case r32: tok=tk_reg32; break;
		5493	}
		5494	itok.number=0;
		5495	goto convr;
		5496	}
		5497	break;
		5498	}
		5499	IDZToReg(itok.name,AX,razr);
		5500	if(sized==0){
		5501	switch(tok){
		5502	case tk_charvar:
		5503	case tk_bytevar:
		5504	getintoal(tok,&wtok,wbuf,&wstr);
		5505	sized=1;
		5506	break;
		5507	case tk_intvar:
		5508	sign=TRUE;
		5509	case tk_wordvar:
		5510	getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,r16);
		5511	sized=2;
		5512	break;
		5513	case tk_longvar:
		5514	sign=TRUE;
		5515	case tk_dwordvar:
		5516	getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,r32);
		5517	sized=4;
		5518	break;
		5519	}
		5520	}
		5521	else{
		5522	convr:
		5523	switch(sized){
		5524	case 1:
		5525	getintoal(tok,&wtok,wbuf,&wstr);
		5526	break;
		5527	case 2:
		5528	getinto_e_ax(0,tok,&wtok,wbuf,&wstr,r16);
		5529	break;
		5530	case 4:
		5531	getinto_e_ax(0,tok,&wtok,wbuf,&wstr,r32);
		5532	break;
		5533	}
		5534	}
		5535	if(usenumstr!=FALSE){
		5536	// num/=ptrs->recrm; //㪠�� - ��
		5537	num=tteg->size;
		5538	if(strinf.bufstr==NULL)starts=num*numel;
		5539	}
		5540	num/=sized;
		5541	goto fillstr;
		5542	case tk_minus:
		5543	nexttok();
		5544	if(tok!=tk_number){
		5545	errstruct();
		5546	break;
		5547	}
		5548	itok.number=-itok.number;
		5549	case tk_number:
		5550	if(sized==0){
		5551	sized=4;
		5552	if(itok.number<65536)sized=2;
		5553	if(itok.number<256)sized=1;
		5554	}
		5555	if(usenumstr!=FALSE){
		5556	// num/=ptrs->recrm; //㪠�� - ��
		5557	num=tteg->size;
		5558	if(strinf.bufstr==NULL)starts=num*numel;
		5559	}
		5560	if(strinf.bufstr==NULL){
		5561	if(optimizespeed==TRUE){
		5562	if(sized==1&&(num%2)==0){
		5563	sized=2;
		5564	itok.number=(itok.number&255)\|((itok.number<<8)&0xFF00);
		5565	}
		5566	if(chip>2&&sized==2&&(num%4)==0){
		5567	sized=4;
		5568	itok.number=(itok.number&0xFFFF)\|(itok.number<<16);
		5569	}
		5570	}
		5571	else{
		5572	if(am32==FALSE){
		5573	if(sized==1&&((num<7&&(num%2)==0)\|\|(itok.number==0&&num==8))){
		5574	sized=2;
		5575	itok.number=(itok.number&255)\|((itok.number<<8)&0xFF00);
		5576	}
		5577	}
		5578	else if(chip>2&&sized!=4&&(num%4)==0&&itok.number==0)sized=4;
		5579	}
		5580	}
		5581	num/=sized;
		5582	if(num==1){
		5583	oneloop++;
		5584	hnum=itok.number;
		5585	}
		5586	else if(num==2&&sized==2&&chip>2){
		5587	oneloop++;
		5588	hnum=(itok.number&0xFFFF)\|(itok.number<<16);
		5589	sized=4;
		5590	num=1;
		5591	}
		5592	else if(num==4&&sized==1&&chip>2){
		5593	oneloop++;
		5594	itok.number&=255;
		5595	hnum=itok.number\|(itok.number<<8)\|(itok.number<<16)\|(itok.number<<24);
		5596	sized=4;
		5597	num=1;
		5598	}
		5599	else{
		5600	if(sized==1){
		5601	if(itok.number==0)outword(0x00B0);
		5602	else{
		5603	op(0xB0);
		5604	op(itok.number);
		5605	}
		5606	ConstToReg(itok.number,AX,r8);
		5607	}
		5608	else MovRegNum(sized,0,itok.number,EAX);
		5609	}
		5610	fillstr:
		5611	// itok.number=ptrs->recnumber;
		5612	itok.number=adr;
		5613	if(rstr.bufstr==NULL)itok.number+=starts;
		5614	itok.sib=(am32==FALSE?CODE16:CODE32);
		5615	if(localstr){
		5616	if(comfile!=file_w32&&oneloop==FALSE){
		5617	pushss();
		5618	popes();
		5619	}
		5620	if(ESPloc&&am32){
		5621	itok.rm=rm_mod10\|rm_sib;
		5622	itok.sib=0x24;
		5623	itok.number+=addESP;
		5624	}
		5625	else{
		5626	itok.rm=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP);
		5627	}
		5628	itok.segm=SS;
		5629	tok=tk_rmnumber;
		5630	itok.post=0;
		5631	itok.size=tteg->size;
		5632	compressoffset(&itok);
		5633	if(rstr.bufstr!=NULL)CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
		5634	}
		5635	else{
		5636	if(comfile!=file_w32&&oneloop==FALSE){
		5637	pushds();
		5638	popes();
		5639	}
		5640	itok.post=poststr;
		5641	itok.segm=DS;
		5642	itok.rm=(am32==FALSE?rm_d16:rm_d32); //��⠭�� 㬮�砭��
		5643	itok.rec=NULL;//ptrs;
		5644	if(rstr.bufstr==NULL){
		5645	if(itok.post!=0)tok=tk_postnumber;
		5646	else tok=tk_number;
		5647	}
		5648	else{
		5649	// printf("bufrm=%s rstr=%s\n",bufrm,rstr.bufstr);
		5650	CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
		5651	// puts("end rm");
		5652	tok=tk_rmnumber;
		5653	itok.size=tteg->size; // ???? trap
		5654	}
		5655	}
		5656	itok.flag=flagstr;
		5657	if(oneloop){
		5658	switch(sized){
		5659	case 1:
		5660	outseg(&itok,2);
		5661	op(0xC6);
		5662	op(itok.rm);
		5663	outaddress(&itok);
		5664	op(hnum);
		5665	break;
		5666	case 2:
		5667	case 4:
		5668	op66(sized);
		5669	if(hnum==0){
		5670	outseg(&itok,2);
		5671	op(0x83);
		5672	op(itok.rm+0x20);
		5673	outaddress(&itok);
		5674	op(0);
		5675	break;
		5676	}
		5677	if((sized==4&&hnum==0xFFFFFFFF)\|\|(sized==2&&hnum==0xFFFF)){
		5678	outseg(&itok,2);
		5679	op(0x83);
		5680	op(itok.rm+0x8);
		5681	outaddress(&itok);
		5682	op(0xFF);
		5683	break;
		5684	}
		5685	if(optimizespeed==0&&sized==4&&short_ok(hnum,TRUE)){
		5686	op(0x6A);
		5687	op(hnum); //push short number
		5688	op66(sized);
		5689	outseg(&itok,2);
		5690	op(0x8f);
		5691	op(itok.rm);
		5692	outaddress(&itok);
		5693	break;
		5694	}
		5695	outseg(&itok,2);
		5696	op(0xC7); //mov word[],number
		5697	op(itok.rm);
		5698	outaddress(&itok);
		5699	if(sized==2)outword(hnum);
		5700	else outdword(hnum);
		5701	break;
		5702	}
		5703	}
		5704	else{
		5705	warningreg(regs[am32][DI]);
		5706	getintoreg_32(DI,(am32+1)*2,0,&ofsst);
		5707	if(num<=2\|\|(num<=4&&(!optimizespeed))){
		5708	for(unsigned int i=0;i
		5709	if(sized==1)stosb();
		5710	else if(sized==2)stosw();
		5711	else stosd();
		5712	}
		5713	}
		5714	else{
		5715	MovRegNum((am32+1)*2,0,num,ECX);
		5716	warningreg(regs[am32][CX]);
		5717	ConstToReg(0,ECX,(am32+1)*2);
		5718	op(0xF3); // REPZ
		5719	if(sized==1)stosb();
		5720	else if(sized==2)stosw();
		5721	else stosd();
		5722	}
		5723	}
		5724	nexttok();
		5725	break;
		5726	case tk_structvar:
		5727	struct structteg *tteg2;
		5728	int numel2;
		5729	int usenumstr2;
		5730	unsigned int num2;
		5731	int localstr2;
		5732	int poststr2;
		5733	int flagstr2;
		5734	// adr=itok.number;
		5735
		5736
		5737	numel2=itok.rm; //�᫮ ��
		5738	usenumstr2=itok.post; //�뫮 㪠��
		5739	if(itok.type==tp_classvar){
		5740	tteg2=(structteg *)itok.rec;
		5741	poststr2=0;
		5742	flagstr2=f_useidx;
		5743	}
		5744	else{
		5745	struct idrec *ptrs;
		5746	ptrs=itok.rec;
		5747	tteg2=(structteg *)ptrs->newid;
		5748	if(ptrs->recpost==LOCAL)localstr2=TRUE;
		5749	poststr2=ptrs->recpost;
		5750	flagstr2=ptrs->flag;
		5751	}
		5752	num2=itok.size;
		5753	// ptrs2=itok.rec;
		5754	// tteg2=(structteg *)ptrs2->newid;
		5755	// numel2=itok.rm; //�᫮ ��
		5756	// num2=tteg2->size;
		5757	if(usenumstr2!=FALSE){
		5758	num2=tteg->size;
		5759	if(strinf.bufstr==NULL)starts=num2*numel2;
		5760	}
		5761	// if(itok.post==FALSE)num2*=ptrs2->recrm; //�� 㪠�� - ��
		5762	// else if(strinf.bufstr==NULL)starts=num2*numel2;
		5763	if(strinf.bufstr==NULL)itok.number+=starts;
		5764	itok.sib=(am32==FALSE?CODE16:CODE32);
		5765	if(localstr2){
		5766	itok.rm=rm_mod10;
		5767	if(strinf.bufstr==NULL){
		5768	if(ESPloc&&am32){
		5769	itok.rm\|=rm_sib;
		5770	itok.sib=0x24;
		5771	}
		5772	else{
		5773	itok.rm\|=(am32==FALSE?rm_BP:rm_EBP);
		5774	}
		5775	}
		5776	else{
		5777	CheckAllMassiv(bufrm,2,&strinf);
		5778	if(am32==FALSE)itok.rm\|=rm_BPSI;
		5779	else{
		5780	itok.sib=(ESPloc?0x34:0x35);
		5781	itok.rm=4\|rm_mod10;
		5782	}
		5783	}
		5784	itok.segm=SS;
		5785	if(ESPloc&&am32)itok.number+=addESP;
		5786	// else itok.number-=localsize;
		5787	tok=tk_rmnumber;
		5788	itok.size=tteg2->size;
		5789	itok.post=0;
		5790	compressoffset(&itok);
		5791	}
		5792	else{
		5793	itok.post=poststr2;
		5794	itok.rm=(am32==FALSE?rm_d16:rm_d32); //22.11.04 09:22//��⠭�� 㬮�砭��
		5795	if(strinf.bufstr==NULL){
		5796	if(itok.post==TRUE)tok=tk_postnumber;
		5797	else tok=tk_number;
		5798	}
		5799	else{
		5800	CheckAllMassiv(bufrm,2,&strinf);
		5801	itok.rm=rm_mod10\|(am32==FALSE?rm_SI:6);
		5802	tok=tk_rmnumber;
		5803	itok.size=tteg2->size;
		5804	}
		5805	itok.segm=DS;
		5806	}
		5807	///!new
		5808	itok.flag=flagstr2;
		5809	warningreg(regs[am32][SI]);
		5810	///!new
		5811	// printf("tok=%d rm=%08X %s",tok,itok.rm,itok.name);
		5812	getintoreg_32(SI,(am32+1)*2,0,&ofsst);
		5813	ClearReg(SI);
		5814	num=tteg->size;
		5815	starts=0;
		5816	if(usenumstr==FALSE)num*=tteg->size; //ptrs->recrm; //�� 㪠�� - ��
		5817	else if(rstr.bufstr==NULL)starts=num*numel;
		5818	itok.number=adr;//ptrs->recnumber;
		5819	if(rstr.bufstr==NULL)itok.number+=starts;
		5820	itok.sib=(am32==FALSE?CODE16:CODE32);
		5821	if(localstr){
		5822	// if(ptrs->recpost==LOCAL){
		5823	if(ESPloc&&am32){
		5824	itok.rm=rm_mod10\|rm_sib;
		5825	itok.sib=0x24;
		5826	itok.number+=addESP;
		5827	}
		5828	else{
		5829	itok.rm=rm_mod10\|(am32==FALSE?rm_BP:rm_EBP);
		5830	}
		5831	itok.segm=SS;
		5832	tok=tk_rmnumber;
		5833	itok.size=tteg->size;
		5834	itok.post=0;
		5835	compressoffset(&itok);
		5836	if(rstr.bufstr!=NULL)CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
		5837	}
		5838	else{
		5839	itok.post=poststr;//ptrs->recpost;
		5840	itok.segm=DS;
		5841	itok.rm=(am32==FALSE?rm_d16:rm_d32); //��⠭�� 㬮�砭��
		5842	if(rstr.bufstr==NULL){
		5843	if(itok.post==TRUE)tok=tk_postnumber;
		5844	else tok=tk_number;
		5845	}
		5846	else{
		5847	CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
		5848	tok=tk_rmnumber;
		5849	itok.size=tteg->size;
		5850	}
		5851	}
		5852	///!new
		5853	itok.flag=flagstr;//ptrs->flag;
		5854	warningreg(regs[am32][DI]);
		5855	if(num2>num)warnsize();
		5856	ClearReg(DI);
		5857	///!new
		5858	usenumstr2=DS;
		5859	if(poststr2==LOCAL)usenumstr2=SS;
		5860	getintoreg_32(DI,(am32+1)*2,0,&ofsst);
		5861	num=num2;
		5862	sized=1;
		5863	if(optimizespeed){
		5864	if((num%2)==0)sized=2;
		5865	if(chip>2&&(num%4)==0)sized=4;
		5866	}
		5867	else{
		5868	if(am32==FALSE){
		5869	if((num%2)==0)sized=2;
		5870	}
		5871	else{
		5872	if(chip>2&&(num%4)==0)sized=4;
		5873	}
		5874	}
		5875	num/=sized;
		5876	///!new
		5877	if(num<=2\|\|(num<=4&&(!optimizespeed&&usenumstr2!=SS))){
		5878	for(unsigned int i=0;i
		5879	if(usenumstr2==SS)op(0x36);
		5880	if(sized==1)movsb();
		5881	else if(sized==2)movsw();
		5882	else movsd();
		5883	}
		5884	}
		5885	else{
		5886	///!new
		5887	MovRegNum((am32+1)*2,0,num,ECX);
		5888	warningreg(regs[am32][CX]);
		5889	ConstToReg(0,ECX,(am32+1)*2);
		5890	if(comfile!=file_w32){
		5891	if(poststr)pushss();
		5892	// if(ptrs->recpost==LOCAL)pushss();
		5893	else pushds();
		5894	popes();
		5895	}
		5896	op(0xF3); // REPZ
		5897	if(usenumstr2==SS)op(0x36);
		5898	if(sized==1)movsb();
		5899	else if(sized==2)movsw();
		5900	else movsd();
		5901	}
		5902	break;
		5903	default: errstruct();
		5904	}
		5905	}
		5906	else{
		5907	nexttok();
		5908	errstruct();
		5909	}
		5910	if(ofsst)free(ofsst);
		5911	}
		5912
		5913
		5914	{
		5915	int i=0;
		5916	if((startStartup+size)
		5917	if(alignword){ //��஢��
		5918	if(startStartup%2==1)i=1;
		5919	}
		5920	if((startStartup+size+i)<=endStartup){
		5921	startStartup+=i;
		5922	newrec->recnumber=startStartup; //�� 砫� ��
		5923	newrec->recpost=FALSE;
		5924	startStartup+=size;
		5925	return TRUE;
		5926	}
		5927	}
		5928	return FALSE;
		5929	}
		5930
		5931
		5932	{
		5933	char buf[IDLENGTH];
		5934	strcpy(buf,name);
		5935	strupr(buf);
		5936	return FastSearch((unsigned char *)asmMnem,ofsmnem,0,buf);
		5937	}
		5938
		5939
		5940	{
		5941	int useme;
		5942	int next=1;
		5943	*tok4=tokens;
		5944	itok4->type=tp_ucnovn;
		5945	whitespace(); //�ய�� ᨬ��
		5946	if(isalpha(cha)\|\|(cha=='_')\|\|cha>=0x80){ //��䨪��
		5947	if(mode==1){
		5948	int i=0;
		5949	do{
		5950	itok4->name[i++]=cha;
		5951	nextchar();
		5952	}while(CheckChar2()==TRUE&&i
		5953	if(i==IDLENGTH)i--;
		5954	itok4->name[i]=0;
		5955	}
		5956	while(CheckChar2()==TRUE)nextchar(); //�� ᫮��
		5957	*tok4=tk_id;
		5958	return;
		5959	}
		5960	if(isdigit(cha)){//�᫠
		5961	if(mode==1){
		5962	inptr--;
		5963	itok4->lnumber=scannumber(&itok4->rm);
		5964	}
		5965	else{
		5966	do{
		5967	nextchar();
		5968	}while(isdigit(cha));
		5969	}
		5970	*tok4=tk_number;
		5971	return;
		5972	}
		5973	else switch(cha){
		5974	case '\"':
		5975	nextchar(); //��ப�� ⠭�
		5976	while(cha!='\"'&&!endoffile){
		5977	convert_char();
		5978	nextchar();
		5979	}
		5980	*tok4=tk_string;
		5981	break;
		5982	case '\'': //ᨬ��쭠� ��⠭� �� 1 ᨬ��
		5983	nextchar();
		5984	while(cha!='\''&&!endoffile){ // special character
		5985	convert_char();
		5986	nextchar();
		5987	}
		5988	break;
		5989	case '/': nextchar();
		5990	switch(cha){
		5991	case '*': nextchar(); //ᮬ��਩
		5992	useme=1;
		5993	if(mode==2)itok4->number=inptr-2;
		5994	while(!endoffile&&useme>0){
		5995	whitespace();
		5996	if(cha=='*'){
		5997	nextchar();
		5998	if(cha=='/')useme--;
		5999	else continue;
		6000	}
		6001	else if(cha=='/'){
		6002	nextchar();
		6003	if(cha=='*')useme++;
		6004	else continue;
		6005	}
		6006	nextchar();
		6007	}
		6008	if(mode==2)*tok4=tk_comment2;
		6009	else FastTok(mode,tok4,itok4);
		6010	if(endoffile)*tok4=tk_eof;
		6011	return;
		6012	case '/':
		6013	if(mode==2)itok4->number=inptr-2;
		6014	do{
		6015	nextchar();
		6016	}while(!endoffile&&cha!=13); //��ப� ��
		6017	if(endoffile)*tok4=tk_eof;
		6018	if(mode==2)*tok4=tk_comment1;
		6019	else FastTok(mode,tok4,itok4);
		6020	return;
		6021	}
		6022	break;
		6023	case '#':
		6024	case '?':
		6025	nextchar();
		6026	// tokscan(&tok,&itok,string);
		6027	FastTok(1,tok4,itok4);
		6028	// if((itok.number=GetDirective((char *)string))!=-1){
		6029	if(*tok4==tk_id&&(itok4->number=GetDirective(itok4->name))!=-1){
		6030	*tok4=tk_question;
		6031	}
		6032	return;
		6033	case ';': *tok4=tk_semicolon; break;
		6034	case '[': *tok4=tk_openblock; break;
		6035	case ']': *tok4=tk_closeblock; break;
		6036	case '(': *tok4=tk_openbracket; break;
		6037	case ')': *tok4=tk_closebracket; break;
		6038	case '{': *tok4=tk_openbrace; break;
		6039	case '}': *tok4=tk_closebrace; break;
		6040	case ',': *tok4=tk_camma; break;
		6041	case ':': *tok4=tk_colon; break;
		6042	case 26: *tok4=tk_eof; return;
		6043	case 13: *tok4=tk_endline; break;
		6044	case '\\':
		6045	nextchar();
		6046	if(cha==13){
		6047	FastTok(mode,tok4,itok4);
		6048	if(tok==tk_endline)FastTok(mode,tok4,itok4);
		6049	return;
		6050	}
		6051	break;
		6052	case '!':
		6053	nextchar();
		6054	if(cha=='='){
		6055	*tok4=tk_notequal; //!=
		6056	itok4->type=tp_compare;
		6057	}
		6058	else{
		6059	*tok4=tk_not;
		6060	next=0;
		6061	}
		6062	break;
		6063	case '=':
		6064	nextchar();
		6065	if(cha=='='){
		6066	*tok4=tk_equalto; //==
		6067	itok4->type=tp_compare;
		6068	}
		6069	else{
		6070	*tok4=tk_assign; //��᢮��
		6071	next=0;
		6072	}
		6073	break;
		6074	case '>':
		6075	nextchar();
		6076	switch(cha){
		6077	case '>':
		6078	nextchar();
		6079	if(cha=='=')*tok4=tk_rrequals; //ᤢ�� ࠢ� � ��᢮��
		6080	else{
		6081	*tok4=tk_rr; //ᤢ�� ࠢ�
		6082	next=0;
		6083	itok4->type=tp_opperand;
		6084	}
		6085	break;
		6086	case '<': *tok4=tk_swap; break; //��
		6087	case '=': *tok4=tk_greaterequal; itok4->type=tp_compare; break; //�� ࠢ��
		6088	default: *tok4=tk_greater; next=0; itok4->type=tp_compare; break; //��
		6089	}
		6090	break;
		6091	case '<':
		6092	nextchar();
		6093	switch(cha){
		6094	case '<':
		6095	nextchar();
		6096	if(cha=='=')*tok4=tk_llequals; //ᤢ�� ᢮��
		6097	else{
		6098	*tok4=tk_ll; //ᤢ��
		6099	next=0;
		6100	itok4->type=tp_opperand;
		6101	}
		6102	break;
		6103	case '>': *tok4=tk_notequal; itok4->type=tp_compare; break; //!=
		6104	case '=': *tok4=tk_lessequal; itok4->type=tp_compare; break; //�� ࠢ��
		6105	default: *tok4=tk_less; next=0; itok4->type=tp_compare; break;//��
		6106	}
		6107	break;
		6108	}
		6109	if(next)nextchar();
		6110	}
		6111
		6112
		6113	//�᪮७�� ४⨢�
		6114	{
		6115	inptr=inptr2;
		6116	cha=cha2;
		6117	linenumber=linenum2;
		6118	do{
		6119	FastTok(0);
		6120	}while(tok!=tk_question&&tok!=tk_eof);
		6121	inptr2=inptr;
		6122	cha2=cha;
		6123	linenum2=linenumber;
		6124	}
		6125
		6126
		6127	{
		6128	int useme=0,binnum=0;
		6129	unsigned char c;
		6130	unsigned long long number=0;
		6131	*rm=tokens;
		6132	for(int i=inptr;;i++){
		6133	c=input[i];
		6134	unsigned char cc=c&(unsigned char)0x5f;
		6135	if(cc>='A'&&cc<='F'){
		6136	if(cc=='B'&&binnum==1)binnum++;
		6137	else binnum=3;
		6138	useme=3;
		6139	}
		6140	else if(c<'0'\|\|c>'9'){
		6141	if(useme==0&&c=='.'&&input[i+1]!='.'){ //float
		6142	binnum=3;
		6143	useme++;
		6144	*rm=tk_double;
		6145	(double )&number=atof((char *)&input[inptr]);
		6146	// printf("float=%f %08X\n",(float )&number,(long )&number);
		6147	inptr=i+1;
		6148	do{
		6149	nextchar();
		6150	}while(isdigit(cha));
		6151	if((cha&0x5f)!='E')break;
		6152	nextchar();
		6153	if(isdigit(cha)\|\|cha=='-'){
		6154	do{
		6155	nextchar();
		6156	}while(isdigit(cha));
		6157	}
		6158	break;
		6159	}
		6160	else if(cc=='H'){ //hex
		6161	useme=2;
		6162	binnum=3;
		6163	break;
		6164	}
		6165	break;
		6166	}
		6167	else if(c<'2'&&(binnum==0\|\|binnum==2))binnum++;
		6168	}
		6169	if(binnum==2)goto cbinnum;
		6170	if(useme!=1){
		6171	nextchar();
		6172	if(useme==2)goto hexnum;
		6173	if(cha=='0'){
		6174	nextchar();
		6175	switch(cha&0x5f){
		6176	case 'X': // hexadecimal number
		6177	nextchar();
		6178	hexnum:
		6179	while(isxdigit(cha)){
		6180	number*=16;
		6181	if(isdigit(cha))number+=cha-'0';
		6182	else number+=(cha&0x5f)-'7';
		6183	nextchar();
		6184	}
		6185	if(useme==2)nextchar();
		6186	useme++;
		6187	break;
		6188	case 'B': // binary number
		6189	cbinnum:
		6190	nextchar();
		6191	while(cha=='0'\|\|cha=='1'){
		6192	number=number*2+(cha-'0');
		6193	nextchar();
		6194	}
		6195	if(binnum==2)nextchar();
		6196	else useme++;
		6197	break;
		6198	case 'O': // octal number
		6199	nextchar();
		6200	while(cha>='0'&&cha<='7'){
		6201	number=number*8+(cha-'0');
		6202	nextchar();
		6203	}
		6204	useme++;
		6205	break;
		6206	}
		6207	}
		6208	if(useme==0\|\|useme==3){ // decimal number
		6209	while(isdigit(cha)){
		6210	number=number*10+(cha-'0');
		6211	nextchar();
		6212	}
		6213	}
		6214	}
		6215	c=(unsigned char)(cha&0x5F);
		6216	if(c=='I'){
		6217	if(input[inptr]=='6'&&input[inptr+1]=='4'){
		6218	inptr+=2;
		6219	nextchar();
		6220	*rm=tk_qword;
		6221	}
		6222	}
		6223	else if(c=='L'\|\|c=='U'\|\|c=='F'\|\|c=='Q'){
		6224	if(c=='L')*rm=tk_dword;
		6225	if(c=='F'){
		6226	*rm=tk_float;
		6227	(float )&number=(double )&number;
		6228	}
		6229	if(c=='Q')*rm=tk_qword;
		6230	nextchar();
		6231	c=(unsigned char)(cha&0x5F);
		6232	if(c=='L'\|\|c=='U'){
		6233	if(c=='L')*rm=tk_dword;
		6234	nextchar();
		6235	}
		6236	}
		6237	if(*rm==tokens){
		6238	if(number<256)*rm=tk_byte;
		6239	else if(number<65536)*rm=tk_word;
		6240	else if(number<0x100000000LL)*rm=tk_dword;
		6241	else *rm=tk_qword;
		6242	}
		6243	return number;
		6244	}
		6245
		6246
		6247	{
		6248	struct structteg *tteg;
		6249	int number,tok,rm;
		6250	tok=*tok4;
		6251	number=itok4->number;
		6252	nextchar();
		6253	//14.09.04 18:52
		6254	do{
		6255	FastTok(1,tok4,itok4);
		6256	strcpy((char *)string4,itok4->name);
		6257	searchtree2(definestart,itok4,tok4,string4);
		6258	}while(*tok4==tk_endline);
		6259	///////////////////
		6260	// printf("tok=%d %s\n",*tok4,itok4->name);
		6261	char *tn;
		6262	if((tn=strchr(itok4->name,'@'))!=NULL)*tn=0;
		6263	if((tteg=FindTeg(FALSE,itok4->name))!=NULL\|\|(tteg=FindTeg(TRUE,itok4->name))!=NULL){
		6264	// printf("tok=%d %s\n",*tok4,itok4->name);
		6265	itok4->number=0;
		6266	dostructvar2(tok4,itok4,tteg,string4);
		6267	rm=RegToRM(number,tok);
		6268	// printf("tok=%d rm=%d %s\n",*tok4,itok4->rm,itok4->name);
		6269	if(*tok4==tk_pointer&&itok4->type==tk_proc){
		6270	itok4->sib=rm\|rm_mod10;
		6271	itok4->flag&=~f_reloc;
		6272	}
		6273	else if(tok4!=tk_proc&&tok4!=tk_declare/&&(itok4->flag&f_static)==0 ��䥪� �� ॣ��/){
		6274	itok4->rm=rm_mod10\|rm;
		6275	itok4->flag&=~f_reloc;
		6276	}
		6277	if(tok4==tk_proc\|\|tok4==tk_declare\|\|*tok4==tk_undefproc){
		6278	structadr.sib=THIS_REG;
		6279	structadr.rm=number;
		6280	}
		6281	else if(tok4==tk_id\|\|tok4==tk_ID\|\|*tok4==tk_structvar){
		6282	*tok4=tk_rmnumber;
		6283	itok4->segm=(splitdata==FALSE)?DS:CS;
		6284	itok4->post=0;
		6285	}
		6286	if(bufrm&&strcmp(bufrm,"&this;")==0){
		6287	free(bufrm);
		6288	bufrm=NULL;
		6289	}
		6290	// printf("tok=%d rm=%d post=%d %s\n",*tok4,itok4->rm,itok4->post,itok4->name);
		6291	// if(strinf.bufstr)puts(strinf.bufstr);
		6292	}
		6293	else if(displaytokerrors){
		6294	unknowntagstruct(itok4->name);
		6295	*tok4=tk_number;
		6296	}
		6297	}
		6298
		6299
		6300	{
		6301	int rm;
		6302	if(displaytokerrors){
		6303	if(am32==FALSE&&tok4==tk_reg32)regBXDISIBPexpected();
		6304	else if(am32&&tok4==tk_reg)reg32expected();
		6305	}
		6306	if(am32==FALSE){
		6307	switch(number){
		6308	case BX:
		6309	rm=rm_BX;
		6310	break;
		6311	case DI:
		6312	rm=rm_DI;
		6313	break;
		6314	case SI:
		6315	rm=rm_SI;
		6316	break;
		6317	case BP:
		6318	rm=rm_BP;
		6319	break;
		6320	default:
		6321	if(displaytokerrors)regBXDISIBPexpected();
		6322	break;
		6323	}
		6324	}
		6325	else rm=number;
		6326	return rm;
		6327	}
		6328
		6329
		6330	{
		6331	char buf[IDLENGTH];
		6332	strcpy(buf,name);
		6333	strlwr(buf);
		6334	return FastSearch((unsigned char *)resMnem,ofsres,3,buf);
		6335	}
		6336
		6337
		6338	{
		6339	ITOK cstok;
		6340	int i;
		6341	unsigned char ocha=cha;
		6342	unsigned int oinptr=inptr;
		6343	int oline=linenumber;
		6344	char odisplay=displaytokerrors;
		6345	displaytokerrors=0;
		6346	tokscan(&i,&cstok,string2);
		6347	displaytokerrors=odisplay;
		6348	switch(i){
		6349	case tk_number:
		6350	cha=ocha;
		6351	inptr=oinptr;
		6352	linenumber=oline;
		6353	case tk_int:
		6354	case tk_char:
		6355	case tk_long:
		6356	case tk_short:
		6357	case tk_byte:
		6358	case tk_word:
		6359	case tk_dword:
		6360	case tk_signed:
		6361	case tk_unsigned:
		6362	return i;
		6363	}
		6364	cha=ocha;
		6365	inptr=oinptr;
		6366	linenumber=oline;
		6367	return 0;
		6368	}
		6369
		6370
		6371	{
		6372	static int use=0;
		6373	int i;
		6374	if(use)return;
		6375	use=1;
		6376	i=GetTokVar2();
		6377	if(*tok4==tk_signed){
		6378	if(i==tk_char\|\|i==tk_int\|\|i==tk_long){
		6379	*tok4=i;
		6380	i=GetTokVar2();
		6381	if(*tok4==tk_long){
		6382	if(i==tk_long)*tok4=tk_qword;
		6383	else if(i!=tk_int&&i!=0&&displaytokerrors)unknowntype();
		6384	}
		6385	if(tok4==tk_int&&am32)tok4=tk_long;
		6386	}
		6387	else if(i==tk_short){
		6388	i=GetTokVar2();
		6389	*tok4=tk_int;
		6390	if(i!=0&&i!=tk_int&&displaytokerrors)unknowntype();
		6391	}
		6392	else if(i==0)*tok4=(am32==0?tk_int:tk_long);
		6393	else if(displaytokerrors)unknowntype();
		6394	}
		6395	else if(*tok4==tk_unsigned){
		6396	switch(i){
		6397	case tk_char:
		6398	*tok4=tk_byte;
		6399	break;
		6400	case tk_int:
		6401	*tok4=(am32==0?tk_word:tk_dword);
		6402	break;
		6403	case tk_long:
		6404	*tok4=tk_dword;
		6405	i=GetTokVar2();
		6406	if(i==tk_long)*tok4=tk_qword;
		6407	else if(i!=tk_int&&i!=0&&displaytokerrors)unknowntype();
		6408	break;
		6409	case tk_short:
		6410	*tok4=tk_word;
		6411	i=GetTokVar2();
		6412	if(i!=0&&i!=tk_int&&displaytokerrors)unknowntype();
		6413	break;
		6414	case 0:
		6415	*tok4=(am32==0?tk_word:tk_dword);
		6416	break;
		6417	default:
		6418	if(displaytokerrors)unknowntype();
		6419	}
		6420	}
		6421	else if(i==tk_int&&(tok4==tk_long\|\|tok4==tk_short))*tok4=i;
		6422	else if(tok4==tk_short)tok4=tk_int;
		6423	else if(tok4==tk_int&&(!(idasm==TRUE&&i==tk_number))&&am32)tok4=tk_long;
		6424	else if(i==tk_long&& tok4==tk_long)tok4=tk_qword;
		6425	use=0;
		6426	}
		6427
		6428
		6429	{
		6430	int otok;
		6431	if(skipfind!=LOCAL)return FALSE;
		6432	switch(tok2){
		6433	case tk_semicolon:
		6434	case tk_assign:
		6435	case tk_openblock:
		6436	case tk_openbracket:
		6437	case tk_camma:
		6438	case tk_openbrace:
		6439	return FALSE;
		6440	}
		6441	otok=tok;
		6442	searchtree2(definestart,&itok,&tok,string);
		6443	if(tok==otok)return FALSE;
		6444	return TRUE;
		6445	}
		6446
		6447
		6448	>

Subversion Repositories Kolibri OS

(root)/programs/develop/cmm/toka.cpp – Rev 7626