source: dev/trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp@ 640

#include "stdafx.h"

void Meta::Clear()
{
    // 名前空間
    namespaceScopesCollection.clear();

    // 関数・メソッド
    userProcs.Clear();

    // DLL関数
    dllProcs.Clear();

    // クラス
    classesImpl.Clear();

    // グローバル変数
    globalVars.Clear();

    // グローバル定数
    globalConsts.Clear();

    // グローバル定数マクロ
    globalConstMacros.Clear();

    // blittable型
    blittableTypes.clear();

    // TypeDef
    typeDefs.clear();

    // 関数ポインタ
    procPointers.Clear();
}

void Meta::StaticLink( Meta &meta, long dataSectionBaseOffset, const std::vector<int> &relationTable )
{
    // 名前空間
    BOOST_FOREACH( NamespaceScopes &namespaceScopes, meta.namespaceScopesCollection )
    {
        if( !this->namespaceScopesCollection.IsExist( namespaceScopes ) )
        {
            this->namespaceScopesCollection.push_back( namespaceScopes );
        }
    }

    // 関数・メソッド
    meta.GetUserProcs().Iterator_Reset();
    while( meta.GetUserProcs().Iterator_HasNext() )
    {
        UserProc *pUserProc = meta.GetUserProcs().Iterator_GetNext();
        if( pUserProc->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        pUserProc->ResetRelationalObjectModuleIndex( relationTable );

        pUserProc->GetNativeCode().ResetDataSectionBaseOffset( dataSectionBaseOffset );

        this->userProcs.Put( pUserProc );
    }
    meta.GetUserProcs().PullOutAll();

    // DLL関数
    meta.GetDllProcs().Iterator_Reset();
    while( meta.GetDllProcs().Iterator_HasNext() )
    {
        DllProc *pDllProc = meta.GetDllProcs().Iterator_GetNext();
        if( pDllProc->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        pDllProc->ResetRelationalObjectModuleIndex( relationTable );
        this->dllProcs.Put( pDllProc );
    }
    meta.GetDllProcs().PullOutAll();

    // クラス
    meta.GetClasses().Iterator_Reset();
    while( meta.GetClasses().Iterator_HasNext() )
    {
        CClass *pClass = meta.GetClasses().Iterator_GetNext();
        if( pClass->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        pClass->ResetRelationalObjectModuleIndex( relationTable );
        pClass->Readed();
        this->GetClasses().Put( pClass );
    }
    meta.GetClasses().PullOutAll();

    // グローバル変数
    long initAreaBaseOffset = this->globalVars.initAreaBuffer.GetSize();
    BOOST_FOREACH( Variable *pVar, meta.globalVars )
    {
        if( pVar->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        // 基底スコープレベルのグローバル変数の生存値をオンにする
        if( pVar->GetScopeLevel() == 0 )
        {
            pVar->isLiving = true;
        }

        bool isResetOffsetAddress = true;
        if( pVar->HasInitData() )
        {
            // 初期バッファがあるときはデータテーブルオフセットを適用する
            pVar->SetOffsetAddress( pVar->GetOffsetAddress() + initAreaBaseOffset );

            isResetOffsetAddress = false;
        }

        pVar->ResetRelationalObjectModuleIndex( relationTable );
        this->globalVars.Add( pVar, isResetOffsetAddress );
    }
    meta.globalVars.PullOutAll();
    this->globalVars.initAreaBuffer.Put(
        meta.globalVars.initAreaBuffer.GetBuffer(),
        meta.globalVars.initAreaBuffer.GetSize()
    );

    // グローバル定数
    meta.GetGlobalConsts().Iterator_Reset();
    while( meta.GetGlobalConsts().Iterator_HasNext() )
    {
        CConst *pConst = meta.GetGlobalConsts().Iterator_GetNext();
        if( pConst->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        pConst->ResetRelationalObjectModuleIndex( relationTable );
        this->GetGlobalConsts().Put( pConst );
    }
    meta.GetGlobalConsts().PullOutAll();

    // グローバル定数マクロ
    meta.GetGlobalConstMacros().Iterator_Reset();
    while( meta.GetGlobalConstMacros().Iterator_HasNext() )
    {
        ConstMacro *pConstMacro = meta.GetGlobalConstMacros().Iterator_GetNext();
        if( pConstMacro->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        pConstMacro->ResetRelationalObjectModuleIndex( relationTable );
        this->GetGlobalConstMacros().Put( pConstMacro );
    }
    meta.GetGlobalConstMacros().PullOutAll();

    // blittable型
    BOOST_FOREACH( BlittableType &blittableType, meta.blittableTypes )
    {
        // TODO: coreモジュール以外でもBlittable型用のクラスモジュールを定義できるようにすべき
        this->blittableTypes.push_back( blittableType );
    }
    meta.blittableTypes.clear();

    // TypeDef
    BOOST_FOREACH( TypeDef &typeDef, meta.typeDefs )
    {
        if( typeDef.IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        typeDef.ResetRelationalObjectModuleIndex( relationTable );
        this->typeDefs.push_back( typeDef );
    }
    meta.typeDefs.clear();

    // 関数ポインタ
    BOOST_FOREACH( ProcPointer *pProcPointer, meta.procPointers )
    {
        if( pProcPointer->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        pProcPointer->ResetRelationalObjectModuleIndex( relationTable );
        this->procPointers.push_back( pProcPointer );
    }
    meta.procPointers.PullOutAll();

    // デリゲート
    meta.GetDelegates().Iterator_Reset();
    while( meta.GetDelegates().Iterator_HasNext() )
    {
        Delegate *pDelegate = meta.GetDelegates().Iterator_GetNext();
        if( pDelegate->IsExternal() )
        {
            // 外部参照の場合は取り込まない
            continue;
        }

        pDelegate->ResetRelationalObjectModuleIndex( relationTable );
        this->GetDelegates().Put( pDelegate );
    }
    meta.GetDelegates().PullOutAll();
}

const ::Delegate &Meta::ToDelegate( const CClass &_class )
{
    const ::Delegate *dg = this->GetDelegates().GetHashArrayElement( _class.GetName().c_str() );
    while( dg )
    {
        if( dg->IsEqualSymbol( _class.GetNamespaceScopes(), _class.GetName() ) ){
            //名前空間とクラス名が一致した
            return *dg;
        }
        dg = dg->GetChainNext();
    }

    throw;
}

const CClass *Meta::FindClassSupportedTypeDef( const Symbol &symbol )
{
    const CClass *pClass = this->GetClasses().FindEx( symbol );
    if( pClass )
    {
        return pClass;
    }

    // TypeDefも見る
    const TypeDef *pTypeDef = this->GetTypeDefs().Find( symbol );
    if( pTypeDef )
    {
        Type type = pTypeDef->GetBaseType();
        if( type.IsObject() )
        {
            return &type.GetClass();
        }
    }

    return NULL;
}

void Meta::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    // 関数・メソッド
    this->GetUserProcs().Iterator_Init();
    this->GetUserProcs().Iterator_Reset();
    while( this->GetUserProcs().Iterator_HasNext() )
    {
        UserProc *pUserProc = this->GetUserProcs().Iterator_GetNext();
        pUserProc->Resolve( resolver, resolveErrors );
    }

    // DLL関数
    this->GetDllProcs().Iterator_Init();
    this->GetDllProcs().Iterator_Reset();
    while( this->GetDllProcs().Iterator_HasNext() )
    {
        DllProc *pDllProc = this->GetDllProcs().Iterator_GetNext();
        pDllProc->Resolve( resolver, resolveErrors );
    }

    // クラス
    this->GetClasses().Iterator_Init();
    this->GetClasses().Iterator_Reset();
    while( this->GetClasses().Iterator_HasNext() )
    {
        CClass *pClass = this->GetClasses().Iterator_GetNext();
        pClass->Resolve( resolver, resolveErrors );
    }

    // グローバル変数
    BOOST_FOREACH( Variable *pVar, globalVars )
    {
        pVar->Resolve( resolver, resolveErrors );
    }

    // グローバル定数
    this->GetGlobalConsts().Iterator_Init();
    this->GetGlobalConsts().Iterator_Reset();
    while( this->GetGlobalConsts().Iterator_HasNext() )
    {
        CConst *pConst = this->GetGlobalConsts().Iterator_GetNext();
        pConst->Resolve( resolver, resolveErrors );
    }

    // グローバル定数マクロ
    this->GetGlobalConstMacros().Iterator_Init();
    this->GetGlobalConstMacros().Iterator_Reset();
    while( this->GetGlobalConstMacros().Iterator_HasNext() )
    {
        ConstMacro *pConstMacro = this->GetGlobalConstMacros().Iterator_GetNext();
        pConstMacro->Resolve( resolver, resolveErrors );
    }

    // blittable型
    BOOST_FOREACH( BlittableType &blittableType, blittableTypes )
    {
        blittableType.Resolve( resolver, resolveErrors );
    }

    // TypeDef
    BOOST_FOREACH( TypeDef &typeDef, typeDefs )
    {
        typeDef.Resolve( resolver, resolveErrors );
    }

    // 関数ポインタ
    BOOST_FOREACH( ProcPointer *pProcPointer, procPointers )
    {
        pProcPointer->Resolve( resolver, resolveErrors );
    }

    // デリゲート
    this->GetDelegates().Iterator_Init();
    this->GetDelegates().Iterator_Reset();
    while( this->GetDelegates().Iterator_HasNext() )
    {
        Delegate *pDelegate = this->GetDelegates().Iterator_GetNext();
        pDelegate->Resolve( resolver, resolveErrors );
    }
}