source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/DataTableGenerator.cpp @ 745

#include "stdafx.h"

using namespace ActiveBasic::Compiler;

int DataTableGenerator::lastMadeConstObjectDataTableOffset = 0;

bool DataTableGenerator::MakeConstObjectToProcessStaticBuffer( DataTable &dataTable, const CClass &objClass, const Jenga::Common::Strings &initMemberValues, int &dataTableOffset )
{
    // クラスに必要なバッファサイズを取得
    int size = objClass.GetSize();

    // クラスのバッファイメージを作成
    BYTE *buffer = (BYTE *)calloc( size, 1 );

    // クラスのバッファイメージをデータ領域へ追加
    dataTableOffset = dataTable.AddBinary( buffer, size );

    DataTableGenerator::lastMadeConstObjectDataTableOffset = dataTableOffset;

    // com_vtblスケジュール
    dataTable.schedules.push_back( Schedule( Schedule::ComVtbl, &objClass, dataTableOffset ) );

    // vtblスケジュール
    dataTable.schedules.push_back( Schedule( Schedule::Vtbl, &objClass, dataTableOffset + PTR_SIZE ) );

    // TypeInfoスケジュール
    int offsetForTypeInfo = objClass.GetMemberOffset( "_system_object_member_typeInfo" );
    //dataTable.schedules.push_back( Schedule( Schedule::TypeInfo, &objClass, dataTableOffset + offsetForTypeInfo ) );

    BOOST_FOREACH( const std::string &initMemberValue, initMemberValues )
    {
        int i = 0;

        // メンバ名
        char memberName[VN_SIZE];
        for( i=0; ; i++ )
        {
            if( initMemberValue[i] == '\0' )
            {
                // エラー
                compiler.errorMessenger.OutputFatalError();
                return false;
            }
            if( initMemberValue[i] == '=' )
            {
                memberName[i] = 0;
                break;
            }
            memberName[i] = initMemberValue[i];
        }

        // 初期値
        const char *initValue = initMemberValue.c_str() + i + 1;

        // メンバを取得
        const Member *member = objClass.FindDynamicMember( memberName );

        // メンバオフセットを取得
        int memberOffset = objClass.GetMemberOffset( member->GetName().c_str() );

        if( member->GetType().IsPointer() && initValue[0] == '[' )
        {
            // ポインタ型でバッファ指定のとき
            int memberDataTableOffset;
            if( !MakeLiteralArrayBuffer( dataTable, initValue, member->GetType(),memberDataTableOffset ) )
            {
                return false;
            }

            dataTable.Overwrite( dataTableOffset + memberOffset, memberDataTableOffset );
            dataTable.schedules.push_back( Schedule( Schedule::DataTable, dataTableOffset + memberOffset ) );
        }
        else if( member->GetType().IsWhole() )
        {
            // 整数
            Type resultType;
            _int64 i64data;
            if( !StaticCalculation( true, initValue, member->GetType().GetBasicType(), &i64data, resultType ) ){
                return false;
            }

            dataTable.Overwrite( dataTableOffset + memberOffset, static_cast<long>(i64data) );
        }
        else if( member->GetType().IsStringClass() )
        {
            // 文字列型
            char temporary[VN_SIZE];
            lstrcpy( temporary, initValue );
            RemoveStringQuotes( temporary );
            int memberDataTableOffset = MakeConstStringObjectToProcessStaticBuffer( dataTable, temporary );
            dataTable.Overwrite( dataTableOffset + memberOffset, memberDataTableOffset );
            dataTable.schedules.push_back( Schedule( Schedule::DataTable, dataTableOffset + memberOffset ) );
        }
    }

    return true;
}
bool DataTableGenerator::MakeConstObjectToProcessStaticBuffer( DataTable &dataTable, const char *expression, Type &resultType, int &dataTableOffset )
{
    char CreateParameter[VN_SIZE];
    int i,i2;

    i=0;

    // クラス名を取得
    char typeName[VN_SIZE];
    for(i2=0;;i++,i2++){
        if(expression[i]=='['){
            typeName[i2]=0;

            // メンバの初期値を取得
            i2=GetStringInBracket(CreateParameter,expression+i);
            RemoveStringBracket(CreateParameter);
            i+=i2;
            if(expression[i]!='\0'){
                compiler.errorMessenger.Output(42,NULL,cp);
                return false;
            }
            break;
        }
        typeName[i2]=expression[i];
        if(expression[i]=='\0'){
            CreateParameter[0]=0;
            break;
        }
    }

    // パラメータを取得
    Jenga::Common::Strings initMemberValues;
    SplitParameter( CreateParameter, initMemberValues );

    if( !compiler.StringToType( typeName, resultType ) ){
        compiler.errorMessenger.Output(3,typeName,cp);
        return false;
    }

    if( !resultType.IsObject() ){
        ////////////////////////
        // 通常のデータ型の場合
        ////////////////////////

        compiler.errorMessenger.Output(121,NULL,cp);
        return false;
    }

    return MakeConstObjectToProcessStaticBuffer( dataTable, resultType.GetClass(), initMemberValues, dataTableOffset );
}

