source: dev/trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp@ 779

#include "stdafx.h"

int DataTable::AddBinary( const void *buffer, int size ){
    int retSize = this->size;

    Realloc( this->size + size );
    memcpy( (char *)this->buffer + retSize, buffer, size );

    return retSize;
}
int DataTable::Add( _int64 i64data ){
    int retSize = size;
    AddBinary( &i64data, sizeof( _int64 ) );
    return retSize;
}
int DataTable::Add( int i32data ){
    int retSize = size;
    AddBinary( &i32data, sizeof( int ) );
    return retSize;
}
int DataTable::Add( double dbl ){
    int retSize = size;
    AddBinary( &dbl, sizeof( double ) );
    return retSize;
}
int DataTable::Add( float flt ){
    int retSize = size;
    AddBinary( &flt, sizeof( float ) );
    return retSize;
}
int DataTable::AddString( const char *str )
{
    return AddBinary( str, strlen( str ) + sizeof(char) );
}
int DataTable::AddString( const std::string &str )
{
    return AddBinary( str.c_str(), static_cast<int>(str.size()) + sizeof(char) );
}
int DataTable::AddWString( const std::wstring &wstr )
{
    return AddBinary( wstr.c_str(), static_cast<int>((wstr.length()+1)*sizeof(wchar_t)));
}
int DataTable::AddSpace( int size )
{
    int retSize = this->size;
    Realloc( this->size + size );
    return retSize;
}
void DataTable::AddAlignment( int size )
{
    if( this->size % size == 0 )
    {
        // 既に境界のとき
        return;
    }
    Realloc( this->size + ( size - (int)(this->size%size) ) );
}

void DataTable::ResetDataSectionBaseOffset( long dataSectionBaseOffset )
{
    foreach( const Schedule &schedule, schedules )
    {
        if( schedule.GetType() == Schedule::DataTable )
        {
#ifdef _WIN64
            OverwriteInt64(
                schedule.GetOffset(),
                GetInt64( schedule.GetOffset() ) + dataSectionBaseOffset
            );
#else
            Overwrite(
                schedule.GetOffset(),
                GetLong( schedule.GetOffset() ) + dataSectionBaseOffset
            );
#endif
        }
    }
}

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