source: dev/trunk/ab5.0/abdev/BasicCompiler32/Compile_Func.cpp@ 447

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

_System_Newに対応（32bit版のみ）。
File size: 22.0 KB
Line 
1#include "stdafx.h"
2
3#include <jenga/include/smoothie/Smoothie.h>
4
5#include <Compiler.h>
6
7#include "../BasicCompiler_Common/common.h"
8#include "Opcode.h"
9
10#ifdef _AMD64_
11#include "../BasicCompiler64/FunctionValue.h"
12#else
13#include "../BasicCompiler32/FunctionValue.h"
14#endif
15
16int GetFunctionFromName(char *FuncName){
17 if( lstrcmpi( FuncName, "CUDbl" ) == 0 ) return FUNC_CUDBL;
18 if( lstrcmpi( FuncName, "Fix" ) == 0 ) return FUNC_FIX;
19 if( lstrcmpi( FuncName, "Len" ) == 0 ) return FUNC_LEN;
20 if( lstrcmpi( FuncName, "AddressOf" ) == 0 ) return FUNC_ADDRESSOF;
21 if( lstrcmpi( FuncName, "SizeOf" ) == 0 ) return FUNC_SIZEOF;
22 if( lstrcmpi( FuncName, "VarPtr" ) == 0 ) return FUNC_VARPTR;
23 if( lstrcmpi( FuncName, "ObjPtr" ) == 0 ) return FUNC_OBJPTR;
24 if( lstrcmpi( FuncName, "__delegate_dynamicmethod_call" ) == 0 ) return FUNC_DELEGATE_DYNAMICMETHOD_CALL;
25 if( lstrcmpi( FuncName, "__delegate_staticmethod_call" ) == 0 ) return FUNC_DELEGATE_STATICMETHOD_CALL;
26 if( lstrcmpi( FuncName, "_System_GetNowScopeCatchAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS;
27 if( lstrcmpi( FuncName, "_System_GetNowScopeFinallyAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS;
28 if( lstrcmpi( FuncName, "_System_GetBp" ) == 0 ) return FUNC_SYSTEM_GET_BP;
29 if( lstrcmpi( FuncName, "_System_GetSp" ) == 0 ) return FUNC_SYSTEM_GET_SP;
30 if( lstrcmp( FuncName, "_System_GetComVtbl" ) == 0 ) return FUNC_SYSTEM_GET_COM_VTBL;
31 if( lstrcmp( FuncName, "_System_GetVtblList" ) == 0 ) return FUNC_SYSTEM_GET_VTBL_LIST;
32 if( lstrcmp( FuncName, "_System_GetDefaultConstructor" ) == 0 ) return FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR;
33 if( lstrcmp( FuncName, "_System_GetDestructor" ) == 0 ) return FUNC_SYSTEM_GET_DESTRUCTOR;
34 if( lstrcmpi( FuncName, "GetDouble" ) == 0 ) return FUNC_GETDOUBLE;
35 if( lstrcmpi( FuncName, "GetSingle" ) == 0 ) return FUNC_GETSINGLE;
36 if( lstrcmpi( FuncName, "GetQWord" ) == 0 ) return FUNC_GETQWORD;
37 if( lstrcmpi( FuncName, "GetDWord" ) == 0 ) return FUNC_GETDWORD;
38 if( lstrcmpi( FuncName, "GetWord" ) == 0 ) return FUNC_GETWORD;
39 if( lstrcmpi( FuncName, "GetByte" ) == 0 ) return FUNC_GETBYTE;
40 return 0;
41}
42
43void Opcode_Func_Fix(const char *lpszParms){
44 Type resultType;
45 if( !NumOpe( lpszParms, Type(), resultType ) ){
46 return;
47 }
48
49 if( resultType.IsDouble() ){
50 //fld qword ptr[esp]
51 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
52
53 //fnstcw word ptr[esp]
54 compiler.codeGenerator.PutOld(
55 (char)0xD9,
56 (char)0x3C,
57 (char)0x24
58 );
59
60 //mov ax,word ptr[esp]
61 compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
62
63 //or ah,0Ch
64 compiler.codeGenerator.PutOld(
65 (char)0x80,
66 (char)0xCC,
67 (char)0x0C
68 );
69
70 //mov word ptr[esp-2],ax
71 compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
72
73 //fldcw word ptr[esp-2]
74 compiler.codeGenerator.PutOld(
75 (char)0xD9,
76 (char)0x6C,
77 (char)0x24,
78 (char)0xFE
79 );
80
81 //fistp dword ptr[esp+4]
82 compiler.codeGenerator.PutOld(
83 (char)0xDB,
84 (char)0x5C,
85 (char)0x24,
86 (char)0x04
87 );
88
89 //fldcw word ptr[esp]
90 compiler.codeGenerator.PutOld(
91 (char)0xD9,
92 (char)0x2C,
93 (char)0x24
94 );
95
96 //add esp,4
97 compiler.codeGenerator.op_add_esp(4);
98 }
99 else if( resultType.IsSingle() ){
100 //fld dword ptr[esp]
101 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
102
103 //sub esp,4
104 compiler.codeGenerator.op_sub_esp(4);
105
106 //fnstcw word ptr[esp]
107 compiler.codeGenerator.PutOld(
108 (char)0xD9,
109 (char)0x3C,
110 (char)0x24
111 );
112
113 //mov ax,word ptr[esp]
114 compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
115
116 //or ah,0Ch
117 compiler.codeGenerator.PutOld(
118 (char)0x80,
119 (char)0xCC,
120 (char)0x0C
121 );
122
123 //mov word ptr[esp-2],ax
124 compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
125
126 //fldcw word ptr[esp-2]
127 compiler.codeGenerator.PutOld(
128 (char)0xD9,
129 (char)0x6C,
130 (char)0x24,
131 (char)0xFE
132 );
133
134 //fistp dword ptr[esp+4]
135 compiler.codeGenerator.PutOld(
136 (char)0xDB,
137 (char)0x5C,
138 (char)0x24,
139 (char)0x04
140 );
141
142 //fldcw word ptr[esp]
143 compiler.codeGenerator.PutOld(
144 (char)0xD9,
145 (char)0x2C,
146 (char)0x24
147 );
148
149 //add esp,4
150 compiler.codeGenerator.op_add_esp(4);
151 }
152 else if( resultType.Is64() ){
153 //pop eax
154 compiler.codeGenerator.op_pop(REG_EAX);
155
156 //add esp,4
157 compiler.codeGenerator.op_add_esp(4);
158
159 //push eax
160 compiler.codeGenerator.op_push(REG_EAX);
161 }
162
163 //pop eax
164 compiler.codeGenerator.op_pop(REG_EAX);
165}
166
167void Opcode_Func_CUDbl(const char *Parameter){
168 Type resultType;
169 if( !NumOpe(Parameter,Type(),resultType) ){
170 return;
171 }
172 ChangeTypeToLong(resultType.GetBasicType());
173
174 //pop eax
175 compiler.codeGenerator.op_pop(REG_EAX);
176
177 //push 0
178 compiler.codeGenerator.op_push_V( 0 );
179
180 //push eax
181 compiler.codeGenerator.op_push(REG_EAX);
182
183 //fild qword ptr[esp]
184 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
185
186 //add esp,8
187 compiler.codeGenerator.op_add_esp(8);
188}
189void Opcode_Func_Len(const char *Parameter){
190 BOOL bArrayHead;
191
192 const char *tempParm=Parameter;
193 char temporary[VN_SIZE];
194 char temp2[32];
195 Type type;
196 if( !GetVarType(Parameter,type,0) ){
197 sprintf(temporary,"_System_DummyStr2=%s",Parameter);
198 OpcodeCalc(temporary);
199
200 lstrcpy(temp2,"_System_DummyStr2");
201 tempParm=temp2;
202
203 type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
204 }
205
206 if( type.IsStringClass() ){
207 //Stringオブジェクトの場合
208 sprintf(temporary,"%s.Length",tempParm);
209
210 int reg=REG_RAX;
211 NumOpe(temporary,Type(),Type());
212
213 //pop eax
214 compiler.codeGenerator.op_pop(REG_EAX);
215
216 return;
217 }
218
219 Subscripts subscripts;
220 RELATIVE_VAR RelativeVar;
221 if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
222
223 if(type.GetBasicType()&FLAG_PTR){
224 type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
225
226 bArrayHead=1;
227 }
228 else bArrayHead=0;
229
230 int typeSize = type.GetSize();
231
232 if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
233
234 //mov eax,typeSize
235 compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
236}
237
238void _Opcode_Func_AddressOf( const char *methodInstanceName, const UserProc &userProc )
239{
240 if( userProc.IsVirtual() ){
241 ///////////////////////////////
242 // 仮想関数の場合
243 // thisポインタをrcxにコピー
244 ///////////////////////////////
245
246 const CClass *pobj_c;
247
248 char ObjectName[VN_SIZE];
249 ReferenceKind referenceKind;
250 SplitObjectName( methodInstanceName, ObjectName, referenceKind );
251
252 if(ObjectName[0]){
253 if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
254 else{
255 RELATIVE_VAR RelativeVar;
256 Type type;
257 if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
258 SetVarPtrToEax(&RelativeVar);
259
260 //mov ecx,eax
261 compiler.codeGenerator.op_mov_RR(REG_ECX,REG_EAX);
262
263 //参照タイプが整合しているかをチェック
264 if( !( type.IsObject() && referenceKind == RefDot
265 || type.IsObjectPtr() && referenceKind == RefPointer ) )
266 {
267 SetError(104,ObjectName,cp);
268 }
269
270 if(type.IsObjectPtr()){
271 //mov ecx,dword ptr[ecx]
272 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE);
273 }
274 }
275 }
276 else{
277InClassMember:
278 //自身のオブジェクトのThisポインタをrcxにコピー
279 SetThisPtrToReg(REG_RCX);
280
281 pobj_c=compiler.pCompilingClass;
282 }
283
284
285 int vtblIndex;
286 if( pobj_c->IsInterface() )
287 {
288 // インターフェイスメソッド呼び出し
289
290 int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
291
292
293 // vtblのポインタを取得
294 //mov edx,dword ptr[ecx+offset_vtbl]
295 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, offset_vtbl, MOD_BASE_DISP8 );
296
297 int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
298
299
300
301 // インターフェイスの場合は更に__thisを取得する
302 //mov rcx,qword ptr[rcx+offset_this]
303 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, offset_this, MOD_BASE_DISP8 );
304
305 int vtblMasterListIndex;
306 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
307 if( vtblMasterListIndex != 0 )
308 {
309 SetError();
310 }
311 }
312 else if( pobj_c->IsComInterface() )
313 {
314 // COMインターフェイス メソッド呼び出し
315
316 //仮想関数（オブジェクトメソッド）呼び出し
317 // pObj -> vtbl1 -> func1
318 // -> func2
319 // -> func3
320
321 int vtblMasterListIndex;
322 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
323
324 // vtblのポインタを取得
325 //mov edx,dword ptr[ecx]
326 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
327 }
328 else
329 {
330 //仮想関数（オブジェクトメソッド）呼び出し
331 // pObj -> vtbl_master_list -> vtbl1 -> func1
332 // -> func2
333 // -> func3
334 // -> vtbl2 -> func1
335 // -> func2
336 // -> func3
337
338 int vtblMasterListIndex;
339 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
340
341 // vtblマスターリストのポインタを取得
342 //mov edx,dword ptr[ecx+sizeof(com_vtbl)]
343 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, PTR_SIZE, MOD_BASE_DISP8 );
344
345 // vtblのポインタを取得
346 //mov edx,dword ptr[edx+vtblMasterListIndex]
347 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex*PTR_SIZE, MOD_BASE_DISP32 );
348 }
349
350 //mov eax,dword ptr[edx+func_index]
351 if( vtblIndex * PTR_SIZE <= 0x7F )
352 {
353 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP8);
354 }
355 else{
356 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP32);
357 }
358 }
359 else{
360 //一般の関数
361
362 //mov eax,ProcAddr
363 compiler.codeGenerator.op_addressof( REG_EAX, &userProc );
364 }
365
366 userProc.Using();
367}
368void Opcode_CreateDelegate( const CClass &dgClass, const char *methodInstanceName, const UserProc &userProc )
369{
370 /////////////////////////////////////////////////////////////////
371 // 関数ポインタをpush
372 /////////////////////////////////////////////////////////////////
373
374 //push AddressOf(userProc)
375 _Opcode_Func_AddressOf( methodInstanceName, userProc );
376 compiler.codeGenerator.op_push( REG_EAX );
377
378
379 if( userProc.GetMethod().IsDynamic() )
380 {
381 /////////////////////////////////////////////////////////////////
382 // オブジェクト ポインタをpush
383 /////////////////////////////////////////////////////////////////
384
385 // オブジェクト名を取得
386 char objectName[VN_SIZE];
387 char memberName[VN_SIZE];
388 char *thisPtrName = "This";
389 Type type;
390 if( SplitMemberName( methodInstanceName, objectName, memberName ) )
391 {
392 if( GetVarType( objectName, type, false ) )
393 {
394 thisPtrName = objectName;
395 }
396 }
397
398 // オブジェクト ポインタを取得
399 RELATIVE_VAR relativeVar;
400 GetVarOffsetReadOnly( thisPtrName, &relativeVar, type );
401 if( !type.IsObject() )
402 {
403 extern int cp;
404 SetError(1,NULL,cp);
405 return;
406 }
407
408 SetVarPtrToEax( &relativeVar );
409
410 //mov eax,dword ptr[eax]
411 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
412
413 //push eax
414 compiler.codeGenerator.op_push( REG_EAX );
415 }
416
417
418 /////////////////////////////////////////////////////////////////
419 // call _CreateDynamicDelegate/_CreateStaticDelegate
420 /////////////////////////////////////////////////////////////////
421
422 std::vector<const UserProc *> subs;
423 if( userProc.GetMethod().IsDynamic() )
424 {
425 dgClass.GetStaticMethods().Enum( "_CreateDynamicDelegate", subs );
426 }
427 else
428 {
429 dgClass.GetStaticMethods().Enum( "_CreateStaticDelegate", subs );
430 }
431
432 // call _CreateDynamicDelegate
433 compiler.codeGenerator.op_call( subs[0] );
434}
435void Opcode_Func_AddressOf( const char *name, const Type &baseType, bool isCallOn, Type &resultType )
436{
437 extern int cp;
438 const UserProc *pUserProc;
439
440 const Parameters *pBaseParams = NULL;
441 if( baseType.IsProcPtr() )
442 {
443 // 左辺で関数ポインタを要求されているとき
444 pBaseParams = &compiler.GetObjectModule().meta.GetProcPointers()[baseType.GetIndex()]->Params();
445 }
446 else if( baseType.IsDelegate() )
447 {
448 // 左辺でデリゲートを要求されているとき
449 pBaseParams = &baseType.GetClass().GetDelegate().Params();
450 }
451
452 if( pBaseParams )
453 {
454 //左辺の型にのっとり、オーバーロードを解決
455
456 std::vector<const UserProc *> subs;
457 GetOverloadSubHash( name, subs );
458 if( subs.size() == 0 ){
459 SetError(27,name,cp);
460 return;
461 }
462
463 //オーバーロードを解決
464 pUserProc=OverloadSolution( name, subs, *pBaseParams, Type(), Type() );
465
466 if( isCallOn && baseType.IsDelegate() )
467 {
468 // コード生成を伴う場合はエラーチェックを行う
469 if( !pUserProc->Params().Equals( *pBaseParams )
470 || !pUserProc->ReturnType().Equals( baseType.GetClass().GetDelegate().ReturnType() ) )
471 {
472 if( baseType.IsDelegate() )
473 {
474 SetError(67, name, cp );
475 }
476 else
477 {
478 SetError(66, name, cp );
479 }
480 }
481 }
482
483 if(!pUserProc){
484 SetError(27,name,cp);
485 return;
486 }
487 }
488 else{
489 pUserProc=GetSubHash(name);
490 if(!pUserProc){
491 SetError(27,name,cp);
492 return;
493 }
494 }
495
496 if( baseType.IsDelegate() )
497 {
498 if( isCallOn )
499 {
500 // デリゲートのとき
501 Opcode_CreateDelegate( baseType.GetClass(), name, *pUserProc );
502 }
503 resultType = baseType;
504 }
505 else
506 {
507 if( isCallOn )
508 {
509 // 関数ポインタのとき
510 _Opcode_Func_AddressOf( name, *pUserProc );
511 }
512 resultType.SetBasicType( DEF_PTR_VOID );
513 }
514}
515void Opcode_Func_SizeOf( const string &typeName ){
516 Type tempType;
517 if( !compiler.StringToType( typeName, tempType ) ){
518 SetError(3,typeName,cp);
519 return;
520 }
521
522 int typeSize = ( tempType.IsObject() ) ?
523 tempType.GetClass().GetSize() : tempType.GetSize();
524
525 //mov eax,size
526 compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
527}
528void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
529 if( isCallOn == false ){
530 // 戻り値の型を取得するだけ
531
532 //変数のアドレスを取得
533 if(!GetVarType( Parameter, resultType, true )) return;
534
535 resultType.PtrLevelUp();
536
537 return;
538 }
539
540 RELATIVE_VAR RelativeVar;
541
542 //変数のアドレスを取得
543 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
544
545 int beforeType = resultType.GetBasicType();
546
547 resultType.PtrLevelUp();
548
549 SetVarPtrToEax(&RelativeVar);
550}
551void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){
552 if( isCallOn == false ){
553 // 戻り値の型を取得するだけ
554
555 //変数のアドレスを取得
556 if(!GetVarType( Parameter, resultType, true )) return;
557
558 resultType.PtrLevelUp();
559
560 return;
561 }
562
563 RELATIVE_VAR RelativeVar;
564
565 //変数のアドレスを取得
566 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
567
568 int beforeType = resultType.GetBasicType();
569
570 resultType.PtrLevelUp();
571
572 SetVarPtrToEax(&RelativeVar);
573
574 if( lstrcmpi( Parameter, "This" )==0 ){
575 // Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける
576 }
577 else if( beforeType == DEF_OBJECT ){
578 //参照をオブジェクトポインタに変更
579
580 //mov eax,dword ptr[eax]
581 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
582 }
583 else{
584 SetError(134,NULL,cp );
585 }
586}
587
588void Opcode_Func_delegate_call( const char *paramsStr, Type &resultType, bool isDynamicCall, bool isCallOn )
589{
590 if( isCallOn )
591 {
592 int i = 0;
593 char methodPtrParamStr[VN_SIZE];
594 i = GetOneParameter( paramsStr, i, methodPtrParamStr );
595
596 char objPtrValueStr[VN_SIZE]="";
597 if( isDynamicCall )
598 {
599 i = GetOneParameter( paramsStr, i, objPtrValueStr );
600 }
601
602 Opcode_CallDelegate( compiler.pCompilingClass->GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
603 }
604
605 resultType = UserProc::CompilingUserProc().ReturnType();
606}
607void Opcode_Func_System_Get_Bp()
608{
609 //mov eax,ebp
610 compiler.codeGenerator.op_mov_RR(REG_EAX,REG_EBP);
611}
612void Opcode_Func_System_Get_Sp()
613{
614 //mov eax,esp
615 compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESP);
616}
617
618void Opcode_Func_System_GetComVtbl( const char *parameter )
619{
620 Type classType;
621 compiler.StringToType( parameter, classType );
622
623 // mov eax,com_vtbl
624 compiler.codeGenerator.op_mov_RV_com_vtbl( REG_EAX, &classType.GetClass() );
625}
626void Opcode_Func_System_GetVtblList( const char *parameter )
627{
628 Type classType;
629 compiler.StringToType( parameter, classType );
630
631 // mov eax,com_vtbl
632 compiler.codeGenerator.op_mov_RV_vtbl( REG_EAX, &classType.GetClass() );
633}
634void Opcode_Func_System_GetDefaultConstructor( const char *parameter )
635{
636 Type classType;
637 compiler.StringToType( parameter, classType );
638
639 if( classType.GetClass().GetConstructorMethod() )
640 {
641 //mov eax,ProcAddr
642 compiler.codeGenerator.op_addressof( REG_EAX, &classType.GetClass().GetConstructorMethod()->GetUserProc() );
643 }
644 else
645 {
646 // デフォルトコンストラクタを持たない
647
648 //xor eax,eax
649 compiler.codeGenerator.op_zero_reg( REG_EAX );
650 }
651}
652void Opcode_Func_System_GetDestructor( const char *parameter )
653{
654 Type classType;
655 compiler.StringToType( parameter, classType );
656
657 //mov eax,ProcAddr
658 compiler.codeGenerator.op_addressof( REG_EAX, &classType.GetClass().GetDestructorMethod()->GetUserProc() );
659}
660
661void Opcode_Func_GetPtrData(const char *Parameter,const int type){
662 Type tempType;
663 if( !NumOpe(Parameter,Type(),tempType) ){
664 return;
665 }
666 if(!tempType.IsWhole()){
667 SetError(11,Parameter,cp);
668 return;
669 }
670 ChangeTypeToLong(tempType.GetBasicType());
671
672 if(type==DEF_DOUBLE){
673 //pop eax
674 compiler.codeGenerator.op_pop(REG_EAX);
675
676 //fld qword ptr[eax]
677 compiler.codeGenerator.PutOld(
678 (char)0xDD,
679 (char)0x00
680 );
681 }
682 else if(type==DEF_SINGLE||type==DEF_DWORD){
683 //pop eax
684 compiler.codeGenerator.op_pop(REG_EAX);
685
686 //mov eax,dword ptr[eax]
687 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
688 }
689 else if(type==DEF_QWORD){
690 //pop ecx
691 compiler.codeGenerator.op_pop(REG_ECX);
692
693 //mov eax,dword ptr[ecx]
694 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE);
695
696 //mov edx,dword ptr[ecx+sizeof(long)]
697 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8);
698 }
699 else if(type==DEF_WORD){
700 //pop ebx
701 compiler.codeGenerator.op_pop(REG_EBX);
702
703 //xor eax,eax
704 compiler.codeGenerator.op_xor_RR(REG_EAX);
705
706 //mov ax,word ptr[ebx]
707 compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_EBX, 0, MOD_BASE );
708 }
709 else if(type==DEF_BYTE){
710 //pop ebx
711 compiler.codeGenerator.op_pop(REG_EBX);
712
713 //xor eax,eax
714 compiler.codeGenerator.op_xor_RR(REG_EAX);
715
716 //mov al,byte ptr[ebx]
717 compiler.codeGenerator.op_mov_RM( sizeof(char), REG_EAX, REG_EBX, 0, MOD_BASE );
718 }
719}
720
721bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn )
722{
723 switch(FuncNum){
724 case FUNC_FIX:
725 if( isCallOn ) Opcode_Func_Fix(Parameter);
726 resultType.SetBasicType( DEF_LONG );
727 break;
728 case FUNC_CUDBL:
729 if( isCallOn ) Opcode_Func_CUDbl(Parameter);
730 resultType.SetBasicType( DEF_DOUBLE );
731 break;
732 case FUNC_LEN:
733 if( isCallOn ) Opcode_Func_Len(Parameter);
734 resultType.SetBasicType( DEF_LONG );
735 break;
736 case FUNC_ADDRESSOF:
737 Opcode_Func_AddressOf( Parameter, baseType, isCallOn, resultType );
738 break;
739 case FUNC_SIZEOF:
740 if( isCallOn ) Opcode_Func_SizeOf(Parameter);
741 resultType.SetBasicType( DEF_LONG );
742 break;
743 case FUNC_VARPTR:
744 Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
745 break;
746 case FUNC_OBJPTR:
747 Opcode_Func_ObjPtr( Parameter, resultType, isCallOn );
748 break;
749 case FUNC_DELEGATE_DYNAMICMETHOD_CALL:
750 Opcode_Func_delegate_call( Parameter, resultType, true, isCallOn );
751 break;
752 case FUNC_DELEGATE_STATICMETHOD_CALL:
753 Opcode_Func_delegate_call( Parameter, resultType, false, isCallOn );
754 break;
755 case FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS:
756 if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeCatchAddress();
757 resultType.SetBasicType( DEF_PTR_VOID );
758 break;
759 case FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS:
760 if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeFinallyAddress();
761 resultType.SetBasicType( DEF_PTR_VOID );
762 break;
763 case FUNC_SYSTEM_GET_BP:
764 if( isCallOn ) Opcode_Func_System_Get_Bp();
765 resultType.SetBasicType( DEF_LONG );
766 break;
767 case FUNC_SYSTEM_GET_SP:
768 if( isCallOn ) Opcode_Func_System_Get_Sp();
769 resultType.SetBasicType( DEF_LONG );
770 break;
771 case FUNC_SYSTEM_GET_COM_VTBL:
772 if( isCallOn ) Opcode_Func_System_GetComVtbl( Parameter );
773 resultType.SetBasicType( DEF_PTR_VOID );
774 break;
775 case FUNC_SYSTEM_GET_VTBL_LIST:
776 if( isCallOn ) Opcode_Func_System_GetVtblList( Parameter );
777 resultType.SetBasicType( DEF_PTR_VOID );
778 break;
779 case FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR:
780 if( isCallOn ) Opcode_Func_System_GetDefaultConstructor( Parameter );
781 resultType.SetBasicType( DEF_PTR_VOID );
782 break;
783 case FUNC_SYSTEM_GET_DESTRUCTOR:
784 if( isCallOn ) Opcode_Func_System_GetDestructor( Parameter );
785 resultType.SetBasicType( DEF_PTR_VOID );
786 break;
787
788 case FUNC_GETDOUBLE:
789 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
790 resultType.SetBasicType( DEF_DOUBLE );
791 break;
792 case FUNC_GETSINGLE:
793 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
794 resultType.SetBasicType( DEF_SINGLE );
795 break;
796 case FUNC_GETQWORD:
797 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
798 resultType.SetBasicType( DEF_QWORD );
799 break;
800 case FUNC_GETDWORD:
801 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
802 resultType.SetBasicType( DEF_DWORD );
803 break;
804 case FUNC_GETWORD:
805 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
806 resultType.SetBasicType( DEF_WORD );
807 break;
808 case FUNC_GETBYTE:
809 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
810 resultType.SetBasicType( DEF_BYTE );
811 break;
812 default:
813 return false;
814 }
815 return true;
816}
Note: See TracBrowser for help on using the repository browser.