source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/ObjectModule.cpp@ 508

#include <string>
#include <vector>
#include <fstream>

#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <commctrl.h>
#include <time.h>
#include <limits.h>
#include <shlobj.h>

//boost libraries
#include <boost/foreach.hpp>

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

#include "../common.h"
#include "../BasicFixed.h"


// ObjectModuleの内容をXmlで生成する場合はこの行を有効にする
//#define OBJECT_MODULE_IS_NOT_BINARY


#ifdef OBJECT_MODULE_IS_NOT_BINARY
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#else
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#endif
#include <boost/serialization/string.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/level.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/is_abstract.hpp>

#include <BoostSerializationSupport.h>

#include <abdev/ab_common/Environment.h>
#include <abdev/ab_common/include/Namespace.h>
#include <abdev/ab_common/include/NamespaceSupporter.h>

using namespace ActiveBasic::Common::Lexical;

#include <Hashmap.h>
#include <Configuration.h>
#include <Symbol.h>
#include <LexicalAnalyzer.h>
#include <Program.h>
#include <Compiler.h>
#include <Debugger.h>


void ObjectModule::StaticLink( ObjectModule &objectModule )
{
    long dataSectionBaseOffset = dataTable.GetSize();
    int sourceIndexBase = (int)sources.size();

    // メタ情報を結合
    meta.StaticLink( objectModule.meta, dataSectionBaseOffset, sourceIndexBase );

    // グローバル ネイティブコードを結合
    objectModule.globalNativeCode.ResetDataSectionBaseOffset( dataSectionBaseOffset );
    objectModule.globalNativeCode.ResetSourceIndexes( sourceIndexBase );
    globalNativeCode.PutEx( objectModule.globalNativeCode );

    // データテーブルを結合
    objectModule.dataTable.ResetDataSectionBaseOffset( dataSectionBaseOffset );
    dataTable.Add( objectModule.dataTable );

    // ソースコードを結合
    BOOST_FOREACH( const BasicSource &source, objectModule.sources )
    {
        this->sources.push_back( source );
    }

    // TODO: basbufがいらなくなったら消す
    extern char *basbuf;
    basbuf = this->sources[0].GetBuffer();
}

bool ObjectModule::Read( const std::string &filePath )
{
    // XMLとして読み込む
    bool isSuccessful = false;

    try{
#ifdef OBJECT_MODULE_IS_NOT_BINARY
        std::ifstream ifs( filePath.c_str() );
        boost::archive::xml_iarchive ia(ifs);
#else
        std::ifstream ifs( filePath.c_str(), ios::in | ios::binary );
        boost::archive::binary_iarchive ia(ifs);
#endif

        // ファイルから読込
        ia >> boost::serialization::make_nvp( RootTagName(), *this );

        isSuccessful = true;
    }
    catch( boost::archive::archive_exception e )
    {
        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
    }
    catch(...){
        MessageBox( NULL, "archive_exception以外の不明な例外", "XMLシリアライズの例外", MB_OK );
    }

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
bool ObjectModule::Write( const std::string &filePath ) const
{
    bool isSuccessful = false;

    try{
#ifdef OBJECT_MODULE_IS_NOT_BINARY
        std::ofstream ofs( filePath.c_str() );
        boost::archive::xml_oarchive oa(ofs);
#else
        std::ofstream ofs( filePath.c_str(), ios::out | ios::binary );
        boost::archive::binary_oarchive oa(ofs);
#endif

        // ファイルに書き出し
        oa << boost::serialization::make_nvp( RootTagName(), *this );

        isSuccessful = true;
    }
    catch( boost::archive::archive_exception e )
    {
        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
    }
    catch(...){
        MessageBox( NULL, "archive_exception以外の不明な例外", "XMLシリアライズの例外", MB_OK );
    }

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
bool ObjectModule::ReadString( const std::string &str )
{
    bool isSuccessful = false;

    // 入力アーカイブの作成

    try{
#ifdef OBJECT_MODULE_IS_NOT_BINARY
        std::istringstream iss( str );
        boost::archive::xml_iarchive ia(iss);
#else
        std::istringstream iss( str, ios::in | ios::binary );
        boost::archive::binary_iarchive ia(iss);
#endif

        // 文字列ストリームから読込
        ia >> boost::serialization::make_nvp( RootTagName(), *this );

        isSuccessful = true;
    }
    catch( boost::archive::archive_exception e )
    {
        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
    }
    catch(...){
        MessageBox( NULL, "archive_exception以外の不明な例外", "XMLシリアライズの例外", MB_OK );
    }

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
bool ObjectModule::WriteString( std::string &str ) const
{
    // 出力アーカイブの作成

    bool isSuccessful = false;
    try{
#ifdef OBJECT_MODULE_IS_NOT_BINARY
        std::ostringstream oss;
        boost::archive::xml_oarchive oa(oss);
#else
        std::ostringstream oss( "", ios::out | ios::binary );
        boost::archive::binary_oarchive oa(oss);
#endif

        // 文字列ストリームに書き出し
        oa << boost::serialization::make_nvp( RootTagName(), *this );

        str = oss.str();

        isSuccessful = true;
    }
    catch( boost::archive::archive_exception e )
    {
        MessageBox( NULL, e.what(), "XMLシリアライズの例外", MB_OK );
    }
    catch(...){
        MessageBox( NULL, "archive_exception以外の不明な例外", "XMLシリアライズの例外", MB_OK );
    }

    return isSuccessful;
}