source: dev/trunk/abdev/BasicCompiler_Common/include/NativeCode.h@ 260

#pragma once

#include <vector>

#include <jenga/include/common/Exception.h>

#include <BoostSerializationSupport.h>

void ObpPlus( int step = 1 );

class UserProc;

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

private:
    Type type;
    long offset;

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

    // 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 );
    }

public:
    Schedule()
    {
    }
    Schedule( Type type, long offset, LONG_PTR lpValue = 0 )
        : type( type )
        , offset( offset )
        , lpValue( lpValue )
    {
    }
    Schedule( const ::UserProc *pUserProc, long offset )
        : type( Schedule::UserProc )
        , offset( offset )
        , pUserProc( pUserProc )
    {
    }
    Schedule( const ::DllProc *pDllProc, long offset )
        : type( Schedule::DllProc )
        , offset( offset )
        , pDllProc( pDllProc )
    {
    }
    ~Schedule()
    {
    }

    Type GetType() const
    {
        return type;
    }
    long GetOffset() const
    {
        return offset;
    }
    LONG_PTR GetLongPtrValue() const
    {
        return lpValue;
    }
    const ::DllProc &GetDllProc() const
    {
        if( type != Schedule::DllProc )
        {
            SetError();
        }
        return *pDllProc;
    }
    const ::UserProc &GetUserProc() const
    {
        if( !( type == Schedule::UserProc || type == Schedule::AddressOf ) )
        {
            SetError();
        }
        return *pUserProc;
    }

    void SpecifyAddressOf()
    {
        if( type != Schedule::UserProc )
        {
            SetError();
        }
        type = Schedule::AddressOf;
    }
};
typedef std::vector<Schedule> Schedules;

class NativeCode
{
    int allocateSize;
    char *codeBuffer;
    int size;

    Schedules schedules;

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

        std::string code;
        ar & BOOST_SERIALIZATION_NVP( code );
        ar & BOOST_SERIALIZATION_NVP( size );
        ar & BOOST_SERIALIZATION_NVP( schedules );

        // 読み込み後の処理
        Realloc( size );
        for( int i=0; i<size; i++ )
        {
            ULONG_PTR l;
            sscanf( code.c_str() + i*3, "%02x,", &l );
            codeBuffer[i] = (char)l;
        }
    }
    template<class Archive> void save(Archive& ar, const unsigned int version) const
    {
        trace_for_serialize( "serializing(save) - NativeCode" );

        // 保存準備
        char *tempCode = (char *)calloc( (size+1) * 3, 1 );
        for( int i=0; i<size; i++ )
        {
            char temp[32];
            sprintf( temp, "%02x,", (unsigned char)codeBuffer[i] );
            tempCode[i*3] = temp[0];
            tempCode[i*3+1] = temp[1];
            tempCode[i*3+2] = temp[2];
        }

        std::string code = tempCode;
        free( tempCode );

        ar & BOOST_SERIALIZATION_NVP( code );
        ar & BOOST_SERIALIZATION_NVP( size );
        ar & BOOST_SERIALIZATION_NVP( schedules );
    }


    void Realloc( int newSize )
    {
        if( allocateSize < newSize + 8192 )
        {
            while( allocateSize < newSize + 8192 )
            {
                allocateSize += 8192;
            }
            codeBuffer = (char *)realloc( codeBuffer, allocateSize );
        }
    }

public:
    NativeCode()
        : allocateSize( 8192 )
        , codeBuffer( (char *)malloc( allocateSize ) )
        , size( 0 )
    {
    }
    NativeCode( const NativeCode &nativeCode, bool isOpBuffer )
        : allocateSize( 8192 )
        , codeBuffer( (char *)malloc( allocateSize ) )
        , size( 0 )
    {
        Put( nativeCode, isOpBuffer );
    }
    NativeCode( const char *codeBuffer, int size )
        : allocateSize( 8192 )
        , codeBuffer( (char *)malloc( allocateSize ) )
        , size( 0 )
    {
        Put( codeBuffer, size );
    }
    ~NativeCode()
    {
        free( codeBuffer );
    }
    void Clear()
    {
        size = 0;
    }

    void operator =( const NativeCode &nativeCode )
    {
        Clear();
        Put( nativeCode, false );
    }

    int GetSize() const
    {
        return size;
    }
    const Schedules &GetSchedules() const
    {
        return schedules;
    }

    long GetLong( int codePos ) const
    {
        return *(long *)(this->codeBuffer+codePos);
    }
    long _GetLong_ObpOld( int _obpOld ) const
    {
        extern char *OpBuffer;
        return *(long *)(OpBuffer+_obpOld);
    }

    void Overwrite( int codePos, char c )
    {
        codeBuffer[codePos] = c;
    }
    void OverwriteOld( int _obpOld, char c )
    {
        // 未完成
        extern char *OpBuffer;
        OpBuffer[_obpOld] = c;
    }
    void Overwrite( int codePos, long newLongValue )
    {
        *(long *)(this->codeBuffer+codePos) = newLongValue;
    }
    void OverwriteOld( int _obpOld, long newLongValue )
    {
        // 未完成
        extern char *OpBuffer;
        *(long *)(OpBuffer+_obpOld) = newLongValue;
    }

    void Put( const char *codeBuffer, int size, bool isOpBuffer = true )
    {
        Realloc( this->size + size );

        memcpy( this->codeBuffer + this->size, codeBuffer, size );
        this->size += size;

        // 未完成
        if( isOpBuffer )
        {
            extern char *OpBuffer;
            extern int obp;
            memcpy( OpBuffer + obp, codeBuffer, size );
            ObpPlus( size );
        }
    }
    void Put( const NativeCode &nativeCode, bool isOpBuffer );
    void Put( _int64 i64data )
    {
        Put( (const char *)(&i64data), sizeof(_int64) );
    }
    void Put( long l, Schedule::Type scheduleType = Schedule::None )
    {
        if( scheduleType != Schedule::None )
        {
            schedules.push_back( Schedule( scheduleType, size ) );
        }

        *((long *)(codeBuffer+size))=l;
        size += sizeof(long);



        // 未完成
        switch( scheduleType )
        {
        case Schedule::None:
            // 何もしない
            break;
        case Schedule::GlobalVar:
            extern CSchedule *pobj_GlobalVarSchedule;
            pobj_GlobalVarSchedule->add();
            break;
        case Schedule::DataTable:
            extern CSchedule *pobj_DataTableSchedule;
            pobj_DataTableSchedule->add();
            break;
        case Schedule::Relocation:
            // 未完成
            break;
        default:
            Jenga::Throw( "scheduleTypeが無効な値を保持している" );
            break;
        }
        extern char *OpBuffer;
        extern int obp;
        *((long *)(OpBuffer+obp))=l;
        ObpPlus( sizeof(long) );
    }
    void PutUserProcSchedule( const UserProc *pUserProc, bool isCall );
    void PutDllProcSchedule( const DllProc *pDllProc );
    void Put( short s )
    {
        Put( (const char *)(&s), sizeof(short) );
    }
    void Put( char c )
    {
        Realloc( size + 1 );
        codeBuffer[size++] = c;



        // 未完成
        extern char *OpBuffer;
        extern int obp;
        OpBuffer[obp]=c;
        ObpPlus();
    }
};