source: dev/trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp@ 828

#include "stdafx.h"
#include <jenga/include/jenga.h>
#include <abdev/ab_common/include/ab_common.h>
#include <algorithm>
#include <boost/checked_delete.hpp>

CClass::CClass( const Symbol &symbol, const NamespaceScopesCollection &importedNamespaces )
    : ClassPrototype( symbol )
    , importedNamespaces( importedNamespaces )
    , classType( Class )
    , pSuperClass( NULL )
    , blittableType( Type() )
    , isReady( false )
    , fixedAlignment( 0 )
    , ConstructorMemberSubIndex( -1 )
    , DestructorMemberSubIndex( -1 )
    , vtblNum( 0 )
    , vtbl_offset( -1 )
    , comVtblOffset( 0 )
    , isCompilingConstructor( false )
    , isCompilingDestructor( false )
    , cacheSize( 0 )
{
}

CClass::CClass(
    const Symbol &symbol,
    const NamespaceScopesCollection &importedNamespaces,
    ClassType classType,
    const GenericTypes &formalGenericTypes,
    const Types &superClassActualTypeParameters,
    int ConstructorMemberSubIndex,
    int DestructorMemberSubIndex,
    int vtblNum,
    int fixedAlignment,
    const Types &expandedClassActualTypeParameters )
    : ClassPrototype( symbol )
    , importedNamespaces( importedNamespaces )
    , classType( classType )
    , formalGenericTypes( formalGenericTypes )
    , pSuperClass( NULL )
    , superClassActualTypeParameters( superClassActualTypeParameters )
    , blittableType( Type() )
    , isReady( false )
    , ConstructorMemberSubIndex( ConstructorMemberSubIndex )
    , DestructorMemberSubIndex( DestructorMemberSubIndex )
    , vtblNum( vtblNum )
    , fixedAlignment( fixedAlignment )
    , expandedClassActualTypeParameters( expandedClassActualTypeParameters )
    , vtbl_offset( -1 )
    , comVtblOffset( 0 )
    , isCompilingConstructor( false )
    , isCompilingDestructor( false )
    , cacheSize( 0 )
{
}

CClass::CClass()
    : ClassPrototype()
    , importedNamespaces()
    , classType()
    , pSuperClass( NULL )
    , blittableType( Type() )
    , isReady( false )
    , fixedAlignment( 0 )
    , ConstructorMemberSubIndex( -1 )
    , DestructorMemberSubIndex( -1 )
    , vtblNum( 0 )
    , vtbl_offset( -1 )
    , comVtblOffset( 0 )
    , isCompilingConstructor( false )
    , isCompilingDestructor( false )
    , cacheSize( 0 )
{
}

CClass::~CClass()
{
    using std::for_each;
    using boost::checked_deleter;
    // 動的メンバ
    for_each( dynamicMembers.begin(), dynamicMembers.end(), checked_deleter<Member>() );
    // 静的メンバ
    for_each( staticMembers.begin(), staticMembers.end(), checked_deleter<Member>() );
    // インターフェイス
    for_each( interfaces.begin(), interfaces.end(), checked_deleter<::Interface>() );
    // テンプレート展開済みのクラス
    for_each( expandedTemplateClasses.begin(), expandedTemplateClasses.end(), checked_deleter<ExpandedTemplateClass>() );
}

void CClass::Using() const
{
    if( this->IsUsing() )
    {
        // 既に使用することになっている
        return;
    }

    Prototype::Using();

    // 仮想関数になるメソッドに使用チェックをつける
    const CClass &_class = *this;
    foreach( const CMethod *pMethod, _class.GetDynamicMethods() )
    {
        if( pMethod->IsVirtual() )
        {
            pMethod->GetUserProc().Using();
        }
    }

    // インターフェイスメソッドに使用チェックをつける
    foreach( const ::Interface *pInterface, _class.GetInterfaces() )
    {
        foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() )
        {
            pMethod->GetUserProc().Using();
        }
    }
}
bool CClass::IsClass() const
{
    return classType == CClass::Class;
}
bool CClass::IsInterface() const
{
    return classType == CClass::Interface;
}
bool CClass::IsComInterface() const
{
    return classType == CClass::ComInterface;
}
bool CClass::IsEnum() const
{
    return classType == CClass::Enum;
}
bool CClass::IsDelegate() const
{
    return classType == CClass::Delegate;
}
bool CClass::IsStructure() const
{
    return classType == CClass::Structure;
}


