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

#pragma once

#include <vector>

#include <BoostSerializationSupport.h>

class Schedule
{
public:
    enum Type
    {
        None,
        GlobalVar,      // グローバル変数スケジュール
        LocalVar,       // ローカル変数スケジュール
        Relocation,     // リロケーション情報スケジュール
    };

private:
    Type type;
    int offset;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        ar & BOOST_SERIALIZATION_NVP( type );
        ar & BOOST_SERIALIZATION_NVP( offset );
    }

public:
    Schedule()
    {
    }
    Schedule( Type type, int offset )
        : type( type )
        , offset( offset )
    {
    }
    ~Schedule()
    {
    }
};
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)
    {
        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++ )
        {
            char c;
            sscanf( code.c_str() + i*3, "%02x,", &c );
            codeBuffer[i] = c;
        }
    }
    template<class Archive> void save(Archive& ar, const unsigned int version) const
    {
        // 保存準備
        char *tempCode = (char *)malloc( (size+1) * 3 );
        for( int i=0; i<size; i++ )
        {
            char temp[32];
            sprintf( temp, "%02x,", 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 additionSize = 0 )
    {
        if( allocateSize < size + 8192 + additionSize )
        {
            while( allocateSize < size + 8192 + additionSize )
            {
                allocateSize += 8192;
            }
            codeBuffer = (char *)realloc( codeBuffer, allocateSize );
        }
    }

public:
    NativeCode()
        : allocateSize( 8192 )
        , codeBuffer( (char *)malloc( allocateSize ) )
        , size( 0 )
    {
    }
    ~NativeCode()
    {
        free( codeBuffer );
    }
    void Clear()
    {
        size = 0;
    }

    void Put( const char *codeBuffer, int size )
    {
        Realloc( size );

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

        // 未完成
        extern char *OpBuffer;
        extern int obp;
        memcpy( OpBuffer + obp, codeBuffer, size );
        obp += size;
    }
    void Put( const NativeCode &nativeCode )
    {
        Put( nativeCode.codeBuffer, nativeCode.size );
    }
    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);



        // 未完成
        extern char *OpBuffer;
        extern int obp;
        *((long *)(OpBuffer+obp))=l;
        obp+=sizeof(long);
    }
    void Put( short s )
    {
        Put( (const char *)(&s), sizeof(short) );
    }
    void Put( char c )
    {
        codeBuffer[size++] = c;
        Realloc();



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