source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/Compiler.cpp@ 750

#include "stdafx.h"

using namespace ActiveBasic::Compiler;

Compiler compiler;

Compiler::Compiler()
    : isBuildSuccessful( false )
    , targetModuleType( ActiveBasic::Common::TargetModuleType::Exe )
    , isDebug( false )
    , isUnicode( false )
    , isCore( false )
    , currentRelationalObjectModuleIndexForSource( 0 )
{
    // 生成先のオブジェクトモジュールを登録
    ObjectModule *pObjectModule = new ObjectModule();
    staticLibraries.push_back( pObjectModule );
    SelectObjectModule( pObjectModule );

    namespaceSupporter.RegistAllNamespaceScopesCollection( &GetObjectModule().meta.GetNamespaces() );

    Symbol::RegistNamespaceSupporter( &namespaceSupporter );
}
Compiler::~Compiler()
{
    foreach( ObjectModule *pStaticLibrary, staticLibraries )
    {
        delete pStaticLibrary;
    }
    staticLibraries.clear();
}

void Compiler::PreStaticLink( const ObjectModules &staticLibraries )
{
    foreach( const ObjectModule *pStaticLibrary, staticLibraries )
    {
        // 関連オブジェクトモジュールの名前リスト
        this->GetObjectModule().relationalObjectModuleNames.push_back( pStaticLibrary->GetName() );
    }
}
void Compiler::StaticLink( ObjectModules &staticLibraries )
{
    foreach( ObjectModule *pStaticLibrary, staticLibraries )
    {
        if( &this->GetObjectModule() == pStaticLibrary )
        {
            // 自分自身の場合はリンクしない
            continue;
        }

        // メタ情報
        this->GetObjectModule().StaticLink( *pStaticLibrary, this->IsSll() );
    }
}

const std::string &Compiler::GetGlobalAreaProcName() const
{
    static std::string globalAreaProcName;

    if( globalAreaProcName.empty() )
    {
        // 初期化
        _ASSERTE( !this->GetModuleName().empty() );

        std::string originalName = this->GetModuleName();

        // モジュール名がシンボル名として使えない場合があるので、16進数文字列に変換する
        char temporary[VN_SIZE*2] = "";
        for( int i=0; i<static_cast<int>(originalName.size()); i++ )
        {
            sprintf( temporary + strlen(temporary), "%2x", originalName[i] );
        }

        globalAreaProcName = (std::string)"_GlobalArea_" + temporary;
    }

    return globalAreaProcName;
}