// コンストラクタのコンパイルを開始
void CClass::NotifyStartConstructorCompile() const
{
    isCompilingConstructor = true;
}

//コンストラクタのコンパイルを終了
void CClass::NotifyFinishConstructorCompile() const
{
    isCompilingConstructor = false;
}

//コンストラクタをコンパイル中かどうかを判別
bool CClass::IsCompilingConstructor() const
{
    return isCompilingConstructor;
}

//デストラクタのコンパイルを開始
void CClass::NotifyStartDestructorCompile() const{
    isCompilingDestructor = true;
}

//デストラクタのコンパイルを終了
void CClass::NotifyFinishDestructorCompile() const{
    isCompilingDestructor = false;
}

//デストラクタをコンパイル中かどうかを判別
bool CClass::IsCompilingDestructor() const
{
    return isCompilingDestructor;
}

//自身の派生クラスかどうかを確認
bool CClass::IsSubClass( const CClass *pSubClass ) const
{
    if( !pSubClass->HasSuperClass() )
    {
        return false;
    }

    const CClass *pTempClass = &pSubClass->GetSuperClass();
    while( pTempClass ){
        if( this == pTempClass ) return true;
        pTempClass = &pTempClass->GetSuperClass();
    }
    return false;
}

//自身と等しいまたは派生クラスかどうかを確認
bool CClass::IsEqualsOrSubClass( const CClass *pSubClass ) const
{
    if( IsEquals( pSubClass ) ) return true;
    return IsSubClass( pSubClass );
}

// 自身と等しいまたは派生クラス、基底クラスかどうかを確認
bool CClass::IsEqualsOrSubClassOrSuperClass( const CClass &objClass ) const
{
    if( IsEquals( &objClass ) ) return true;
    if( IsSubClass( &objClass ) ) return true;
    if( objClass.IsSubClass( this ) ) return true;
    return false;
}

bool CClass::IsInheritsInterface( const CClass *pInterfaceClass ) const
{
    foreach( const ::Interface *pInterface, interfaces ){
        if( pInterfaceClass == &pInterface->GetClass() ){
            return true;
        }
    }
    return false;
}

bool CClass::InheritsClass( const CClass &inheritsClass, const Types &actualTypeParameters, int nowLine )
{
    //メソッドをコピー
    const Methods& inheritsClassMethods = inheritsClass.GetDynamicMethods();
    GetDynamicMethods().reserve( inheritsClassMethods.size() );
    foreach( const CMethod *pBaseMethod, inheritsClassMethods ){
        CMethod *pMethod = new DynamicMethod( *pBaseMethod );

        // アクセシビリティ
        if(pBaseMethod->GetAccessibility() == Prototype::Private){
            pMethod->SetAccessibility( Prototype::None );
        }
        else{
            pMethod->SetAccessibility( pBaseMethod->GetAccessibility() );
        }

        //pobj_Inherits
        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
        if(pBaseMethod->GetInheritsClassPtr()==0){
            pMethod->SetInheritsClassPtr( &inheritsClass );
        }
        else{
            pMethod->SetInheritsClassPtr( pBaseMethod->GetInheritsClassPtr() );
        }

        GetDynamicMethods().push_back( pMethod );
    }

    //仮想関数の数
    AddVtblNum( inheritsClass.GetVtblNum() );

    //継承先のクラスをメンバとして保持する
    SetSuperClass( &inheritsClass );
    SetSuperClassActualTypeParameters( actualTypeParameters );

    // インターフェイスを引き継ぐ
    const Interfaces& inheritsClassInterfaces = inheritsClass.GetInterfaces();
    interfaces.reserve( inheritsClassInterfaces.size() );
    foreach( const ::Interface *pInterface, inheritsClassInterfaces )
    {
        interfaces.push_back( new ::Interface( *pInterface ) );
    }

    if( this->IsInterface() && inheritsClass.IsComInterface() )
    {
        // COMインターフェイスを継承した場合はCOMインターフェイスにする
        this->SetClassType( CClass::ComInterface );
    }

    return true;
}

