source: dev/trunk/ab5.0/abdev/ab_common/include/Lexical/NativeCode.h@ 829

#pragma once

class UserProc;
class DllProc;
class CClass;

class Schedule
{
public:
    enum Type
    {
        None = 10000,
        GlobalVar,      // グローバル変数スケジュール
        DataTable,      // データテーブル スケジュール
        CatchAddress,   // Catchアドレス スケジュール
        Relocation,     // リロケーション情報スケジュール
        UserProc,       // ユーザ定義関数呼び出し側スケジュール
        AddressOf,      // ユーザ定義関数位置スケジュール
        DllProc,        // DLL関数位置スケジュール
        ComVtbl,        // com_vtblスケジュール
        Vtbl,           // vtblスケジュール
        TypeInfo,       // TypeInfoスケジュール
    };

private:
    Type type;
    long offset;

    union{
        LONG_PTR lpValue;
        const ::UserProc *pUserProc;
        const ::DllProc *pDllProc;
        const ::CClass *pClass;
    };

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - Schedule" );

        ar & BOOST_SERIALIZATION_NVP( type );
        ar & BOOST_SERIALIZATION_NVP( offset );

        switch( type )
        {
        case UserProc:
        case AddressOf:
        case CatchAddress:
            ar & boost::serialization::make_nvp("pUserProc", const_cast<::UserProc *&>(pUserProc));
            break;
        case DllProc:
            ar & boost::serialization::make_nvp("pDllProc", const_cast<::DllProc *&>(pDllProc));
            break;
        case ComVtbl:
        case Vtbl:
        case TypeInfo:
            ar & boost::serialization::make_nvp("pClass", const_cast<::CClass *&>(pClass));
            break;
        default:
            ar & BOOST_SERIALIZATION_NVP( lpValue );
            break;
        }
    }

public:
    Schedule()
    {
    }
    Schedule( Type type, long offset, LONG_PTR lpValue = 0 )
        : type( type )
        , offset( offset )
        , lpValue( lpValue )
    {
    }
    Schedule( Schedule::Type type, const ::UserProc *pUserProc, long offset )
        : type( type )
        , offset( offset )
        , pUserProc( pUserProc )
    {
    }
    Schedule( const ::DllProc *pDllProc, long offset )
        : type( Schedule::DllProc )
        , offset( offset )
        , pDllProc( pDllProc )
    {
    }
    Schedule( Type type, const ::CClass *pClass, long offset )
        : type( type )
        , pClass( pClass )
        , offset( offset )
    {
        if( !( type == Schedule::ComVtbl || type == Schedule::Vtbl || type == Schedule::TypeInfo ) )
        {
            DebugBreak();
        }
    }
    Schedule(Schedule&& y)
        : type(std::move(y.type))
        , offset(std::move(y.offset))
        , lpValue(std::move(y.lpValue))
    {
    }
    Schedule(Schedule const& y)
        : type(y.type)
        , offset(y.offset)
        , lpValue(y.lpValue)
    {
    }
    Schedule& operator =(Schedule&& y)
    {
        type = std::move(y.type);
        offset = std::move(y.offset);
        lpValue = std::move(y.lpValue);
        return *this;
    }
    Schedule& operator =(Schedule const& y)
    {
        return *this = std::move(Schedule(y));
    }
    ~Schedule()
    {
    }

    Type GetType() const
    {
        return type;
    }
    long GetOffset() const
    {
        return offset;
    }
    LONG_PTR GetLongPtrValue() const
    {
        return lpValue;
    }
    const ::DllProc &GetDllProc() const;
    const ::UserProc &GetUserProc() const;
    const ::CClass &GetClass() const;

    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
};
typedef std::vector<Schedule> Schedules;

#define CODETYPE_SYSTEMPROC     0x0001
#define CODETYPE_DEBUGPROC      0x0002
class SourceLine
{
    long nativeCodePos;
    DWORD codeType;
    SourceCodePosition sourceCodePosition;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - SourceLine" );

