Changeset 639 in dev for trunk/ab5.0/abdev/ab_common/src


Ignore:
Timestamp:
Jun 12, 2008, 11:30:50 PM (16 years ago)
Author:
dai_9181
Message:

静的リンクリンカの依存関係解決モジュールを製作中

Location:
trunk/ab5.0/abdev/ab_common/src/Lexical
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp

    r637 r639  
    869869}
    870870
    871 bool CClass::Resolve()
    872 {
    873     // TODO: Resolve
     871bool CClass::Resolve( const ObjectModule &resolver )
     872{
     873    // 型パラメータ
     874    BOOST_FOREACH( GenericType &genericType, formalGenericTypes )
     875    {
     876        genericType.GetType().Resolve( resolver );
     877    }
     878
     879    // 基底クラス
     880    if( this->pSuperClass )
     881    {
     882        if( this->pSuperClass->IsNeedResolve() )
     883        {
     884            this->pSuperClass = resolver.meta.GetClasses().FindEx( *pSuperClass );
     885        }
     886    }
     887
     888    // 基底クラスの型パラメータ（実パラメータ）
     889    BOOST_FOREACH( Type &superClassActualTypeParameter, superClassActualTypeParameters )
     890    {
     891        superClassActualTypeParameter.Resolve( resolver );
     892    }
     893
     894    // Blittable型情報
     895    blittableType.Resolve( resolver );
     896
     897    // 実装するインターフェイス
     898    BOOST_FOREACH( ::Interface *pInterface, interfaces )
     899    {
     900        pInterface->Resolve( resolver );
     901    }
     902
     903    // 動的メンバ
     904    BOOST_FOREACH( Member *pMember, dynamicMembers )
     905    {
     906        pMember->Resolve( resolver );
     907    }
     908
     909    // 静的メンバ
     910    BOOST_FOREACH( Member *pMember, staticMembers )
     911    {
     912        pMember->Resolve( resolver );
     913    }
     914
     915    // 動的メソッド
     916    BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
     917    {
     918        pMethod->Resolve( resolver );
     919    }
     920
     921    // 静的メソッド
     922    BOOST_FOREACH( CMethod *pMethod, staticMethods )
     923    {
     924        pMethod->Resolve( resolver );
     925    }
     926
     927    // テンプレート展開後のクラス
     928    BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
     929    {
     930        pExpandedTemplateClass->Resolve( resolver );
     931    }
     932
    874933    return true;
    875934}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Const.cpp

    r637 r639  
    77}
    88
    9 bool CConst::Resolve()
     9bool CConst::Resolve( const ObjectModule &resolver )
    1010{
    11     // TODO: Resolve
     11    type.Resolve( resolver );
    1212    return true;
    1313}
    … …  
    7878}
    7979
    80 bool ConstMacro::Resolve()
     80bool ConstMacro::Resolve( const ObjectModule &resolver )
    8181{
    82     // TODO: Resolve
     82    // 依存関係を解決すべきメンバは無い
    8383    return true;
    8484}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp

    r637 r639  
    7878}
    7979
    80 void DataTable::Resolve()
     80void DataTable::Resolve( const ObjectModule &resolver )
    8181{
    82     // TODO: Resolve
     82    BOOST_FOREACH( Schedule &schedule, schedules )
     83    {
     84        schedule.Resolve( resolver );
     85    }
    8386}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Delegate.cpp

    r637 r639  
    1919}
    2020
    21 bool Delegate::Resolve()
     21bool Delegate::Resolve( const ObjectModule &resolver )
    2222{
    23     // TODO: Resolve
     23    Procedure::Resolve( resolver );
     24
     25    BOOST_FOREACH( Parameter *pParameter, dynamicParams )
     26    {
     27        pParameter->Resolve( resolver );
     28    }
     29
    2430    return true;
    2531}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Interface.cpp

    r603 r639  
    5252    return interfaceName;
    5353}
     54
     55bool Interface::Resolve( const ObjectModule &resolver )
     56{
     57    // 動的メソッド
     58    BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
     59    {
     60        pMethod->Resolve( resolver );
     61    }
     62
     63    // クラス
     64    if( this->pInterfaceClass )
     65    {
     66        if( this->pInterfaceClass->IsNeedResolve() )
     67        {
     68            this->pInterfaceClass = resolver.meta.GetClasses().FindLike( pInterfaceClass );
     69        }
     70    }
     71
     72    BOOST_FOREACH( Type &actualTypeParameter, actualTypeParameters )
     73    {
     74        actualTypeParameter.Resolve( resolver );
     75    }
     76
     77    return true;
     78}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Member.cpp

    r632 r639  
    4040{
    4141}
     42
     43bool Member::Resolve( const ObjectModule &resolver )
     44{
     45    type.Resolve( resolver );
     46    return true;
     47}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp

    r637 r639  
    253253}
    254254
    255 void Meta::Resolve()
     255void Meta::Resolve( const ObjectModule &resolver )
    256256{
    257257    // 関数・メソッド
    … …  
    261261    {
    262262        UserProc *pUserProc = this->GetUserProcs().Iterator_GetNext();
    263         pUserProc->Resolve();
     263        pUserProc->Resolve( resolver );
    264264    }
    265265
    … …  
    270270    {
    271271        DllProc *pDllProc = this->GetDllProcs().Iterator_GetNext();
    272         pDllProc->Resolve();
     272        pDllProc->Resolve( resolver );
    273273    }
    274274
    … …  
    279279    {
    280280        CClass *pClass = this->GetClasses().Iterator_GetNext();
    281         pClass->Resolve();
     281        pClass->Resolve( resolver );
    282282    }
    283283
    … …  
    285285    BOOST_FOREACH( Variable *pVar, globalVars )
    286286    {
    287         pVar->Resolve();
     287        pVar->Resolve( resolver );
    288288    }
    289289
    … …  
    294294    {
    295295        CConst *pConst = this->GetGlobalConsts().Iterator_GetNext();
    296         pConst->Resolve();
     296        pConst->Resolve( resolver );
    297297    }
    298298
    … …  
    303303    {
    304304        ConstMacro *pConstMacro = this->GetGlobalConstMacros().Iterator_GetNext();
    305         pConstMacro->Resolve();
     305        pConstMacro->Resolve( resolver );
    306306    }
    307307
    … …  
    309309    BOOST_FOREACH( TypeDef &typeDef, typeDefs )
    310310    {
    311         typeDef.Resolve();
     311        typeDef.Resolve( resolver );
    312312    }
    313313
    … …  
    315315    BOOST_FOREACH( ProcPointer *pProcPointer, procPointers )
    316316    {
    317         pProcPointer->Resolve();
     317        pProcPointer->Resolve( resolver );
    318318    }
    319319
    … …  
    324324    {
    325325        Delegate *pDelegate = this->GetDelegates().Iterator_GetNext();
    326         pDelegate->Resolve();
    327     }
    328 }
     326        pDelegate->Resolve( resolver );
     327    }
     328}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Method.cpp

    r603 r639  
    11#include "stdafx.h"
     2
     3bool CMethod::Resolve( const ObjectModule &resolver )
     4{
     5    if( pUserProc )
     6    {
     7        if( pUserProc->IsNeedResolve() )
     8        {
     9            pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
     10        }
     11    }
     12    return true;
     13}
    214
    315DynamicMethod::OverrideResult::EnumType DynamicMethod::Override( const UserProc *pUserProc, Prototype::Accessibility accessibility, bool isOverrideModifier )
    … …  
    2941}
    3042
     43bool DynamicMethod::Resolve( const ObjectModule &resolver )
     44{
     45    CMethod::Resolve( resolver );
     46
     47    if( this->pInheritsClass )
     48    {
     49        if( this->pInheritsClass->IsNeedResolve() )
     50        {
     51            this->pInheritsClass = resolver.meta.GetClasses().FindLike( pInheritsClass );
     52        }
     53    }
     54
     55    return true;
     56}
    3157
    3258StaticMethod::StaticMethod( const StaticMethod &staticMethod )
    … …  
    3561    throw;
    3662}
     63
     64bool StaticMethod::Resolve( const ObjectModule &resolver )
     65{
     66    CMethod::Resolve( resolver );
     67    return true;
     68}
     69
    3770
    3871Methods::Methods()

  • trunk/ab5.0/abdev/ab_common/src/Lexical/NativeCode.cpp

    r637 r639  
    1717    _ASSERT( type == Schedule::ComVtbl || type == Schedule::Vtbl || type == Schedule::TypeInfo );
    1818    return *pClass;
     19}
     20
     21bool Schedule::Resolve( const ObjectModule &resolver )
     22{
     23    switch( type )
     24    {
     25    case UserProc:
     26    case AddressOf:
     27    case CatchAddress:
     28        if( pUserProc->IsNeedResolve() )
     29        {
     30            pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
     31        }
     32        break;
     33    case DllProc:
     34        if( pDllProc->IsNeedResolve() )
     35        {
     36            pDllProc = resolver.meta.GetDllProcs().FindLike( pDllProc );
     37        }
     38        break;
     39    case ComVtbl:
     40    case Vtbl:
     41    case TypeInfo:
     42        if( pClass->IsNeedResolve() )
     43        {
     44            pClass = resolver.meta.GetClasses().FindLike( pClass );
     45        }
     46        break;
     47    default:
     48        break;
     49    }
     50
     51    return true;
    1952}
    2053
    … …  
    158191}
    159192
    160 void NativeCode::Resolve()
     193void NativeCode::Resolve( const ObjectModule &resolver )
    161194{
    162     // TODO: Resolve
     195    BOOST_FOREACH( Schedule &schedule, schedules )
     196    {
     197        schedule.Resolve( resolver );
     198    }
    163199}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/ObjectModule.cpp

    r637 r639  
    8787void ObjectModule::Resolve()
    8888{
    89     this->meta.Resolve();
     89    this->meta.Resolve( *this );
    9090
    9191    // グローバルネイティブコードを解決（スケジュールを解決する）
    92     this->globalNativeCode.Resolve();
     92    this->globalNativeCode.Resolve( *this );
    9393
    9494    // データテーブルを解決（スケジュールを解決する）
    95     this->dataTable.Resolve();
     95    this->dataTable.Resolve( *this );
    9696}
    9797

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp

    r637 r639  
    1111    }
    1212}
     13
     14bool Procedure::Resolve( const ObjectModule &resolver )
     15{
     16    BOOST_FOREACH( Parameter *pParameter, params )
     17    {
     18        pParameter->Resolve( resolver );
     19    }
     20
     21    returnType.Resolve( resolver );
     22
     23    return true;
     24}
     25
    1326
    1427void UserProc::ResetRelationalObjectModuleIndex( const std::vector<int> &relationTable )
    … …  
    157170}
    158171
    159 bool UserProc::Resolve()
    160 {
    161     // TODO: Resolve
     172bool UserProc::Resolve( const ObjectModule &resolver )
     173{
     174    Procedure::Resolve( resolver );
     175
     176    if( pParentClass )
     177    {
     178        if( pParentClass->IsNeedResolve() )
     179        {
     180            pParentClass = resolver.meta.GetClasses().FindLike( pParentClass );
     181        }
     182    }
     183
     184    if( pInterface )
     185    {
     186        const_cast<Interface *>(pInterface)->Resolve( resolver );
     187    }
     188
     189    if( pMethod )
     190    {
     191        pMethod->Resolve( resolver );
     192    }
     193
     194    BOOST_FOREACH( Parameter *pParameter, realParams )
     195    {
     196        pParameter->Resolve( resolver );
     197    }
     198
     199    BOOST_FOREACH( Variable *pLocalVar, localVars )
     200    {
     201        pLocalVar->Resolve( resolver );
     202    }
     203
     204    nativeCode.Resolve( resolver );
    162205    return true;
    163206}
    … …  
    185228}
    186229
    187 bool DllProc::Resolve()
    188 {
    189     // TODO: Resolve
    190     return true;
    191 }
    192 
    193 bool ProcPointer::Resolve()
    194 {
    195     // TODO: Resolve
     230bool DllProc::Resolve( const ObjectModule &resolver )
     231{
     232    Procedure::Resolve( resolver );
     233    return true;
     234}
     235
     236bool ProcPointer::Resolve( const ObjectModule &resolver )
     237{
     238    Procedure::Resolve( resolver );
    196239    return true;
    197240}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Template.cpp

    r632 r639  
    88    }
    99}
     10
     11bool ExpandedTemplateClass::Resolve( const ObjectModule &resolver )
     12{
     13    if( pClass->IsNeedResolve() )
     14    {
     15        pClass = const_cast<CClass *>(resolver.meta.GetClasses().FindLike( pClass ));
     16    }
     17
     18    BOOST_FOREACH( Type &actualType, actualTypes )
     19    {
     20        actualType.Resolve( resolver );
     21    }
     22
     23    return true;
     24}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp

    r632 r639  
    554554    if(name[i]=='%') return DEF_INTEGER;
    555555    return DEF_DOUBLE;
     556}
     557
     558bool Type::Resolve( const ObjectModule &resolver )
     559{
     560    if( this->HasMember() )
     561    {
     562        if( this->pClass->IsNeedResolve() )
     563        {
     564            this->pClass = resolver.meta.GetClasses().FindLike( this->pClass );
     565        }
     566
     567        BOOST_FOREACH( GenericType &actualGenericType, actualGenericTypes )
     568        {
     569            actualGenericType.GetType().Resolve( resolver );
     570        }
     571    }
     572    return true;
    556573}
    557574

  • trunk/ab5.0/abdev/ab_common/src/Lexical/TypeDef.cpp

    r637 r639  
    88}
    99
    10 bool TypeDef::Resolve()
     10bool TypeDef::Resolve( const ObjectModule &resolver )
    1111{
    12     // TODO: Resolve
     12    this->baseType.Resolve( resolver );
    1313    return true;
    1414}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Variable.cpp

    r637 r639  
    2828}
    2929
    30 bool Variable::Resolve()
     30bool Variable::Resolve( const ObjectModule &resolver )
    3131{
    32     // TODO: Resolve
     32    this->type.Resolve( resolver );
    3333    return true;
    3434}
Note: See TracChangeset for help on using the changeset viewer.