source: dev/BasicCompiler32/CParameter.cpp@ 73

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

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