int Compiler::AddStringToDataTable( const std::string &text )
{
    if( this->IsUnicode() )
    {
        return this->GetObjectModule().dataTable.AddWString( Jenga::Common::ToWString( text ) );
    }
    else
    {
        return this->GetObjectModule().dataTable.AddString( text );
    }
}

ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType Compiler::StringToGenericTypeEx( const std::string &typeName, Type &type )
{
    // ジェネリッククラスをインスタンス化した型の場合
    int i = 0;
    char className[VN_SIZE];
    GetIdentifierToken( className, typeName.c_str(), i );

    // ジェネリクスクラスを取得
    const CClass *pGenericClass = this->GetObjectModule().meta.FindClassSupportedTypeDef( 
        LexicalAnalyzer::FullNameToSymbol( className )
    );

    if( !pGenericClass )
    {
        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::NotfoundGenericClass;
    }

    if( typeName[i] != '<' )
    {
        Jenga::Throw( "StringToType内でジェネリクス構文の解析に失敗" );
    }

    GenericTypes genericTypes;
    bool isValueType = false;
    while( true )
    {
        i++;

        char typeParameterStr[VN_SIZE];
        GetIdentifierToken( typeParameterStr, typeName.c_str(), i );

        // 型パラメータの型情報を取得
        Type typeParameterType;
        StringToType( typeParameterStr, typeParameterType );

        if( this->IsCompilingClass() )
        {
            if( this->pCompilingClass->IsExpanded() && typeParameterType.IsTypeParameter() )
            {
                // 現在コンパイル中のクラスがテンプレート展開済みのクラスで、
                // 尚且つターゲットとなる型が型パラメータだったとき

                // テンプレート展開情報を用いて型解決を行う
                this->pCompilingClass->ResolveExpandedClassActualTypeParameter( typeParameterType );
            }
        }

        genericTypes.push_back( GenericType( "(non support)", typeParameterType ) );

        if( typeParameterType.IsValueType() )
        {
            // 値型の場合
            isValueType = true;
        }

        if( typeName[i] != ',' )
        {
            break;
        }
    }

    // 基本型をセット
    type.SetBasicType( DEF_OBJECT );

    if( isValueType )
    {
        // 型パラメータに値型が指定された場合

        // 仮型パラメータを実型パラメータに変換
        Types actualTypes;
        foreach( const GenericType &genericType, genericTypes )
        {
            actualTypes.push_back( genericType.GetType() );
        }

        // テンプレートとしてクラスを展開する
        const CClass *pExpandedClass = LexicalAnalyzer::TemplateExpand( *const_cast<CClass *>(pGenericClass), actualTypes );

        if( pExpandedClass )
        {
            // 拡張情報をセット
            type.SetClassPtr( pExpandedClass );
        }
        else
        {
            // TODO: 消す
            goto Generic;
        }
    }
    else
    {
Generic:
        // 型パラメータにクラス型が指定された場合

        // ジェネリック クラスとして利用する

        // 拡張情報をセット
        type.SetClassPtr( pGenericClass );
        type.SetActualGenericTypes( genericTypes );
    }

    return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
}
ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType Compiler::StringToTypeEx( const std::string &typeName, Type &type, bool isResolveGenerics )
{
    type.SetIndex( -1 );


    /////////////////////////////////////////////////////////
    // ☆★☆ ジェネリクスサポート ☆★☆

    if( strstr( typeName.c_str(), "<" ) )
    {
        return StringToGenericTypeEx( typeName, type );
    }

    //
    /////////////////////////////////////////////////////////


    if( typeName[0] == '*' ){
        if( typeName.size() >= 3
            && typeName[1] == 1 && ( typeName[2] == ESC_FUNCTION || typeName[2] == ESC_SUB ) )
        {
            // 関数ポインタを追加する
            {
                DWORD dwProcType = (DWORD)typeName[2];
                const std::string &paramStr = typeName.substr( 3 );

                Procedure::Kind kind = ( dwProcType == ESC_FUNCTION )
                    ? Procedure::Function
                    : Procedure::Sub;

                ProcPointer *pProcPointer = new ProcPointer( kind );

                //buffer[0]は'('となっている
                extern int cp;
                ActiveBasic::Compiler::LexicalAnalyzer::SetParamsAndReturnType( pProcPointer, paramStr.c_str(), false, cp );

                this->GetObjectModule().meta.GetProcPointers().push_back( pProcPointer );
            }

            //関数ポインタ（*Function）
            type.SetBasicType( DEF_PTR_PROC );
            type.SetIndex( this->GetObjectModule().meta.GetProcPointers().size() - 1 );
            return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
        }

        const std::string &nextTypeName = typeName.substr( 1 );

        ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType result = StringToTypeEx( nextTypeName, type, isResolveGenerics );
        if( result != ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful )
        {
            return result;
        }

        type.PtrLevelUp();

        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
    }

    {
        int basicType;
        if( Type::StringToBasicType( typeName, basicType ) )
        {
            // 基本型だったとき
            type.SetBasicType( basicType );
            return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
        }
    }

    // Object型だったとき
    if( typeName == "Object" )
    {
        type.SetType( DEF_OBJECT, this->GetObjectModule().meta.GetClasses().GetObjectClassPtr() );
        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
    }

    // String型だったとき
    if( typeName == "String" )
    {
        type.SetType( DEF_OBJECT, this->GetObjectModule().meta.GetClasses().GetStringClassPtr() );
        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
    }


    ////////////////////
    // TypeDefされた型
    ////////////////////
    const TypeDef *pTypeDef = this->GetObjectModule().meta.GetTypeDefs().Find( LexicalAnalyzer::FullNameToSymbol( typeName ) );
    if( pTypeDef )
    {
        type = pTypeDef->GetBaseType();

        if( type.IsObject() )
        {
            if( isResolveGenerics && type.GetClass().IsGeneric() && !type.HasActualGenericType() )
            {
                // ジェネリッククラスの場合
                trace( "型解決されていない" );
                return ActiveBasic::Compiler::Error::StringToTypeErrorCode::FailedResolveGenericType;
            }
        }

        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
    }

    //クラス
    const CClass *pobj_c = this->GetObjectModule().meta.FindClassSupportedTypeDef( LexicalAnalyzer::FullNameToSymbol( typeName ) );
    if(pobj_c)
    {
        if( isResolveGenerics && pobj_c->IsGeneric() )
        {
            // ジェネリッククラスの場合
            trace( "型解決されていない" );
            return ActiveBasic::Compiler::Error::StringToTypeErrorCode::FailedResolveGenericType;
        }

        if( pobj_c->IsStructure() )
        {
            type.SetBasicType( DEF_STRUCT );
        }
        else
        {
            type.SetBasicType( DEF_OBJECT );
        }
        type.SetClassPtr( pobj_c );
        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
    }


    /////////////////////////////////////////////////////////
    // ☆★☆ ジェネリクスサポート ☆★☆

    // 型パラメータ
    if( this->IsCompilingClass() )
    {
        // クラスに属するメソッドをコンパイルしているとき
        int formalTypeIndex = this->GetCompilingClass().GetFormalGenericTypeParameterIndex( typeName );
        if( formalTypeIndex != -1 )
        {
            // コンパイル中クラスにおけるジェネリクス用の型パラメータのとき
            type.SetBasicType( DEF_TYPE_PARAMETER );
            type.SetClassPtr( &this->GetCompilingClass().GetFormalGenericTypes()[formalTypeIndex].GetType().GetClass() );
            type.SetFormalTypeName( typeName );
            type.SetFormalTypeIndex( formalTypeIndex );
            return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
        }
    }

    //
    /////////////////////////////////////////////////////////

    return ActiveBasic::Compiler::Error::StringToTypeErrorCode::NotfoundType;
}