bool CClass::InheritsInterface( const CClass &inheritsInterfaceClass, const Types &actualTypeParameters, int nowLine )
{
    if( !( this->IsInterface() || this->IsComInterface() ) )
    {
        Jenga::Throw( "非インターフェイスに対してCClass::InheritsInterfaceメソッドが呼ばれた" );
    }

    // インターフェイスを継承する
    return this->InheritsClass( inheritsInterfaceClass, actualTypeParameters, nowLine );
}

void CClass::AddDynamicMember( Member *pMember )
{
    dynamicMembers.push_back( pMember );
}
void CClass::AddStaticMember( Member *pMember )
{
    staticMembers.push_back( pMember );
}

bool CClass::DupliCheckAll(const char *name) const
{
    //重複チェック

    //メンバ
    if(DupliCheckMember(name)) return 1;

    //メソッド
    foreach( const CMethod *pMethod, GetDynamicMethods() ){
        if(  name == pMethod->GetUserProc().GetName() ){
            return 1;
        }
    }

    return 0;
}
bool CClass::DupliCheckMember(const char *name) const
{
    //重複チェック

    if( this->HasSuperClass() )
    {
        if( this->GetSuperClass().DupliCheckMember( name ) )
        {
            // 基底クラスで重複が発見された
            return true;
        }
    }

    // 動的メンバ
    foreach( const Member *pMember, dynamicMembers )
    {
        if( GetName() == pMember->GetName() )
        {
            return true;
        }
    }

    // 静的メンバ
    foreach( Member *pMember, staticMembers ){
        if( GetName() == pMember->GetName() ){
            return true;
        }
    }

    return false;
}

const Member *CClass::FindDynamicMember( const char *memberName ) const
{
    if( this->HasSuperClass() )
    {
        // 基底クラスで検索
        const Member *result = this->GetSuperClass().FindDynamicMember( memberName );
        if( result )
        {
            return result;
        }
    }

    foreach( Member *pMember, GetDynamicMembers() )
    {
        if( pMember->GetName() == memberName )
        {
            return pMember;
        }
    }
    return NULL;
}

void CClass::EnumDynamicMethodsOrInterfaceMethods( const char *methodName, std::vector<const UserProc *> &subs ) const
{
    // 動的メソッド
    GetDynamicMethods().Enum( methodName, subs );

    // インターフェイス メソッド
    foreach( ::Interface *pInterface, GetInterfaces() )
    {
        pInterface->GetDynamicMethods().Enum( methodName, subs );
    }
}
const CMethod *CClass::GetDynamicMethodOrInterfaceMethod( const UserProc *pUserProc ) const
{
    // 動的メソッド
    const CMethod *result = GetDynamicMethods().GetMethodPtr( pUserProc );

    if( !result )
    {
        // インターフェイス メソッド
        foreach( ::Interface *pInterface, GetInterfaces() )
        {
            result = pInterface->GetDynamicMethods().GetMethodPtr( pUserProc );
            if( result )
            {
                return result;
            }
        }
    }

    return result;
}

void CClass::ResolveExpandedClassActualTypeParameter( Type &type ) const
{
    if( !this->IsExpanded() )
    {
        _ASSERTE( false );
    }

    if( !type.IsTypeParameter() )
    {
        // 型パラメータではない場合
        return;
    }

    type = expandedClassActualTypeParameters[type.GetFormalTypeIndex()];
}

