Changeset 349 in dev for trunk


Ignore:
Timestamp:
Oct 13, 2007, 11:45:58 AM (17 years ago)
Author:
dai_9181
Message:

インターフェイス実装中…

Location:
trunk/abdev
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/Compile_CallProc.cpp

    r348 r349  
    330330        //                ->func3
    331331
    332         int vtblMasterListIndex, vtblIndex;
    333         pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
    334 
    335         // vtblマスターリストのポインタを取得
    336         //mov edx,dword ptr[ecx]
    337         compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
    338        
    339         // vtblのポインタを取得
    340         //mov edx,dword ptr[edx+vtblMasterListIndex]
    341         compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex, MOD_BASE_DISP32 );
     332        int vtblIndex;
     333        if( pobj_c->IsInterface() )
     334        {
     335            // インターフェイスメソッド呼び出し
     336
     337            int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
     338
     339
     340            // vtblのポインタを取得
     341            //mov edx,dword ptr[ecx+offset_vtbl]
     342            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, offset_vtbl, MOD_BASE_DISP8 );
     343
     344            int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
     345
     346
     347
     348            // インターフェイスの場合は更に__thisを取得する
     349            //mov rcx,qword ptr[rcx+offset_this]
     350            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, offset_this, MOD_BASE_DISP8 );
     351
     352            int vtblMasterListIndex;
     353            pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
     354            if( vtblMasterListIndex != 0 )
     355            {
     356                SetError();
     357            }
     358        }
     359        else
     360        {
     361            //仮想関数（オブジェクトメソッド）呼び出し
     362            // pObj -> vtbl_master_list -> vtbl1 -> func1
     363            //                                   -> func2
     364            //                                   -> func3
     365            //                          -> vtbl2 -> func1
     366            //                                   -> func2
     367            //                                   -> func3
     368
     369            int vtblMasterListIndex;
     370            pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
     371
     372            // vtblマスターリストのポインタを取得
     373            //mov edx,dword ptr[ecx]
     374            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
     375           
     376            // vtblのポインタを取得
     377            //mov edx,dword ptr[edx+vtblMasterListIndex]
     378            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex, MOD_BASE_DISP32 );
     379        }
    342380
    343381        //call dword ptr[edx+func_index]

  • trunk/abdev/BasicCompiler32/Compile_Func.cpp

    r348 r349  
    269269
    270270
    271         //仮想関数（オブジェクトメソッド）
    272         //pObj->func_table->func1
    273         //                ->func2
    274         //                ->func3
    275 
    276         int vtblMasterListIndex, vtblIndex;
    277         pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
    278 
    279         // vtblマスターリストのポインタを取得
    280         //mov edx,dword ptr[ecx]
    281         compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
    282        
    283         // vtblのポインタを取得
    284         //mov edx,dword ptr[edx+vtblMasterListIndex]
    285         compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex, MOD_BASE_DISP32 );
     271        int vtblIndex;
     272        if( pobj_c->IsInterface() )
     273        {
     274            // インターフェイスメソッド呼び出し
     275
     276            int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
     277
     278
     279            // vtblのポインタを取得
     280            //mov edx,dword ptr[ecx+offset_vtbl]
     281            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, offset_vtbl, MOD_BASE_DISP8 );
     282
     283            int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
     284
     285
     286
     287            // インターフェイスの場合は更に__thisを取得する
     288            //mov rcx,qword ptr[rcx+offset_this]
     289            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, offset_this, MOD_BASE_DISP8 );
     290
     291            int vtblMasterListIndex;
     292            pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
     293            if( vtblMasterListIndex != 0 )
     294            {
     295                SetError();
     296            }
     297        }
     298        else
     299        {
     300            //仮想関数（オブジェクトメソッド）呼び出し
     301            // pObj -> vtbl_master_list -> vtbl1 -> func1
     302            //                                   -> func2
     303            //                                   -> func3
     304            //                          -> vtbl2 -> func1
     305            //                                   -> func2
     306            //                                   -> func3
     307
     308            int vtblMasterListIndex;
     309            pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
     310
     311            // vtblマスターリストのポインタを取得
     312            //mov edx,dword ptr[ecx]
     313            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
     314           
     315            // vtblのポインタを取得
     316            //mov edx,dword ptr[edx+vtblMasterListIndex]
     317            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex, MOD_BASE_DISP32 );
     318        }
    286319
    287320        //mov eax,dword ptr[edx+func_index]

  • trunk/abdev/BasicCompiler32/Compile_Object.cpp

    r346 r349  
    9797    }
    9898}
    99 void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter, const Type &baseType ){
    100     int typeSize = classObj.GetSize();
    101 
    102     if(classObj.IsAbstract()){
     99void Operator_New( const CClass &objClass, const char *objectSizeStr, const char *parameter, const Type &baseType )
     100{
     101    const CClass *pClass = &objClass;
     102    int typeSize = pClass->GetSize();
     103
     104    if( pClass->IsInterface() )
     105    {
     106        pClass = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr();
     107    }
     108
     109    if(pClass->IsAbstract()){
    103110        //抽象クラスだったとき
    104         SetError(125,classObj.GetName(),cp);
     111        SetError(125,pClass->GetName(),cp);
    105112    }
    106113
    … …  
    188195
    189196
    190     const CMethod *method = classObj.GetDestructorMethod();
     197    const CMethod *method = pClass->GetDestructorMethod();
    191198    if( method == NULL ) return;
    192199
    … …  
    207214
    208215    //仮想関数テーブルを初期化
    209     if( classObj.IsExistVirtualFunctions()
    210         && !classObj.IsAbstract() )
     216    if( pClass->IsExistVirtualFunctions()
     217        && !pClass->IsAbstract() )
    211218    {
    212219        // mov ecx,vtblAddress
    213         compiler.codeGenerator.op_mov_RV_vtbl( REG_ECX, &classObj );
     220        compiler.codeGenerator.op_mov_RV_vtbl( REG_ECX, pClass );
    214221
    215222        //mov dword ptr[eax],ecx
    … …  
    217224
    218225        // 仮想関数になるメソッドに使用チェックをつける
    219         BOOST_FOREACH( const CMethod *pMethod, classObj.GetDynamicMethods() )
     226        BOOST_FOREACH( const CMethod *pMethod, pClass->GetDynamicMethods() )
    220227        {
    221228            if( pMethod->IsVirtual() )
    … …  
    224231            }
    225232        }
    226         BOOST_FOREACH( const ::Interface *pInterface, classObj.GetInterfaces() )
     233        BOOST_FOREACH( const ::Interface *pInterface, pClass->GetInterfaces() )
    227234        {
    228235            BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
    … …  
    248255    ////////////////////////////
    249256
    250     _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
     257    _call_constructor(pClass,parameter,typeSize,bSomeObjects);
    251258}
    252259void OpcodeDelete(const char *Parameter, bool isSweeping){

  • trunk/abdev/BasicCompiler64/Compile_CallProc.cpp

    r348 r349  
    356356
    357357    if( pUserProc->IsVirtual() && !isFixedClass ){
    358         //仮想関数（オブジェクトメソッド）呼び出し
    359         //pObj->func_table->func1
    360         //                ->func2
    361         //                ->func3
    362 
    363         int vtblMasterListIndex, vtblIndex;
    364         pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
    365 
    366         // vtblマスターリストのポインタを取得
    367         //mov r11,qword ptr[rcx]
    368         compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
    369 
    370         // vtblのポインタを取得
    371         //mov r11,dword ptr[r11+vtblMasterListIndex]
    372         compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_R11, REG_R11, vtblMasterListIndex*PTR_SIZE, MOD_BASE_DISP32 );
     358        int vtblIndex;
     359        if( pobj_c->IsInterface() )
     360        {
     361            // インターフェイスメソッド呼び出し
     362
     363            int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
     364
     365            // vtblのポインタを取得
     366            //mov r11,qword ptr[rcx+offset_vtbl]
     367            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,offset_vtbl,MOD_BASE_DISP8);
     368
     369            int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
     370
     371            // インターフェイスの場合は更に__thisを取得する
     372            //mov rcx,qword ptr[rcx+offset_this]
     373            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,offset_this,MOD_BASE_DISP8);
     374
     375            int vtblMasterListIndex;
     376            pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
     377            if( vtblMasterListIndex != 0 )
     378            {
     379                SetError();
     380            }
     381        }
     382        else
     383        {
     384            //仮想関数（オブジェクトメソッド）呼び出し
     385            // pObj -> vtbl_master_list -> vtbl1 -> func1
     386            //                                   -> func2
     387            //                                   -> func3
     388            //                          -> vtbl2 -> func1
     389            //                                   -> func2
     390            //                                   -> func3
     391
     392            int vtblMasterListIndex;
     393            pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
     394
     395            // vtblマスターリストのポインタを取得
     396            //mov r11,qword ptr[rcx]
     397            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
     398
     399            // vtblのポインタを取得
     400            //mov r11,dword ptr[r11+vtblMasterListIndex]
     401            compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_R11, REG_R11, vtblMasterListIndex*PTR_SIZE, MOD_BASE_DISP32 );
     402        }
    373403
    374404        //call qword ptr[r11+func_index]

  • trunk/abdev/BasicCompiler64/Compile_Func.cpp

    r348 r349  
    116116
    117117
    118         //仮想関数（オブジェクトメソッド）
    119         //pObj->func_table->func1
    120         //                ->func2
    121         //                ->func3
    122 
    123         int vtblMasterListIndex, vtblIndex;
    124         pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
    125 
    126         // vtblマスターリストのポインタを取得
    127         //mov r11,qword ptr[rcx]
    128         compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
    129 
    130         // vtblのポインタを取得
    131         //mov r11,dword ptr[r11+vtblMasterListIndex]
    132         compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_R11, REG_R11, vtblMasterListIndex, MOD_BASE_DISP32 );
     118        int vtblIndex;
     119        if( pobj_c->IsInterface() )
     120        {
     121            // インターフェイスメソッド
     122
     123            int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
     124
     125            // vtblのポインタを取得
     126            //mov r11,qword ptr[rcx+offset_vtbl]
     127            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,offset_vtbl,MOD_BASE_DISP8);
     128
     129            int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
     130
     131            // インターフェイスの場合は更に__thisを取得する
     132            //mov rcx,qword ptr[rcx+offset_this]
     133            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,offset_this,MOD_BASE_DISP8);
     134
     135            int vtblMasterListIndex;
     136            pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
     137            if( vtblMasterListIndex != 0 )
     138            {
     139                SetError();
     140            }
     141        }
     142        else
     143        {
     144            //仮想関数（オブジェクトメソッド）
     145            // pObj -> vtbl_master_list -> vtbl1 -> func1
     146            //                                   -> func2
     147            //                                   -> func3
     148            //                          -> vtbl2 -> func1
     149            //                                   -> func2
     150            //                                   -> func3
     151
     152            int vtblMasterListIndex;
     153            pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
     154
     155            // vtblマスターリストのポインタを取得
     156            //mov r11,qword ptr[rcx]
     157            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
     158
     159            // vtblのポインタを取得
     160            //mov r11,dword ptr[r11+vtblMasterListIndex]
     161            compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_R11, REG_R11, vtblMasterListIndex, MOD_BASE_DISP32 );
     162        }
    133163
    134164        //mov rax,qword ptr[r11+func_index]

  • trunk/abdev/BasicCompiler64/Compile_Object.cpp

    r346 r349  
    9090    }
    9191}
    92 void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter, const Type &baseType ){
    93     int typeSize = classObj.GetSize();
    94 
    95     if(classObj.IsAbstract()){
     92void Operator_New( const CClass &objClass, const char *objectSizeStr, const char *parameter, const Type &baseType )
     93{
     94    const CClass *pClass = &objClass;
     95    int typeSize = pClass->GetSize();
     96
     97    if( pClass->IsInterface() )
     98    {
     99        pClass = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr();
     100    }
     101
     102    if( pClass->IsAbstract() ){
    96103        //抽象クラスだったとき
    97         SetError(125,classObj.GetName().c_str(),cp);
     104        SetError(125,pClass->GetName().c_str(),cp);
    98105    }
    99106
    … …  
    177184
    178185
    179     const CMethod *method = classObj.GetDestructorMethod();
     186    const CMethod *method = pClass->GetDestructorMethod();
    180187    if( method == NULL ) return;
    181188
    … …  
    201208
    202209    //仮想関数テーブルを初期化
    203     if( classObj.IsExistVirtualFunctions()
    204         && !classObj.IsAbstract() )
     210    if( pClass->IsExistVirtualFunctions()
     211        && !pClass->IsAbstract() )
    205212    {
    206213        // mov rcx,vtblAddress
    207         compiler.codeGenerator.op_mov_RV_vtbl( REG_RCX, &classObj );
     214        compiler.codeGenerator.op_mov_RV_vtbl( REG_RCX, pClass );
    208215
    209216        //mov qword ptr[rax],rcx
    … …  
    212219
    213220        // 仮想関数になるメソッドに使用チェックをつける
    214         BOOST_FOREACH( const CMethod *pMethod, classObj.GetDynamicMethods() )
     221        BOOST_FOREACH( const CMethod *pMethod, pClass->GetDynamicMethods() )
    215222        {
    216223            if( pMethod->IsVirtual() )
    … …  
    219226            }
    220227        }
    221         BOOST_FOREACH( const ::Interface *pInterface, classObj.GetInterfaces() )
     228        BOOST_FOREACH( const ::Interface *pInterface, pClass->GetInterfaces() )
    222229        {
    223230            BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
    … …  
    238245    ////////////////////////////
    239246
    240     _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
     247    _call_constructor(pClass,parameter,typeSize,bSomeObjects);
    241248
    242249

  • trunk/abdev/BasicCompiler_Common/include/Class.h

    r348 r349  
    562562    mutable const CClass *pStringClass;
    563563    mutable const CClass *pObjectClass;
     564    mutable const CClass *pInterfaceInfo;
    564565    const CClass *GetStringClassPtr() const;
    565566    const CClass *GetObjectClassPtr() const;
     567    const CClass *GetInterfaceInfoClassPtr() const;
    566568};

  • trunk/abdev/BasicCompiler_Common/src/Class.cpp

    r348 r349  
    15281528
    15291529            if( pobj_c->GetName() == "Object"
    1530                 || pobj_c->GetFullName() == "ActiveBasic.Core.InterfaceInfo"
    15311530                || dwClassType == ESC_TYPE )
    15321531            {
    … …  
    19881987    return pObjectClass;
    19891988}
     1989const CClass *Classes::GetInterfaceInfoClassPtr() const
     1990{
     1991    if( !pInterfaceInfo ){
     1992        // キャッシュしておく
     1993        pInterfaceInfo = this->Find( "ActiveBasic.Core.InterfaceInfo" );
     1994
     1995        if( !pInterfaceInfo )
     1996        {
     1997            SmoothieException::Throw();
     1998        }
     1999        return pInterfaceInfo;
     2000    }
     2001    return pInterfaceInfo;
     2002}

  • trunk/abdev/res/res.rc

    r130 r349  
    138138        MENUITEM SEPARATOR
    139139        MENUITEM "デバッグ ビルド(&D)\tF7",     IDM_DEBUGCOMPILE
    140         MENUITEM "デバッグ実行(&R)\tF8",        IDM_DEBUG
     140        MENUITEM "デバッグ実行(&R)\tF5",        IDM_DEBUG
    141141        MENUITEM SEPARATOR
    142142        MENUITEM "ブレークポイントの設置/解除(&B)\tF9", IDM_BREAKPOINT
    … …  
    367367    VK_F11,         IDM_STEP_OVER,          VIRTKEY, NOINVERT
    368368    VK_F11,         IDM_STEP_CURSOR,        VIRTKEY, CONTROL, NOINVERT
    369     VK_F5,          IDM_WEB_SEARCH,         VIRTKEY, NOINVERT
     369    VK_F5,          IDM_DEBUG,              VIRTKEY, NOINVERT
    370370    VK_F6,          IDM_RELEASECOMPILE,     VIRTKEY, NOINVERT
    371371    VK_F7,          IDM_DEBUGCOMPILE,       VIRTKEY, NOINVERT
    372     VK_F8,          IDM_DEBUG,              VIRTKEY, NOINVERT
    373372    VK_F9,          IDM_BREAKPOINT,         VIRTKEY, NOINVERT
    374373    "X",            IDM_CUT,                VIRTKEY, CONTROL, NOINVERT
Note: See TracChangeset for help on using the changeset viewer.