source: dev/BasicCompiler32/CParameter.cpp@ 28

Last change on this file since 28 was 28, checked in by dai_9181, 17 years ago

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