//サイズを取得
int CClass::GetSize() const
{
    int resultSize = 0;

    int alignment = 1;
    if( this->IsStructure() )
    {
        // 構造体のとき

        if( this->GetFixedAlignment() )
        {
            // アラインメントの固定値が指定されていた場合はそれを取得
            alignment = this->GetFixedAlignment();
        }
    }
    else
    {
        // それ以外

        if( this->HasSuperClass() )
        {
            const CClass& super = this->GetSuperClass();
            // 基底クラスのサイズを追加
            resultSize += super.GetSize();

            // 基底クラスのアラインメントを取得
            alignment = super.GetAlignment();
        }
        else
        {
            // 基底クラスが存在しないとき

            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
            resultSize += IsExistVirtualFunctions() ? PTR_SIZE*2 : 0;
        }
    }

    foreach( Member *pMember, dynamicMembers )
    {
        const Type& memberType = pMember->GetType();
        // メンバサイズ
        int tempMemberSize = memberType.GetSize();

        // 一時アラインメントを算出
        int tempAlignment = tempMemberSize;
        if( memberType.IsStruct() )
        {
            // メンバが構造体の場合は、メンバのアラインメントを取得
            tempAlignment = memberType.GetClass().GetAlignment();
        }

        // アラインメントを考慮してパディングを追加
        if( GetFixedAlignment() && alignment < tempAlignment )
        {
            if( resultSize % alignment )
            {
                resultSize += alignment - ( resultSize % alignment );
            }
        }
        else
        {
            if( alignment < tempAlignment )
            {
                // 最大アラインメントを更新
                alignment = tempAlignment;
            }

            if( tempMemberSize == 0 )
            {
                if( !memberType.IsStruct() )
                {
                    throw;
                }

                //メンバを持たない構造体
                //※何もしない（オフセットの計算をしない）
            }
            else{
                if( resultSize % tempAlignment )
                {
                    resultSize += tempAlignment - ( resultSize % tempAlignment );
                }
            }
        }

        // メンバサイズを加算（配列を考慮）
        resultSize += tempMemberSize * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
    }

    if( alignment )
    {
        // 末尾アラインメントを考慮してパディングを追加
        if( resultSize % alignment )
        {
            resultSize += alignment - ( resultSize % alignment );
        }
    }

    return resultSize;
}

//メンバのオフセットを取得
int CClass::GetMemberOffset( const char *memberName ) const
{
    int resultSize = 0;

    int alignment = 1;
    if( this->IsStructure() )
    {
        // 構造体のとき

        if( this->GetFixedAlignment() )
        {
            // アラインメントの固定値が指定されていた場合はそれを取得
            alignment = this->GetFixedAlignment();
        }
    }
    else
    {
        // それ以外

        if( this->HasSuperClass() )
        {
            if( this->GetSuperClass().HasDynamicMember( memberName ) )
            {
                // 基底クラスのメンバを取得
                return this->GetSuperClass().GetMemberOffset( memberName );
            }

            // 基底クラスのサイズを追加
            resultSize += this->GetSuperClass().GetSize();

            // 基底クラスのアラインメントを取得
            alignment = this->GetSuperClass().GetAlignment();
        }
        else
        {
            // 基底クラスが存在しないとき

            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
            resultSize += IsExistVirtualFunctions() ? PTR_SIZE*2 : 0;
        }
    }

    foreach( Member *pMember, dynamicMembers )
    {
        // メンバサイズ
        int tempMemberSize = pMember->GetType().GetSize();

        // 一時アラインメントを算出
        int tempAlignment = tempMemberSize;
        if( pMember->GetType().IsStruct() )
        {
            // メンバが構造体の場合は、メンバのアラインメントを取得
            tempAlignment = pMember->GetType().GetClass().GetAlignment();
        }

        // アラインメントを考慮してパディングを追加
        if( GetFixedAlignment() && alignment < tempAlignment )
        {
            if( resultSize % alignment )
            {
                resultSize += alignment - ( resultSize % alignment );
            }
        }
        else
        {
            if( alignment < tempAlignment )
            {
                // 最大アラインメントを更新
                alignment = tempAlignment;
            }

            if( tempMemberSize == 0 )
            {
                if( !pMember->GetType().IsStruct() )
                {
                    throw;
                }

                //メンバを持たない構造体
                //※何もしない（オフセットの計算をしない）
            }
            else{
                if( resultSize % tempAlignment )
                {
                    resultSize += tempAlignment - ( resultSize % tempAlignment );
                }
            }
        }

        if(memberName){
            //メンバ指定がある場合は、オフセットを返す
            if( pMember->GetName() == memberName )
            {
                return resultSize;
            }
        }

        // メンバサイズを加算（配列を考慮）
        resultSize += tempMemberSize * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
    }

    if( alignment )
    {
        // 末尾アラインメントを考慮してパディングを追加
        if( resultSize % alignment )
        {
            resultSize += alignment - ( resultSize % alignment );
        }
    }

    return resultSize;
}
int CClass::GetAlignment() const
{
    int alignment = 1;
    if( this->IsStructure() )
    {
        // 構造体のとき

        if( this->GetFixedAlignment() )
        {
            // アラインメントの固定値が指定されていた場合はそれを取得
            return this->GetFixedAlignment();
        }
    }
    else
    {
        // それ以外

        if( this->HasSuperClass() )
        {
            // 基底クラスのアラインメントを取得
            alignment = this->GetSuperClass().GetAlignment();
        }
        else
        {
            // 基底クラスが存在しないとき

            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
            alignment = PTR_SIZE;
        }
    }

    foreach( Member *pMember, dynamicMembers )
    {
        int tempAlignment = pMember->GetType().GetSize();
        if( pMember->GetType().IsStruct() )
        {
            // メンバが構造体の場合は、メンバのアラインメントを取得
            tempAlignment = pMember->GetType().GetClass().GetAlignment();
        }

        if( alignment < tempAlignment )
        {
            // 最大アラインメントを更新
            alignment = tempAlignment;
        }
    }

    return alignment;
}