bool Compiler::StringToType( const std::string &typeName, Type &type )
{
    return ( StringToTypeEx( typeName, type, false ) == ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful );
}

const std::string Compiler::TypeToString( const Type &type )
{
    if( PTR_LEVEL( type.GetBasicType() ) ){
        //ポインタレベルが1以上の場合
        Type tempType( type );
        tempType.PtrLevelDown();

        return '*' + TypeToString( tempType );
    }
    else if( type.IsObject() || type.IsStruct() )
    {
        //オブジェクトまたは構造体

        if( !( type.GetIndex() == 0 || type.GetIndex() == -1 ) )
        {
            std::string result = type.GetClass().GetName();
            if( type.GetClass().GetNamespaceScopes().size() >= 1 )
            {
                result = type.GetClass().GetNamespaceScopes().ToString()
                    + "."
                    + result;
            }

            if( type.GetClass().IsExpanded() )
            {
                // テンプレート展開済みのクラスの場合
                std::string actualGenericTypesName;
                foreach( const Type &typeParameter, type.GetClass().expandedClassActualTypeParameters )
                {
                    if( actualGenericTypesName.size() )
                    {
                        actualGenericTypesName += ',';
                    }
                    actualGenericTypesName += typeParameter.ToString();
                }

                result += '<' + actualGenericTypesName + '>';
            }

            return result;
        }
    }
    else if( type.IsProcPtr() ){
        if( type.GetIndex() == 0 || type.GetIndex() == -1 ){
            return "VoidPtr";
        }
        else{
            if( this->GetObjectModule().meta.GetProcPointers()[type.GetIndex()]->ReturnType().IsNull() ){
                return "*Sub";
            }
            return "*Function";
        }
    }
    else{
        // 基本型
        const char *lpszTypeName = Type::BasicTypeToCharPtr( type );
        if( lpszTypeName )
        {
            return (const std::string)lpszTypeName;
        }
    }

    compiler.errorMessenger.Output(1, NULL, cp);

    return (std::string)"(null)";
}

int Compiler::SizeOf( const Type &type )
{
    Type tempType( type );
    if( this->IsCompilingClass() )
    {
        if( this->pCompilingClass->IsExpanded() && tempType.IsTypeParameter() )
        {
            // 現在コンパイル中のクラスがテンプレート展開済みのクラスで、
            // 尚且つターゲットとなる型が型パラメータだったとき

            // テンプレート展開情報を用いて型解決を行う
            this->pCompilingClass->ResolveExpandedClassActualTypeParameter( tempType );
        }
    }
    return tempType.GetSize();
}

void Compiler::ClearCompilingUserProcAndClass()
{
    this->pCompilingUserProc = NULL;
    this->pCompilingClass = NULL;
}

void Compiler::SetCompilingClass( const CClass *pClass )
{
    this->pCompilingClass = pClass;
}

void Compiler::SetCompilingUserProc( const UserProc *pUserProc )
{
    this->pCompilingUserProc = pUserProc;

    this->SetCompilingClass( pUserProc->GetParentClassPtr() );
}

void Compiler::StartGlobalAreaCompile()
{
    ClearCompilingUserProcAndClass();
}

void Compiler::StartProcedureCompile( const UserProc *pUserProc )
{
    //コンパイル中の関数
    this->SetCompilingUserProc( pUserProc );

    if( pUserProc->HasParentClass() )
    {
        // クラスの使用チェック
        pUserProc->GetParentClass().Using();
    }

    // コンパイル中の関数が属する名前空間
    this->GetNamespaceSupporter().SetLivingNamespaceScopes( pUserProc->GetNamespaceScopes() );

    // コンパイル中の関数でImportsされている名前空間
    this->GetNamespaceSupporter().SetImportedNamespaces( pUserProc->GetImportedNamespaces() );

    // コード生成対象を選択
    this->codeGenerator.Select( (const_cast<UserProc *>(pUserProc))->GetNativeCode() );
}
void Compiler::FinishProcedureCompile()
{
    this->pCompilingUserProc = NULL;
    this->pCompilingClass = NULL;
}

bool Compiler::IsGlobalAreaCompiling()
{
    if( pCompilingUserProc == NULL )
    {
        return true;
    }
    return ( pCompilingUserProc->GetName() == this->GetGlobalAreaProcName() );
}
bool Compiler::IsLocalAreaCompiling()
{
    return !IsGlobalAreaCompiling();
}
const UserProc &Compiler::GetCompilingUserProc()
{
    if( pCompilingUserProc == NULL )
    {
        _ASSERTE( false );
        throw;
    }
    return *pCompilingUserProc;
}

bool Compiler::IsCompilingClass()
{
    return ( pCompilingClass != NULL );
}
const CClass &Compiler::GetCompilingClass()
{
    if( this->IsCompilingClass() )
    {
        return *pCompilingClass;
    }

    throw;
}