        ar & BOOST_SERIALIZATION_NVP( nativeCodePos );
        ar & BOOST_SERIALIZATION_NVP( codeType );
        ar & BOOST_SERIALIZATION_NVP( sourceCodePosition );
    }

public:
    SourceLine( int nativeCodePos, DWORD codeType, const SourceCodePosition &sourceCodePosition )
        : nativeCodePos( nativeCodePos )
        , codeType( codeType )
        , sourceCodePosition( sourceCodePosition )
    {
    }
    SourceLine()
    {
    }
    SourceLine(SourceLine const& y)
        : nativeCodePos(y.nativeCodePos)
        , codeType(y.codeType)
        , sourceCodePosition(y.sourceCodePosition)
    {
    }
    SourceLine(SourceLine&& y)
        : nativeCodePos(std::move(y.nativeCodePos))
        , codeType(std::move(y.codeType))
        , sourceCodePosition(std::move(y.sourceCodePosition))
    {
    }
    SourceLine& operator =(SourceLine&& y)
    {
        nativeCodePos = std::move(y.nativeCodePos);
        codeType = std::move(y.codeType);
        sourceCodePosition = std::move(y.sourceCodePosition);
        return *this;
    }
    SourceLine& operator =(SourceLine const& y)
    {
        return *this = std::move(SourceLine(y));
    }

    long GetNativeCodePos() const
    {
        return nativeCodePos;
    }
    DWORD GetCodeType() const
    {
        return codeType;
    }
    const SourceCodePosition &GetSourceCodePosition() const
    {
        return sourceCodePosition;
    }
    SourceCodePosition &GetSourceCodePosition()
    {
        return sourceCodePosition;
    }
    void SetSourceCodePosition( const SourceCodePosition &sourceCodePosition )
    {
        this->sourceCodePosition = sourceCodePosition;
    }
    bool IsInSystemProc() const
    {
        return ( (codeType&CODETYPE_SYSTEMPROC) != 0 );
    }
    bool IsInDebugProc() const
    {
        return ( (codeType&CODETYPE_DEBUGPROC) != 0 );
    }
};
typedef std::vector<SourceLine> SourceLines;

class NativeCode : public Jenga::Common::Binary
{
    // リンカで解決しなければならないスケジュール
    Schedules schedules;

    // ソースコード行番号とネイティブコード位置の対応情報
    SourceLines sourceLines;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing(load) - NativeCode" );

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Jenga::Common::Binary );
        ar & BOOST_SERIALIZATION_NVP( schedules );
        ar & BOOST_SERIALIZATION_NVP( sourceLines );
    }

public:
    NativeCode()
        : Jenga::Common::Binary()
    {
    }
    NativeCode( const NativeCode &nativeCode )
        : Jenga::Common::Binary()
    {
        PutEx( nativeCode );
    }
    NativeCode( const char *codeBuffer, int size )
        : Jenga::Common::Binary( codeBuffer, size )
    {
    }
    ~NativeCode()
    {
    }

    void operator =( const NativeCode &nativeCode )
    {
        Clear();
        PutEx( nativeCode );
    }

    const Schedules &GetSchedules() const
    {
        return schedules;
    }

    void PutEx( const NativeCode &nativeCode );
    void PutEx( long l, Schedule::Type scheduleType );
    void PutUserProcSchedule( const UserProc *pUserProc, bool isCall );
    void PutCatchAddressSchedule( const UserProc *pUserProc, long codePos );
    void PutDllProcSchedule( const DllProc *pDllProc );
    void PutComVtblSchedule( const CClass *pClass );
    void PutVtblSchedule( const CClass *pClass );

    const SourceLines &GetSourceLines() const
    {
        return sourceLines;
    }
    void NextSourceLine( const SourceCodePosition &sourceCodePosition, bool isInSystemProc );

    void ResetDataSectionBaseOffset( long dataSectionBaseOffset );
    void ResetRelationalObjectModuleIndex( const std::vector<int> &relationTable );

    void Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
};