source: dev/trunk/ab5.0/abdev/BasicCompiler64/Compile_Func.cpp @ 449

Last change on this file since 449 was 449, checked in by dai_9181, 16 years ago

・デリゲートの共変戻り値、反変引数に対応した。
・core.libで定義されたデリゲートがアプリケーションプロジェクトで利用できないバグを修正。
File size: 18.7 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, "Len" ) == 0 )              return FUNC_LEN;
18    if( lstrcmpi( FuncName, "AddressOf" ) == 0 )        return FUNC_ADDRESSOF;
19    if( lstrcmpi( FuncName, "SizeOf" ) == 0 )           return FUNC_SIZEOF;
20    if( lstrcmpi( FuncName, "VarPtr" ) == 0 )           return FUNC_VARPTR;
21    if( lstrcmpi( FuncName, "ObjPtr" ) == 0 )           return FUNC_OBJPTR;
22    if( lstrcmpi( FuncName, "__delegate_dynamicmethod_call" ) == 0 )    return FUNC_DELEGATE_DYNAMICMETHOD_CALL;
23    if( lstrcmpi( FuncName, "__delegate_staticmethod_call" ) == 0 )     return FUNC_DELEGATE_STATICMETHOD_CALL;
24    if( lstrcmpi( FuncName, "_System_GetNowScopeCatchAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS;
25    if( lstrcmpi( FuncName, "_System_GetNowScopeFinallyAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS;
26    if( lstrcmpi( FuncName, "_System_GetBp" ) == 0 )    return FUNC_SYSTEM_GET_BP;
27    if( lstrcmpi( FuncName, "_System_GetSp" ) == 0 )    return FUNC_SYSTEM_GET_SP;
28    if( lstrcmp( FuncName, "_System_GetComVtbl" ) == 0 )        return FUNC_SYSTEM_GET_COM_VTBL;
29    if( lstrcmp( FuncName, "_System_GetVtblList" ) == 0 )       return FUNC_SYSTEM_GET_VTBL_LIST;
30    if( lstrcmp( FuncName, "_System_GetDefaultConstructor" ) == 0 ) return FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR;
31    if( lstrcmp( FuncName, "_System_GetDestructor" ) == 0 )         return FUNC_SYSTEM_GET_DESTRUCTOR;
32    if( lstrcmpi( FuncName, "GetDouble" ) == 0 )        return FUNC_GETDOUBLE;
33    if( lstrcmpi( FuncName, "GetSingle" ) == 0 )        return FUNC_GETSINGLE;
34    if( lstrcmpi( FuncName, "GetQWord" ) == 0 )         return FUNC_GETQWORD;
35    if( lstrcmpi( FuncName, "GetDWord" ) == 0 )         return FUNC_GETDWORD;
36    if( lstrcmpi( FuncName, "GetWord" ) == 0 )          return FUNC_GETWORD;
37    if( lstrcmpi( FuncName, "GetByte" ) == 0 )          return FUNC_GETBYTE;
38    return 0;
39}
40void Opcode_Func_Len( const char *Parameter ){
41    BOOL bArrayHead;
42
43    const char *tempParm=Parameter;
44    char temporary[VN_SIZE];
45    char temp2[32];
46    Type type;
47    if( !GetVarType(Parameter,type,0) ){
48        sprintf(temporary,"_System_DummyStr2=%s",Parameter);
49        OpcodeCalc(temporary);
50
51        lstrcpy(temp2,"_System_DummyStr2");
52        tempParm=temp2;
53
54        type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
55    }
56
57    if( type.IsStringClass() ){
58        //Stringオブジェクトの場合
59        sprintf(temporary,"%s.Length",tempParm);
60
61        int reg=REG_RAX;
62        NumOpe(&reg,temporary,Type(),Type());
63        return;
64    }
65
66    Subscripts subscripts;
67    RELATIVE_VAR RelativeVar;
68    if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
69
70    if(type.GetBasicType()&FLAG_PTR){
71        type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
72
73        bArrayHead=1;
74    }
75    else bArrayHead=0;
76
77    int typeSize = type.GetSize();
78
79    if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
80
81    //mov rax,TypeSize
82    compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
83
84    return;
85}
86
87void _Opcode_Func_AddressOf( const char *methodInstanceName, const UserProc &userProc )
88{
89    if( userProc.IsVirtual() )
90    {
91        ///////////////////////////////
92        // 仮想関数の場合
93        // thisポインタをrcxにコピー
94        ///////////////////////////////
95
96        const CClass *pobj_c;
97
98        char ObjectName[VN_SIZE];
99        ReferenceKind referenceKind;
100        SplitObjectName(methodInstanceName,ObjectName, referenceKind );
101
102        if(ObjectName[0]){
103            if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
104            else{
105                RELATIVE_VAR RelativeVar;
106                Type type;
107                if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
108                SetVarPtrToReg(REG_RCX,&RelativeVar);
109
110                //参照タイプが整合しているかをチェック
111                if( !( type.IsObject() && referenceKind == RefDot
112                    || type.IsObjectPtr() && referenceKind == RefPointer ) )
113                {
114                    SetError(104,ObjectName,cp);
115                }
116
117                if(type.IsObjectPtr()){
118                    //mov rcx,qword ptr[rcx]
119                    compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
120                }
121            }
122        }
123        else{
124InClassMember:
125            //自身のオブジェクトのThisポインタをrcxにコピー
126            SetThisPtrToReg(REG_RCX);
127
128            pobj_c=compiler.pCompilingClass;
129        }
130
131
132        int vtblIndex;
133        if( pobj_c->IsInterface() )
134        {
135            // インターフェイスメソッド
136
137            int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
138
139            // vtblのポインタを取得
140            //mov r11,qword ptr[rcx+offset_vtbl]
141            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,offset_vtbl,MOD_BASE_DISP8);
142
143            int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
144
145            // インターフェイスの場合は更に__thisを取得する
146            //mov rcx,qword ptr[rcx+offset_this]
147            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,offset_this,MOD_BASE_DISP8);
148
149            int vtblMasterListIndex;
150            pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
151            if( vtblMasterListIndex != 0 )
152            {
153                SetError();
154            }
155        }
156        else if( pobj_c->IsComInterface() )
157        {
158            //仮想関数（オブジェクトメソッド）
159            // pObj -> vtbl1 -> func1
160            //               -> func2
161            //               -> func3
162
163            int vtblMasterListIndex;
164            pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
165
166            // vtblのポインタを取得
167            //mov r11,qword ptr[rcx]
168            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
169        }
170        else
171        {
172            //仮想関数（オブジェクトメソッド）
173            // pObj -> vtbl_master_list -> vtbl1 -> func1
174            //                                   -> func2
175            //                                   -> func3
176            //                          -> vtbl2 -> func1
177            //                                   -> func2
178            //                                   -> func3
179
180            int vtblMasterListIndex;
181            pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
182
183            // vtblマスターリストのポインタを取得
184            //mov r11,qword ptr[rcx+sizeof(com_vtbl)]
185            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,PTR_SIZE,MOD_BASE_DISP8);
186
187            // vtblのポインタを取得
188            //mov r11,dword ptr[r11+vtblMasterListIndex]
189            compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_R11, REG_R11, vtblMasterListIndex, MOD_BASE_DISP32 );
190        }
191
192        //mov rax,qword ptr[r11+func_index]
193        if( vtblIndex * PTR_SIZE <= 0x7F )
194        {
195            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,vtblIndex*PTR_SIZE,MOD_BASE_DISP8);
196        }
197        else
198        {
199            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,vtblIndex*PTR_SIZE,MOD_BASE_DISP32);
200        }
201    }
202    else{
203        //一般の関数
204
205        //mov rax,ProcAddr
206        compiler.codeGenerator.op_addressof( REG_RAX, &userProc );
207    }
208
209    userProc.Using();
210}
211void Opcode_CreateDelegate( const CClass &dgClass, const char *methodInstanceName, const UserProc &userProc )
212{
213    /////////////////////////////////////////////////////////////////
214    // 関数ポインタをpush
215    /////////////////////////////////////////////////////////////////
216
217    //mov rax,AddressOf
218    _Opcode_Func_AddressOf( methodInstanceName, userProc );
219
220
221    if( userProc.GetMethod().IsDynamic() )
222    {
223        //mov rdx,rax
224        compiler.codeGenerator.op_mov_RR( REG_RDX, REG_RAX );
225
226        pobj_BlockReg->lock( REG_RDX );
227
228
229        /////////////////////////////////////////////////////////////////
230        // オブジェクト ポインタをpush
231        /////////////////////////////////////////////////////////////////
232
233        // オブジェクト名を取得
234        char objectName[VN_SIZE];
235        char memberName[VN_SIZE];
236        char *thisPtrName = "This";
237        Type type;
238        if( SplitMemberName( methodInstanceName, objectName, memberName ) )
239        {
240            if( GetVarType( objectName, type, false ) )
241            {
242                thisPtrName = objectName;
243            }
244        }
245
246        // オブジェクト ポインタを取得
247        RELATIVE_VAR relativeVar;
248        GetVarOffsetReadOnly( thisPtrName, &relativeVar, type );
249        if( !type.IsObject() )
250        {
251            extern int cp;
252            SetError(1,NULL,cp);
253            return;
254        }
255
256        SetVarPtrToReg( REG_RAX, &relativeVar );
257
258        //mov rcx,dword ptr[rax]
259        compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RCX, REG_RAX, 0, MOD_BASE );
260
261        pobj_BlockReg->unlock( REG_RDX );
262    }
263    else
264    {
265        //mov rcx,rax
266        compiler.codeGenerator.op_mov_RR( REG_RCX, REG_RAX );
267    }
268
269
270    /////////////////////////////////////////////////////////////////
271    // call _CreateDynamicDelegate/_CreateStaticDelegate
272    /////////////////////////////////////////////////////////////////
273
274    std::vector<const UserProc *> subs;
275    if( userProc.GetMethod().IsDynamic() )
276    {
277        dgClass.GetStaticMethods().Enum( "_CreateDynamicDelegate", subs );
278    }
279    else
280    {
281        dgClass.GetStaticMethods().Enum( "_CreateStaticDelegate", subs );
282    }
283
284    // call _CreateDynamicDelegate
285    compiler.codeGenerator.op_call( subs[0] );
286}
287void Opcode_Func_AddressOf( const char *name, const Type &baseType, bool isCallOn, Type &resultType )
288{
289    extern int cp;
290
291    const Parameters *pBaseParams = NULL;
292    const Type *pBaseReturnType = NULL;
293    if( baseType.IsProcPtr() )
294    {
295        // 左辺で関数ポインタを要求されているとき
296        const ProcPointer *pTempProcPointer = compiler.GetObjectModule().meta.GetProcPointers()[baseType.GetIndex()];
297        pBaseParams = &pTempProcPointer->Params();
298        pBaseReturnType = &pTempProcPointer->ReturnType();
299    }
300    else if( baseType.IsDelegate() )
301    {
302        // 左辺でデリゲートを要求されているとき
303        const Delegate *pTempDelegate = &baseType.GetClass().GetDelegate();
304        pBaseParams = &pTempDelegate->Params();
305        pBaseReturnType = &pTempDelegate->ReturnType();
306    }
307
308    const UserProc *pUserProc;
309    if( pBaseParams && pBaseReturnType )
310    {
311        //左辺の型にのっとり、オーバーロードを解決
312
313        std::vector<const UserProc *> subs;
314        GetOverloadSubHash( name, subs );
315        if( subs.size() == 0 ){
316            SetError(27,name,cp);
317            return;
318        }
319
320        //オーバーロードを解決
321        pUserProc=OverloadSolution( name, subs, *pBaseParams, Type(), Type() );
322
323        if( isCallOn )
324        {
325            // コード生成を伴う場合はエラーチェックを行う
326
327            if( baseType.IsDelegate() )
328            {
329                // デリゲート
330                // 共変戻り値、反変引数をサポート
331                if( !(
332                    pBaseParams->Equals( pUserProc->Params(), true )
333                    && ( pBaseReturnType->Equals( pUserProc->ReturnType() ) || pBaseReturnType->IsCovariant( pUserProc->ReturnType() ) )
334                    ) )
335                {
336                    SetError(67, name, cp );
337                }
338            }
339            else
340            {
341                // 関数ポインタ
342                if( !(
343                    pBaseParams->Equals( pUserProc->Params() )
344                    && pBaseReturnType->Equals( pUserProc->ReturnType() )
345                    ) )
346                {
347                    SetError(66, name, cp );
348                }
349            }
350        }
351
352        if(!pUserProc){
353            SetError(27,name,cp);
354            return;
355        }
356    }
357    else{
358        pUserProc=GetSubHash(name);
359        if(!pUserProc){
360            SetError(27,name,cp);
361            return;
362        }
363    }
364
365    if( baseType.IsDelegate() )
366    {
367        if( isCallOn )
368        {
369            // デリゲートのとき
370            Opcode_CreateDelegate( baseType.GetClass(), name, *pUserProc );
371        }
372        resultType = baseType;
373    }
374    else
375    {
376        if( isCallOn )
377        {
378            // 関数ポインタのとき
379            _Opcode_Func_AddressOf( name, *pUserProc );
380        }
381        resultType.SetBasicType( DEF_PTR_VOID );
382    }
383}
384void Opcode_Func_SizeOf( const string &typeName ){
385    Type tempType;
386    if( !compiler.StringToType( typeName, tempType ) ){
387        SetError(3,typeName,cp);
388        return;
389    }
390
391    int typeSize = ( tempType.IsObject() ) ?
392        tempType.GetClass().GetSize() : tempType.GetSize();
393
394    //mov rax,size
395    compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
396}
397void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
398    if( isCallOn == false ){
399        // 戻り値の型を取得するだけ
400
401        //変数のアドレスを取得
402        if(!GetVarType( Parameter, resultType, true )) return;
403
404        resultType.PtrLevelUp();
405
406        return;
407    }
408
409    RELATIVE_VAR RelativeVar;
410
411    //変数のアドレスを取得
412    if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
413
414    int beforeType = resultType.GetBasicType();
415
416    resultType.PtrLevelUp();
417
418    SetVarPtrToReg(REG_RAX,&RelativeVar);
419
420    // TODO: 取り除く（この動きはObjPtrに託す）
421    /*
422    if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){
423        //参照をオブジェクトポインタに変更
424
425        //mov rax,qword ptr[rax]
426        compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
427
428        SetError(-120,NULL,cp);
429    }*/
430}
431void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){
432    if( isCallOn == false ){
433        // 戻り値の型を取得するだけ
434
435        //変数のアドレスを取得
436        if(!GetVarType( Parameter, resultType, true )) return;
437
438        resultType.PtrLevelUp();
439
440        return;
441    }
442
443    RELATIVE_VAR RelativeVar;
444
445    //変数のアドレスを取得
446    if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
447
448    int beforeType = resultType.GetBasicType();
449
450    resultType.PtrLevelUp();
451
452    SetVarPtrToReg(REG_RAX,&RelativeVar);
453
454    if( lstrcmpi( Parameter, "This" )==0 ){
455        // Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける
456    }
457    else if( beforeType == DEF_OBJECT ){
458        //参照をオブジェクトポインタに変更
459
460        //mov rax,qword ptr[rax]
461        compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
462    }
463    else{
464        SetError(134,NULL,cp );
465    }
466}
467
468void Opcode_Func_delegate_call( const char *paramsStr, Type &resultType, bool isDynamicCall, bool isCallOn )
469{
470    if( isCallOn )
471    {
472        int i = 0;
473        char methodPtrParamStr[VN_SIZE];
474        i = GetOneParameter( paramsStr, i, methodPtrParamStr );
475
476        char objPtrValueStr[VN_SIZE] = "";
477        if( isDynamicCall )
478        {
479            i = GetOneParameter( paramsStr, i, objPtrValueStr );
480        }
481
482        Opcode_CallDelegate( compiler.pCompilingClass->GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
483    }
484
485    resultType = UserProc::CompilingUserProc().ReturnType();
486}
487
488void Opcode_Func_System_Get_Bp()
489{
490    //mov rax,rbp
491    compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RBP);
492}
493void Opcode_Func_System_Get_Sp()
494{
495    //mov rax,rsp
496    compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RSP);
497}
498
499void Opcode_Func_System_GetComVtbl( const char *parameter )
500{
501    Type classType;
502    compiler.StringToType( parameter, classType );
503
504    // mov rax,com_vtbl
505    compiler.codeGenerator.op_mov_RV_com_vtbl( REG_RAX, &classType.GetClass() );
506}
507void Opcode_Func_System_GetVtblList( const char *parameter )
508{
509    Type classType;
510    compiler.StringToType( parameter, classType );
511
512    // mov rax,com_vtbl
513    compiler.codeGenerator.op_mov_RV_vtbl( REG_RAX, &classType.GetClass() );
514}
515void Opcode_Func_System_GetDefaultConstructor( const char *parameter )
516{
517    Type classType;
518    compiler.StringToType( parameter, classType );
519
520    if( classType.GetClass().GetConstructorMethod() )
521    {
522        //mov rax,ProcAddr
523        compiler.codeGenerator.op_addressof( REG_RAX, &classType.GetClass().GetConstructorMethod()->GetUserProc() );
524    }
525    else
526    {
527        // デフォルトコンストラクタを持たない
528
529        //xor rax,rax
530        compiler.codeGenerator.op_zero_reg( REG_RAX );
531    }
532}
533void Opcode_Func_System_GetDestructor( const char *parameter )
534{
535    Type classType;
536    compiler.StringToType( parameter, classType );
537
538    //mov rax,ProcAddr
539    compiler.codeGenerator.op_addressof( REG_RAX, &classType.GetClass().GetDestructorMethod()->GetUserProc() );
540}
541
542void Opcode_Func_GetPtrData( const char *Parameter, const int type ){
543    int reg=REG_RAX;
544    Type tempType;
545    if( !NumOpe(&reg,Parameter,Type(),tempType) ){
546        return;
547    }
548    if(!tempType.IsWhole()){
549        SetError(11,Parameter,cp);
550        return;
551    }
552
553    if(type==DEF_DOUBLE){
554        //movlpd xmm0,qword ptr[rax]
555        compiler.codeGenerator.op_movlpd_RM(REG_XMM0,REG_RAX,0,MOD_BASE);
556    }
557    else if(type==DEF_SINGLE){
558        //movss xmm0,dword ptr[rax]
559        compiler.codeGenerator.op_movss_RM(REG_XMM0,REG_RAX,0,MOD_BASE);
560    }
561    else{
562        //mov rax,ptr[rax]
563        compiler.codeGenerator.op_mov_RM(Type(type).GetSize(),REG_RAX,REG_RAX,0,MOD_BASE);
564    }
565}
566
567bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn )
568{
569    switch(FuncNum){
570        case FUNC_LEN:
571            if( isCallOn ) Opcode_Func_Len(Parameter);
572            resultType.SetBasicType( DEF_LONG );
573            break;
574        case FUNC_ADDRESSOF:
575            Opcode_Func_AddressOf( Parameter, baseType, isCallOn, resultType );
576            break;
577        case FUNC_SIZEOF:
578            if( isCallOn ) Opcode_Func_SizeOf(Parameter);
579            resultType.SetBasicType( DEF_LONG );
580            break;
581        case FUNC_VARPTR:
582            Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
583            break;
584        case FUNC_OBJPTR:
585            Opcode_Func_ObjPtr( Parameter, resultType, isCallOn );
586            break;
587        case FUNC_DELEGATE_DYNAMICMETHOD_CALL:
588            Opcode_Func_delegate_call( Parameter, resultType, true, isCallOn );
589            break;
590        case FUNC_DELEGATE_STATICMETHOD_CALL:
591            Opcode_Func_delegate_call( Parameter, resultType, false, isCallOn );
592            break;
593        case FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS:
594            if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeCatchAddress();
595            resultType.SetBasicType( DEF_PTR_VOID );
596            break;
597        case FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS:
598            if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeFinallyAddress();
599            resultType.SetBasicType( DEF_PTR_VOID );
600            break;
601        case FUNC_SYSTEM_GET_BP:
602            if( isCallOn ) Opcode_Func_System_Get_Bp();
603            resultType.SetBasicType( DEF_INT64 );
604            break;
605        case FUNC_SYSTEM_GET_SP:
606            if( isCallOn ) Opcode_Func_System_Get_Sp();
607            resultType.SetBasicType( DEF_INT64 );
608            break;
609        case FUNC_SYSTEM_GET_COM_VTBL:
610            if( isCallOn ) Opcode_Func_System_GetComVtbl( Parameter );
611            resultType.SetBasicType( DEF_PTR_VOID );
612            break;
613        case FUNC_SYSTEM_GET_VTBL_LIST:
614            if( isCallOn ) Opcode_Func_System_GetVtblList( Parameter );
615            resultType.SetBasicType( DEF_PTR_VOID );
616            break;
617        case FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR:
618            if( isCallOn ) Opcode_Func_System_GetDefaultConstructor( Parameter );
619            resultType.SetBasicType( DEF_PTR_VOID );
620            break;
621        case FUNC_SYSTEM_GET_DESTRUCTOR:
622            if( isCallOn ) Opcode_Func_System_GetDestructor( Parameter );
623            resultType.SetBasicType( DEF_PTR_VOID );
624            break;
625
626        case FUNC_GETDOUBLE:
627            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
628            resultType.SetBasicType( DEF_DOUBLE );
629            break;
630        case FUNC_GETSINGLE:
631            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
632            resultType.SetBasicType( DEF_SINGLE );
633            break;
634        case FUNC_GETQWORD:
635            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
636            resultType.SetBasicType( DEF_QWORD );
637            break;
638        case FUNC_GETDWORD:
639            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
640            resultType.SetBasicType( DEF_DWORD );
641            break;
642        case FUNC_GETWORD:
643            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
644            resultType.SetBasicType( DEF_WORD );
645            break;
646        case FUNC_GETBYTE:
647            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
648            resultType.SetBasicType( DEF_BYTE );
649            break;
650        default:
651            return false;
652    }
653    return true;
654}
Note: See TracBrowser for help on using the repository browser.