int DataTableGenerator::MakeConstStringObjectToProcessStaticBuffer( DataTable &dataTable, const char *str )
{
    const CClass &strClass = *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
    const CClass &objClass = strClass.GetSuperClass();

    // クラスに必要なバッファサイズを取得
    int size = strClass.GetSize();

    // メンバ位置を取得
    int offsetForTypeInfo = strClass.GetMemberOffset( "_system_object_member_typeInfo" );
    int offsetForLength = strClass.GetMemberOffset( "m_Length" );
    int offsetForChars = strClass.GetMemberOffset( "Chars" );

    // 現在のデータ領域のヘッダ位置を取得
    int headOffset = dataTable.GetSize();

    // クラスのバッファイメージを作成
    BYTE *buffer = (BYTE *)calloc( size, 1 );
    *(long *)(buffer + offsetForLength) = lstrlen( str );
    *(LONG_PTR *)(buffer + offsetForChars) = headOffset + size;

    // クラスのバッファイメージをデータ領域へ追加
    int dataTableOffset = dataTable.AddBinary( buffer, size );

    // スケジューリング
    dataTable.schedules.push_back( Schedule( Schedule::ComVtbl, &strClass, headOffset ) );
    dataTable.schedules.push_back( Schedule( Schedule::Vtbl, &strClass, headOffset + PTR_SIZE ) );
    dataTable.schedules.push_back( Schedule( Schedule::TypeInfo, &strClass, headOffset + offsetForTypeInfo ) );
    dataTable.schedules.push_back( Schedule( Schedule::DataTable, headOffset + offsetForChars ) );

    // 文字列バッファをデータ領域へ追加
    compiler.AddStringToDataTable( str );

    return dataTableOffset;
}

bool DataTableGenerator::MakeLiteralArrayBuffer( DataTable &dataTable, const char *expression, const Type &baseType, int &dataTableOffset )
{
    if( !baseType.IsPointer() ){
        compiler.errorMessenger.Output(1,NULL,cp);
        return false;
    }
    Type tempBaseType( baseType );
    tempBaseType.PtrLevelDown();

    char *buffer = (char *)malloc( lstrlen( expression ) + 1 );
    lstrcpy( buffer, expression );
    RemoveStringBracket( buffer );

    Jenga::Common::Strings parameters;
    SplitParameter( buffer, parameters );

    // アラインメント
    dataTable.AddAlignment( tempBaseType.GetSize() );

    // データテーブルに空間を確保
    dataTableOffset = dataTable.AddSpace( static_cast<int>(tempBaseType.GetSize() * parameters.size()) );

    bool isSuccessful = true;
    int i = 0;
    BOOST_FOREACH( const std::string &paramStr, parameters )
    {
        if( paramStr.size() == 0 )
        {
            throw;
        }
        if( paramStr[0] == '\"' )
        {
            // 文字列
            std::string tempParamStr = paramStr;
            if( !RemoveStringQuotes( tempParamStr ) )
            {
                compiler.errorMessenger.OutputFatalError();
            }

            // 文字列を追加
            _int64 strOffset;
            if( tempBaseType.IsStringClass() )
            {
                // Stringクラス
                strOffset = MakeConstStringObjectToProcessStaticBuffer( dataTable, tempParamStr.c_str() );
            }
            else
            {
                // Charポインタ
                strOffset = compiler.AddStringToDataTable( tempParamStr );
            }

            // ポインタ値を上書き
            int tempOffset = dataTableOffset + i * tempBaseType.GetSize();
            dataTable.OverwriteBinary( tempOffset, &strOffset, tempBaseType.GetSize() );

            // DataTableスケジュール
            dataTable.schedules.push_back( Schedule( Schedule::DataTable, tempOffset  ) );
        }
        else
        {
            // 数値
            Type resultType;
            _int64 i64data;
            if( !StaticCalculation( true, paramStr.c_str(), tempBaseType.GetBasicType(), &i64data, resultType ) ){
                isSuccessful = false;
                break;
            }
            if( !resultType.IsWhole() ){
                // TODO: 実数に未対応
                compiler.errorMessenger.OutputFatalError();
                isSuccessful = false;
                break;
            }

            // 上書き
            dataTable.OverwriteBinary( dataTableOffset + i * tempBaseType.GetSize(), &i64data, tempBaseType.GetSize() );
        }

        i++;
    }

    free( buffer );

    return isSuccessful;
}