source: dev/BasicCompiler32/CParameter.cpp@ 20

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

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