Rev 7626 | Details | Compare with Previous | Last modification | View Log | RSS feed
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[16]; |
||
7700 | leency | 666 | int i; |
6446 | GerdtR | 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=8;i!=0;i--){ |
||
7700 | leency | 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=8;i!=0;i--){ |
||
7700 | leency | 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;i |
||
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;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;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;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;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->numel*GetVarSize(*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;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 | |||
7700 | leency | 4097 | { |
6446 | GerdtR | 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;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;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;i |
||
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;i |
||
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=size*8-bitofs%(size*8); //(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;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(;loop |
||
5038 | nexttok(); |
||
5039 | break; |
||
5040 | case tk_extract: //считать фрагмент файла с данными |
||
5041 | nexttok(); |
||
5042 | loop=doextract(); |
||
5043 | for(;loop |
||
5044 | break; |
||
5045 | case tk_openbrace: //массив данных |
||
5046 | nexttok(); |
||
5047 | loop=Fill2Teg(numel,tteg); |
||
5048 | for(;loop |
||
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(;loop |
||
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 | >65536)*rm=tk_word; |