source: dev/BasicCompiler32/CParameter.cpp@ 49

Last change on this file since 49 was 47, checked in by dai_9181, 18 years ago

列挙子の比較演算が正常に行えないバグを修正。
クラス名と同名のグローバル関数を定義できないバグを修正
File size: 16.6 KB
Line 
1#include "../BasicCompiler_Common/common.h"
2#include "opcode.h"
3
4CParameter::CParameter(char *buffer){
5 ///////////////////////////
6 // パラメータ文字列を整理
7 ///////////////////////////
8
9 extern HANDLE hHeap;
10 int i,i2,i3;
11 char temporary[VN_SIZE];
12
13 i=0;
14 ParmsNum=0;
15 while(1){
16 if(buffer[i]=='\0') break;
17
18 for(i2=0;;i2++,i++){
19 if(buffer[i]=='\"'){
20 temporary[i2]=buffer[i];
21 for(i++,i2++;;i++,i2++){
22 temporary[i2]=buffer[i];
23 if(buffer[i]=='\"') break;
24 }
25 continue;
26 }
27
28 if(buffer[i]=='('){
29 i3=GetStringInPare(temporary+i2,buffer+i);
30 i2+=i3-1;
31 i+=i3-1;
32 continue;
33 }
34 if(buffer[i]=='['){
35 i3=GetStringInBracket(temporary+i2,buffer+i);
36 i2+=i3-1;
37 i+=i3-1;
38 continue;
39 }
40
41 if(buffer[i]==','||buffer[i]=='\0'){
42 temporary[i2]=0;
43 break;
44 }
45 temporary[i2]=buffer[i];
46 }
47
48 Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
49 lstrcpy(Parms[ParmsNum],temporary);
50 ParmsNum++;
51
52 if(buffer[i]==',') i++;
53 }
54
55 ReturnTypeInfo.type=0;
56 ReturnTypeInfo.u.lpIndex=0;
57}
58CParameter::CParameter(PARAMETER_INFO *pParamInfo,int ParmNum){
59 int i;
60 for(i=0;i<ParmNum;i++){
61 Parms[i]=0;
62 types[i].type=pParamInfo[i].type;
63 types[i].u.lpIndex=pParamInfo[i].u.index;
64 }
65 this->ParmsNum=ParmNum;
66
67 ReturnTypeInfo.type=0;
68 ReturnTypeInfo.u.lpIndex=0;
69}
70CParameter::~CParameter(){
71 int i2;
72
73 //パラメータ文字列を解放
74 for(i2=0;i2<ParmsNum;i2++){
75 if(Parms[i2]==(char *)-1) continue;
76
77 if(Parms[i2]) HeapDefaultFree(Parms[i2]);
78 }
79}
80
81
82void CParameter::SetReturnType(TYPEINFO *pTypeInfo){
83 ReturnTypeInfo=*pTypeInfo;
84}
85
86BOOL CParameter::_overload_check(PARAMETER_INFO *ppi,int pi_num,TYPEINFO *pReturnTypeInfo,int overload_level){
87 //パラメータを識別してオーバーロードを解決
88
89 //パラメータの個数が不一致の場合
90 if(pi_num!=ParmsNum) return 0;
91
92 int i,type;
93 LONG_PTR lpIndex;
94 for(i=0;i<pi_num;i++){
95 if(Parms[i]){
96 TYPEINFO BaseType={ppi[i].type,ppi[i].u.index};
97 type=NumOpe_GetType(Parms[i],&BaseType,&lpIndex);
98 }
99 else{
100 type=types[i].type;
101 lpIndex=types[i].u.lpIndex;
102 }
103
104 if(type!=ppi[i].type){
105 if(overload_level==OVERLOAD_LEVEL1){
106 return 0;
107 }
108 else if(overload_level==OVERLOAD_LEVEL2){
109 if(!(
110 IsWholeNumberType(type)&&IsWholeNumberType(ppi[i].type)||
111 IsRealNumberType(type)&&IsRealNumberType(ppi[i].type)
112 )) return 0;
113 }
114 else if(overload_level==OVERLOAD_LEVEL3){
115 if(type==DEF_OBJECT||ppi[i].type==DEF_OBJECT) return 0;
116 }
117 }
118 else{
119 if(NATURAL_TYPE(type)==DEF_OBJECT){
120 if(lpIndex!=ppi[i].u.index) return 0;
121 }
122 }
123 }
124
125 if(pReturnTypeInfo){
126 //戻り値も比較対象にする
127 if(ReturnTypeInfo.type==pReturnTypeInfo->type){
128 if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT){
129 if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
130 }
131 }
132 else return 0;
133 }
134
135 return 1;
136}
137SUBINFO *CParameter::OverloadSolutionWithReturnType(const char *name,SUBINFO **ppsi,int num){
138 int i,sw=0;
139 SUBINFO *psi;
140 psi=0;
141 for(i=0;i<num;i++){
142 psi=ppsi[i];
143
144 TYPEINFO ReturnTypeInfo;
145 ReturnTypeInfo.type=psi->ReturnType;
146 ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
147
148 //エラーチェック
149 if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL1)){
150 if(sw){
151 SetError(52,name,cp);
152 return 0;
153 }
154 sw=1;
155 break;
156 }
157 }
158
159 if(!sw){
160 for(i=0;i<num;i++){
161 psi=ppsi[i];
162
163 TYPEINFO ReturnTypeInfo;
164 ReturnTypeInfo.type=psi->ReturnType;
165 ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
166
167 //エラーチェック
168 if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL2)){
169 if(sw){
170 SetError(52,name,cp);
171 return 0;
172 }
173 sw=1;
174 break;
175 }
176 }
177 }
178
179 if(!sw){
180 for(i=0;i<num;i++){
181 psi=ppsi[i];
182
183 TYPEINFO ReturnTypeInfo;
184 ReturnTypeInfo.type=psi->ReturnType;
185 ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
186
187 //エラーチェック
188 if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL3)){
189 if(sw){
190 SetError(52,name,cp);
191 return 0;
192 }
193 sw=1;
194 break;
195 }
196 }
197 }
198
199 if(!sw){
200 SetError(52,name,cp);
201 return 0;
202 }
203
204 return psi;
205}
206
207SUBINFO *CParameter::OverloadSolution(const char *name,SUBINFO **ppsi,int num){
208 int i,sw=0;
209 SUBINFO *psi;
210 psi=0;
211
212 for(i=0;i<num;i++){
213 psi=ppsi[i];
214
215 //エラーチェック
216 if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL1)){
217 if(sw){
218 return OverloadSolutionWithReturnType(name,ppsi,num);
219 }
220 sw=1;
221 break;
222 }
223 }
224
225 if(!sw){
226 for(i=0;i<num;i++){
227 psi=ppsi[i];
228
229 //エラーチェック
230 if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL2)){
231 if(sw){
232 return OverloadSolutionWithReturnType(name,ppsi,num);
233 }
234 sw=1;
235 break;
236 }
237 }
238 }
239
240 if(!sw){
241 for(i=0;i<num;i++){
242 psi=ppsi[i];
243
244 //エラーチェック
245 if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL3)){
246 if(sw){
247 return OverloadSolutionWithReturnType(name,ppsi,num);
248 }
249 sw=1;
250 break;
251 }
252 }
253 }
254
255 if(!sw){
256 SUBINFO *temp_psi;
257 for(i=0;i<num;i++){
258 temp_psi=ppsi[i];
259
260 //エラーチェック
261 if(temp_psi->ParmNum==this->ParmsNum){
262 if(sw){
263 sw=0;
264 break;
265 }
266 sw=1;
267
268 psi=temp_psi;
269 }
270 }
271 }
272
273 if(!sw){
274 SetError(52,name,cp);
275 return 0;
276 }
277
278 return psi;
279}
280
281BOOL CParameter::ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
282 if(ParmsNum>pi_num){
283 if(ppi[pi_num-1].type!=DEF_ELLIPSE){
284 //パラメータが多すぎるとき
285 SetError(10,FuncName,cp);
286 return 0;
287 }
288 }
289 else if(ParmsNum<pi_num){
290 if(ParmsNum<SecondParmNum){
291 if(ppi[ParmsNum].type==DEF_ELLIPSE){
292 return 1;
293 }
294
295 //パラメータが少なすぎるとき
296 SetError(10,FuncName,cp);
297 return 0;
298 }
299
300 //省略パラメータに "0" を指定する
301 for(;ParmsNum < pi_num;ParmsNum++){
302 extern HANDLE hHeap;
303 char temporary[64];
304 if(ppi[ParmsNum].bByVal) lstrcpy(temporary,"0");
305 else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
306 Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
307 lstrcpy(Parms[ParmsNum],temporary);
308 }
309 }
310
311 return 1;
312}
313void CParameter::MacroParameterSupport(PARAMETER_INFO *ppi){
314 int i;
315 for(i=0;i<ParmsNum;i++){
316 if(Parms[i][0]=='\0'){
317 extern HANDLE hHeap;
318 char temporary[64];
319 if(ppi[i].bByVal) lstrcpy(temporary,"0");
320 else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
321 HeapDefaultFree(Parms[i]);
322 Parms[i]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
323 lstrcpy(Parms[i],temporary);
324 }
325 }
326}
327
328void CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
329 ///////////////////////////////////////////////////////
330 // 一時オブジェクトをあらかじめスタックに積んでおく
331 ///////////////////////////////////////////////////////
332 //TODO: 64ビットコードのままなので、32ビット用に書き換える
333
334 useTempObject = false;
335
336 //一時オブジェクトの数
337 nCountOfTempObjects = 0;
338
339 BOOL bEllipse;
340 if(pi_num){
341 if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
342 else bEllipse=0;
343 }
344 else bEllipse=0;
345
346 for(int i2=ParmsNum-1;i2>=0;i2--){
347 useTempParameters[i2] = false;
348
349 if(bEllipse&&i2<=pi_num-2) bEllipse=0;
350
351 if(i2==0&&ppi[i2].name){
352 if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
353 //オブジェクトメンバの第一パラメータのThisポインタ
354 continue;
355 }
356 }
357 if((i2==0||i2==1)&&ppi[i2].name){
358 if(lstrcmp(ppi[i2].name,FuncName)==0){
359 //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
360 continue;
361 }
362 }
363
364 TYPEINFO DummyTypeInfo;
365 BOOL bByVal;
366 if(bEllipse){
367 DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
368 bByVal=1;
369 }
370 else{
371 DummyTypeInfo.type=ppi[i2].type;
372 DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
373 bByVal=ppi[i2].bByVal;
374 }
375
376
377 if( !bByVal ){
378 //ポインタ参照
379 if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
380 //ポインタ指定
381 continue;
382 }
383
384 LONG_PTR lpVarIndex;
385 if( GetVarType( Parms[i2], &lpVarIndex, FALSE ) == -1 ){
386 //変数ではないとき
387 int reg = REG_RAX;
388 int type = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
389 //↑ここでスタックに積む
390
391 bool result = CheckDifferentType(
392 DummyTypeInfo.type,
393 DummyTypeInfo.u.lpIndex,
394 type,
395 lpVarIndex,
396 FuncName,
397 i2);
398
399 if( result ){
400 useTempParameters[i2] = true;
401 useTempObject = true;
402
403 types[i2].type = type;
404 types[i2].u.lpIndex = lpVarIndex;
405 }
406
407 nCountOfTempObjects++;
408 }
409 }
410 }
411}
412void CParameter::DeleteTempParameters(){
413 ///////////////////////////////////////////////////////
414 // 一時オブジェクトを破棄
415 ///////////////////////////////////////////////////////
416 //TODO: 64ビットコードのままなので、32ビット用に書き換える
417
418 if( !useTempObject ) return;
419
420 for(int i2=ParmsNum-1;i2>=0;i2--){
421 if( useTempParameters[i2] ){
422 //スタックフレームから取得
423 // ※関数呼び出し時も値が普遍のebxを利用する
424 op_pop(REG_EBX);
425
426
427 ///////////////////////////
428 // デストラクタを呼び出す
429 ///////////////////////////
430
431 //push ebx
432 op_push(REG_EBX);
433
434 //call destructor
435 int i5 = types[i2].u.pobj_Class->DestructorMemberSubIndex;
436 if( i5 != -1 ){
437 op_call( types[i2].u.pobj_Class->ppobj_Method[i5]->psi );
438 }
439
440
441 /////////////////////////
442 // メモリを解放する
443 /////////////////////////
444
445 //push ebx
446 op_push(REG_EBX);
447
448 //call free
449 extern SUBINFO *pSub_free;
450 op_call(pSub_free);
451 }
452 }
453}
454
455void CParameter::SetObjectParameter(CClass *pobj_Class,LPSTR Parameter){
456 int object_size;
457 object_size=GetSizeOfClass(pobj_Class);
458
459 //push object_size
460 op_push_value(object_size);
461
462 //call calloc
463 extern SUBINFO *pSub_calloc;
464 op_call(pSub_calloc);
465
466 //push eax
467 op_push(REG_EAX);
468
469
470 TYPEINFO BaseType={DEF_OBJECT,(LONG_PTR)pobj_Class};
471 TYPEINFO CalcType;
472 CalcType.type=NumOpe_GetType(Parameter,&BaseType,&CalcType.u.lpIndex);
473
474 if(pobj_Class->CopyConstructorMemberSubIndex!=-1&&
475 CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
476 ////////////////////////////////////
477 // コピーコンストラクタを呼び出す
478 ////////////////////////////////////
479
480 //push eax
481 op_push(REG_EAX);
482
483 BOOL bUseHeap;
484 CalcType.type=NumOpe(Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
485
486 //pop ecx
487 op_pop(REG_ECX);
488
489 //pop eax
490 op_pop(REG_EAX);
491
492 if(bUseHeap){
493 //※解放用に退避
494 //mov esi,ecx
495 op_mov_RR(REG_ESI,REG_ECX);
496 }
497
498 //push ecx
499 op_push(REG_ECX);
500
501 //push eax
502 op_push(REG_EAX);
503
504 //call constructor
505 op_call(pobj_Class->ppobj_Method[pobj_Class->CopyConstructorMemberSubIndex]->psi);
506
507
508 if(bUseHeap){
509 FreeTempObject(REG_ESI,pobj_Class);
510 }
511 }
512 else{
513 //push eax
514 op_push(REG_EAX);
515
516
517 if(pobj_Class->ConstructorMemberSubIndex!=-1){
518 ////////////////////////////////
519 // コンストラクタを呼び出す
520 ////////////////////////////////
521
522 //push this
523 op_push(REG_EAX);
524
525 //call constructor
526 op_call(pobj_Class->ppobj_Method[pobj_Class->ConstructorMemberSubIndex]->psi);
527 }
528
529
530 TYPEINFO CalcType;
531 BOOL bUseHeap;
532 CalcType.type=NumOpe(Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
533
534
535
536 SetObjectVariable((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,bUseHeap);
537 }
538}
539
540int CParameter::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
541 ///////////////////////////////////////////////////////////
542 // パラメータをレジスタ及びスタックフレームにセット
543 ///////////////////////////////////////////////////////////
544 int i2,i3;
545
546 BOOL bEllipse;
547 if(pi_num){
548 if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
549 else bEllipse=0;
550 }
551 else bEllipse=0;
552
553 BOOL bHas_System_LocalThis=0;
554 if(ParmsNum>=1){
555 if(lstrcmp(ppi[0].name,"_System_LocalThis")==0)
556 bHas_System_LocalThis=1;
557 }
558
559 //戻り値用の変数名を取得
560 const char *lpszVarNameToReturn = (FuncName[0]==1&&FuncName[1]==ESC_OPERATOR)?"_System_ReturnValue":FuncName;
561
562 //パラメータをレジスタとスタックに格納
563 int CalcType;
564 LONG_PTR lpCalcIndex;
565 BOOL bCalcUseHeap;
566 int ParmSize=0;
567 RELATIVE_VAR RelativeVar;
568 int nCountOfNowTempObjects = 0;
569 for(i2=ParmsNum-1;i2>=0;i2--){
570 if(bEllipse&&i2<=pi_num-2) bEllipse=0;
571
572 if(i2==0&&ppi[i2].name){
573 if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
574 //オブジェクトメンバの第一パラメータのThisポインタ
575 continue;
576 }
577 }
578 if((i2==0||i2==1)&&ppi[i2].name){
579 if(lstrcmp(ppi[i2].name,lpszVarNameToReturn)==0){
580 //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
581 continue;
582 }
583 }
584
585 TYPEINFO DummyTypeInfo;
586 BOOL bByVal;
587 if(bEllipse){
588 DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
589 bByVal=1;
590 }
591 else{
592 DummyTypeInfo.type=ppi[i2].type;
593 DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
594 bByVal=ppi[i2].bByVal;
595 }
596
597 if(bByVal==1){
598 //値参照
599
600 if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
601 char temp2[255];
602 sprintf(temp2,"%s関数の第%dパラメータ",FuncName,i2+1);
603 SetError(19,temp2,cp);
604 continue;
605 }
606
607 if(DummyTypeInfo.type==DEF_OBJECT){
608 SetObjectParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
609 goto next;
610 }
611
612
613 extern LONG_PTR ProcPtr_BaseIndex;
614 LONG_PTR back_ProcPtr_BaseIndex;
615 back_ProcPtr_BaseIndex=ProcPtr_BaseIndex;
616 if(DummyTypeInfo.type==DEF_PTR_PROC) ProcPtr_BaseIndex=DummyTypeInfo.u.lpIndex;
617 else ProcPtr_BaseIndex=-1;
618
619 CalcType=NumOpe(Parms[i2],DummyTypeInfo.type,DummyTypeInfo.u.lpIndex,&lpCalcIndex,&bCalcUseHeap);
620
621 ProcPtr_BaseIndex=back_ProcPtr_BaseIndex;
622
623 if(CalcType==-1) break;
624
625 if(CalcType==DEF_OBJECT){
626 //キャスト演算子のオーバーロードに対応する
627 CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
628 }
629
630 if(!bEllipse){
631 //型チェック
632 if(bHas_System_LocalThis) i3=i2-1;
633 else i3=i2;
634 CheckDifferentType(
635 DummyTypeInfo.type,
636 DummyTypeInfo.u.lpIndex,
637 CalcType,
638 lpCalcIndex,
639 FuncName,
640 i3);
641 }
642
643 if(DummyTypeInfo.type==DEF_DOUBLE){
644 ChangeTypeToDouble(CalcType);
645 ParmSize+=sizeof(long)*2;
646 }
647 else if(DummyTypeInfo.type==DEF_SINGLE){
648 ChangeTypeToSingle(CalcType);
649 ParmSize+=sizeof(long);
650 }
651 else if(DummyTypeInfo.type==DEF_INT64||DummyTypeInfo.type==DEF_QWORD){
652 ChangeTypeToInt64(CalcType);
653 ParmSize+=sizeof(long)*2;
654 }
655 else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||
656 (IsPtrType(DummyTypeInfo.type)/*&&DummyTypeInfo.type!=DEF_PTR_VOID&&DummyTypeInfo.type!=DEF_PTR_BYTE*/)){
657 ChangeTypeToLong(CalcType);
658 ParmSize+=sizeof(long);
659 }
660 else if(DummyTypeInfo.type==DEF_INTEGER||DummyTypeInfo.type==DEF_WORD){
661 ChangeTypeToInteger(CalcType);
662 ParmSize+=sizeof(long);
663 }
664 else if(DummyTypeInfo.type==DEF_CHAR||DummyTypeInfo.type==DEF_BYTE||DummyTypeInfo.type==DEF_BOOLEAN){
665 ChangeTypeToByte(CalcType);
666 ParmSize+=sizeof(long);
667 }
668 else{
669 SetError(300,NULL,cp);
670 }
671 }
672 else{
673 //ポインタ参照
674 if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
675 //ポインタ指定
676 i3=NumOpe(Parms[i2]+2,0,0,0);
677
678 ChangeTypeToLong(i3);
679 }
680 else{
681 //変数のアドレスを取得
682 int VarType;
683 LONG_PTR lpVarIndex;
684 if(GetVarOffset(
685 false,
686 false,
687 Parms[i2],
688 &VarType,
689 &RelativeVar,
690 &lpVarIndex)){
691 if(DummyTypeInfo.type!=DEF_ANY){
692 //型チェックを行う
693 if(DummyTypeInfo.type==VarType){
694 if(DummyTypeInfo.type==DEF_OBJECT){
695 if(DummyTypeInfo.u.lpIndex!=lpVarIndex){
696 SetError(11,Parms[i2],cp);
697 }
698 }
699 }
700 else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
701 //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
702 }
703 else{
704 SetError(11,Parms[i2],cp);
705 }
706 }
707
708 //変数アドレスをレジスタにセット
709 SetVarPtrToEax(&RelativeVar);
710
711 //push eax
712 op_push(REG_EAX);
713 }
714 else{
715 //一時オブジェクトをコピー
716
717 //mov eax, dword ptr[esp+offset]
718 op_mov_RM(
719 sizeof(long),
720 REG_EAX,
721 REG_ESP,
722 ( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects - 1 ) ) * PTR_SIZE,
723 MOD_BASE_DISP32 );
724
725 nCountOfNowTempObjects++;
726
727 //push eax
728 op_push(REG_EAX);
729
730 //VarType = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
731 }
732 }
733
734 ParmSize+=PTR_SIZE;
735 }
736
737next:;
738 }
739
740 return ParmSize;
741}
Note: See TracBrowser for help on using the repository browser.