void CClass::GetVtblMasterListIndexAndVtblIndex( const UserProc *pUserProc, int &vtblMasterListIndex, int &vtblIndex ) const
{
    vtblMasterListIndex = 0;

    vtblIndex = 0;
    foreach( const CMethod *pMethod, GetDynamicMethods() ){
        if( &pMethod->GetUserProc() == pUserProc )
        {
            return;
        }

        if( pMethod->IsVirtual() )
        {
            vtblIndex++;
        }
    }

    foreach( const ::Interface *pInterface, interfaces )
    {
        vtblMasterListIndex++;

        vtblIndex = 0;
        foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
            if( &pMethod->GetUserProc() == pUserProc )
            {
                return;
            }

            if( pMethod->IsVirtual() )
            {
                vtblIndex++;
            }
        }
    }

    _ASSERT( false );
    throw;
}
int CClass::GetVtblMasterListIndex( const CClass *pClass ) const
{
    int result = 0;

    foreach( const ::Interface *pInterface, interfaces )
    {
        result++;
        
        if( &pInterface->GetClass() == pClass )
        {
            return result;
        }
    }

    _ASSERT( false );
    throw;
}
long CClass::GetVtblMasterListOffset() const
{
    if( vtblMasterListOffset == -1 )
    {
        _ASSERT( false );
        throw;
    }

    return vtblMasterListOffset;
}
bool CClass::IsAbstract() const
{
    // 未実装(abstract)の仮想関数を持つ場合はtrueを返す

    foreach( const CMethod *pMethod, GetDynamicMethods() ){
        if(pMethod->IsVirtual()){
            if(pMethod->IsAbstract()){
                return true;
            }
        }
    }

    // インターフェイスのvtbl
    foreach( const ::Interface *pInterface, interfaces )
    {
        foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
            if(pMethod->IsVirtual()){
                if(pMethod->IsAbstract()){
                    return true;
                }
            }
        }
    }

    return false;
}

const CClass *Classes::FindEx( const Symbol &symbol ) const
{
    if( symbol.GetNamespaceScopes().size() == 0 && symbol.GetName() == "Object" )
    {
        return GetObjectClassPtr();
    }
    else if( symbol.GetNamespaceScopes().size() == 0 && symbol.GetName() == "String" )
    {
        return GetStringClassPtr();
    }

    std::vector<const CClass *> classes;
    foreach (auto pClass, GetHashArrayElement(symbol.GetName()))
    {
        if ( pClass->IsEqualSymbol(symbol.GetNamespaceScopes(), symbol.GetName()))
        {
            //名前空間とクラス名が一致した
            classes.push_back( pClass );
        }
    }
    if( classes.size() > 0 )
    {
        // 複数の名前空間の中に同一のクラス名が存在する場合があるので、アクセス可能で尚且つ階層が一番深いものをチョイスする
        auto pClass = classes.front();

        foreach( const CClass *pTempClass, classes )
        {
            if( pClass->GetNamespaceScopes().size() < pTempClass->GetNamespaceScopes().size() )
            {
                pClass = pTempClass;
            }
        }

        return pClass;
    }

    return NULL;
}

