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

#include "stdafx.h"
#include <jenga/include/jenga.h>
#include <abdev/ab_common/include/ab_common.h>

#define BREAK_EIP(checkEip)  (obp+0x00401000>=checkEip)

const ::DllProc &Schedule::GetDllProc() const
{
    _ASSERT( type == Schedule::DllProc );
    return *pDllProc;
}
const ::UserProc &Schedule::GetUserProc() const
{
    _ASSERT( type == Schedule::UserProc || type == Schedule::AddressOf || type == Schedule::CatchAddress );
    return *pUserProc;
}
const ::CClass &Schedule::GetClass() const
{
    _ASSERT( type == Schedule::ComVtbl || type == Schedule::Vtbl || type == Schedule::TypeInfo );
    return *pClass;
}

bool Schedule::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    switch( type )
    {
    case UserProc:
    case AddressOf:
    case CatchAddress:
        if( this->pUserProc->IsNeedResolve() )
        {
            const ::UserProc *pTempUserProc = resolver.meta.GetUserProcs().FindLike( this->pUserProc );
            if( pTempUserProc )
            {
                this->pUserProc = pTempUserProc;
            }
            else
            {
                resolveErrors.Add( ResolveError( this->pUserProc->GetRelationalObjectModuleIndex(), this->pUserProc->GetFullName() ) );
            }
        }
        break;
    case DllProc:
        if( this->pDllProc->IsNeedResolve() )
        {
            const ::DllProc *pTempDllProc = resolver.meta.GetDllProcs().FindLike( this->pDllProc );
            if( pTempDllProc )
            {
                this->pDllProc = pTempDllProc;
            }
            else
            {
                resolveErrors.Add( ResolveError( this->pDllProc->GetRelationalObjectModuleIndex(), this->pDllProc->GetFullName() ) );
            }
        }
        break;
    case ComVtbl:
    case Vtbl:
    case TypeInfo:
        if( this->pClass->IsNeedResolve() )
        {
            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
            if( pTempClass )
            {
                this->pClass = pTempClass;
            }
            else
            {
                resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
            }
        }
        break;
    default:
        break;
    }

    return true;
}

void NativeCode::PutEx( const NativeCode &nativeCode )
{
    long baseOffset = GetSize();

    // コードバッファを追加
    Put( nativeCode.GetBuffer(), nativeCode.GetSize() );

    // スケジュールを追加
    foreach( const Schedule &schedule, nativeCode.schedules )
    {
        this->schedules.push_back(
            Schedule(
                schedule.GetType(),
                baseOffset + schedule.GetOffset(),
                schedule.GetLongPtrValue()
            )
        );
    }

    // ソースコード行番号とネイティブコード位置の対応情報を追加
    foreach( const SourceLine &sourceLine, nativeCode.sourceLines )
    {
        this->sourceLines.push_back(
            SourceLine(
                baseOffset + sourceLine.GetNativeCodePos(),
                sourceLine.GetCodeType(),
                sourceLine.GetSourceCodePosition()
            )
        );
    }
}

void NativeCode::PutEx( long l, Schedule::Type scheduleType )
{
    if( scheduleType != Schedule::None )
    {
        schedules.push_back( Schedule( scheduleType, GetSize() ) );
    }

    Put( l );
}

void NativeCode::PutUserProcSchedule( const UserProc *pUserProc, bool isCall )
{
    pUserProc->Using();

    Schedule::Type type = isCall ? Schedule::UserProc : Schedule::AddressOf;

    schedules.push_back( Schedule( type, pUserProc, GetSize() ) );

    Put( (long)0 );
}

void NativeCode::PutCatchAddressSchedule( const UserProc *pUserProc, long codePos )
{
    pUserProc->Using();

    schedules.push_back( Schedule( Schedule::CatchAddress, pUserProc, GetSize() ) );

    Put( codePos );
}

void NativeCode::PutDllProcSchedule( const DllProc *pDllProc )
{
    schedules.push_back( Schedule( pDllProc, GetSize() ) );

    Put( (long)0 );
}

void NativeCode::PutComVtblSchedule( const CClass *pClass )
{
    schedules.push_back( Schedule( Schedule::ComVtbl, pClass, GetSize() ) );

    Put( (long)0 );
}

void NativeCode::PutVtblSchedule( const CClass *pClass )
{
    schedules.push_back( Schedule( Schedule::Vtbl, pClass, GetSize() ) );

    Put( (long)0 );
}

void NativeCode::NextSourceLine( const SourceCodePosition &sourceCodePosition, bool isInSystemProc )
{
    if( sourceLines.size() )
    {
        if( sourceLines.back().GetNativeCodePos() == GetSize() )
        {
            sourceLines.back().SetSourceCodePosition( sourceCodePosition );
            return;
        }
    }

    extern BOOL bDebugSupportProc;
    DWORD sourceLineType = 0;
    if( bDebugSupportProc )
    {
        sourceLineType |= CODETYPE_DEBUGPROC;
    }
    if( isInSystemProc )
    {
        sourceLineType |= CODETYPE_SYSTEMPROC;
    }
    sourceLines.push_back(
        SourceLine(
            GetSize(),
            sourceLineType,
            sourceCodePosition
        )
    );
}

void NativeCode::ResetDataSectionBaseOffset( long dataSectionBaseOffset )
{
    foreach( const Schedule &schedule, schedules )
    {
        if( schedule.GetType() == Schedule::DataTable )
        {
            Overwrite(
                schedule.GetOffset(),
                GetLong( schedule.GetOffset() ) + dataSectionBaseOffset
            );
        }
    }
}
void NativeCode::ResetRelationalObjectModuleIndex( const std::vector<int> &relationTable )
{
    BOOST_FOREACH( SourceLine &sourceLine, sourceLines )
    {
        sourceLine.GetSourceCodePosition().SetRelationalObjectModuleIndex(
            relationTable[sourceLine.GetSourceCodePosition().GetRelationalObjectModuleIndex()]
        );
    }
}

void NativeCode::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    BOOST_FOREACH( Schedule &schedule, schedules )
    {
        schedule.Resolve( resolver, resolveErrors );
    }
}