const CClass *Classes::GetStringClassPtr() const
{
    if( !pStringClass )
    {
        // キャッシュしておく
        pStringClass = this->FindEx( Symbol( NamespaceScopes( "System" ), "String" ) );
    }
    return pStringClass;
}
const CClass *Classes::GetObjectClassPtr() const
{
    if( !pObjectClass )
    {
        // キャッシュしておく
        pObjectClass = this->FindEx( Symbol( NamespaceScopes( "System" ), "Object" ) );
    }
    return pObjectClass;
}
const CClass *Classes::GetInterfaceInfoClassPtr() const
{
    if( !pInterfaceInfo )
    {
        // キャッシュしておく
        pInterfaceInfo = this->FindEx( Symbol( NamespaceScopes( "ActiveBasic.Core" ), "InterfaceInfo" ) );
    }
    return pInterfaceInfo;
}

std::string CClass::GetStaticDefiningStringAsMemberNames() const
{
    std::string result;

    foreach( const Member *pMember, dynamicMembers )
    {
        if( result.size() )
        {
            result += ',';
        }

        result += '\"' + pMember->GetName() + '\"';
    }

    return result;
}
std::string CClass::GetStaticDefiningStringAsMemberOffsets() const
{
    std::string result;

    foreach( const Member *pMember, dynamicMembers )
    {
        if( result.size() )
        {
            result += ',';
        }

        int offset = this->GetMemberOffset( pMember->GetName().c_str() );

        char temporary[255];
        _itoa( offset, temporary, 16 );

        result += (std::string)"&H" + temporary;
    }

    return result;
}

void CClass::GetReferenceOffsetsInitializeBuffer( std::string &referenceOffsetsBuffer, int &numOfReference, int baseOffset ) const
{
    const CClass &thisClass = *this;
    foreach( const Member *pMember, thisClass.GetDynamicMembers() )
    {
        if( pMember->GetType().IsObject() || pMember->GetType().IsPointer() )
        {
            if( referenceOffsetsBuffer.size() )
            {
                referenceOffsetsBuffer += ",";
            }

            char temp[255];
            sprintf( temp, "%d", baseOffset + thisClass.GetMemberOffset( pMember->GetName().c_str() ) );
            referenceOffsetsBuffer += temp;

            numOfReference++;
        }
        if( pMember->GetType().IsStruct() && !pMember->GetType().IsPointer() )
        {
            // 構造体の実体をメンバに持つとき
            int baseOffset = thisClass.GetMemberOffset( pMember->GetName().c_str() );

            // 構造体メンバでGCによるチェックが必要な参照位置を追加
            pMember->GetType().GetClass().GetReferenceOffsetsInitializeBuffer( referenceOffsetsBuffer, numOfReference, baseOffset );
        }
    }
}

bool CClass::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    // 型パラメータ
    BOOST_FOREACH( GenericType &genericType, formalGenericTypes )
    {
        genericType.GetType().Resolve( resolver, resolveErrors );
    }

    // 基底クラス
    if( this->pSuperClass )
    {
        if( this->pSuperClass->IsNeedResolve() )
        {
            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pSuperClass );
            if( pTempClass )
            {
                this->pSuperClass = pTempClass;
            }
            else
            {
                resolveErrors.Add( ResolveError( this->pSuperClass->GetRelationalObjectModuleIndex(), this->pSuperClass->GetFullName() ) );
            }
        }
    }

    // 基底クラスの型パラメータ（実パラメータ）
    BOOST_FOREACH( Type &superClassActualTypeParameter, superClassActualTypeParameters )
    {
        superClassActualTypeParameter.Resolve( resolver, resolveErrors );
    }

    // Blittable型情報
    blittableType.Resolve( resolver, resolveErrors );

    // 実装するインターフェイス
    foreach( ::Interface *pInterface, interfaces )
    {
        pInterface->Resolve( resolver, resolveErrors );
    }

    // 動的メンバ
    foreach( Member *pMember, dynamicMembers )
    {
        pMember->Resolve( resolver, resolveErrors );
    }

    // 静的メンバ
    foreach( Member *pMember, staticMembers )
    {
        pMember->Resolve( resolver, resolveErrors );
    }

    // 動的メソッド
    foreach( CMethod *pMethod, GetDynamicMethods() )
    {
        pMethod->Resolve( resolver, resolveErrors );
    }

    // 静的メソッド
    foreach( CMethod *pMethod, staticMethods )
    {
        pMethod->Resolve( resolver, resolveErrors );
    }

    // テンプレート展開後のクラス
    foreach( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
    {
        pExpandedTemplateClass->Resolve( resolver, resolveErrors );
    }

    return true;
}