source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/Delegate.cpp@ 448

#include "stdafx.h"

#include <Delegate.h>

void Delegate::RefleshParameterAndReturnType()
{
    // パラメータを解析
    params.Analyze( paramStr.c_str(), sourceIndex );

    // 動的パラメータを作る
    dynamicParams = params;
    dynamicParams.insert( dynamicParams.begin(), new Parameter( "_System_LocalThis", Type( DEF_PTR_VOID ) ) );

    if( IsFunction() )
    {
        // 戻り値を取得
        if( !compiler.StringToType( returnTypeName, returnType ) )
        {
            SetError(3,returnTypeName,sourceIndex);
        }
    }
}

bool Delegate::IsSimilar( const Delegate &dgt ) const
{
    if( this->Params().Equals( dgt.Params(), true ) )           // パラメータが等しい、もしくは反変
    {
        if( this->returnType.Equals( dgt.returnType ) )
        {
            // 戻り値が等しい
            return true;
        }
        else if( this->returnType.IsCovariant( dgt.returnType ) )
        {
            // 戻り値が共変
            return true;
        }
    }
    return false;
}

void Delegates::Collect( const BasicSource &source )
{
    int i2;
    char temporary[VN_SIZE];

    // 名前空間管理
    NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    namespaceScopes.clear();

    // Importsされた名前空間の管理
    NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
    importedNamespaces.clear();

    for( int i=0; i<source.GetLength(); i++ )
    {
        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( source[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=source[i];
            }
            namespaceScopes.push_back( temporary );

            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
            if( namespaceScopes.size() <= 0 ){
                SetError(12, "End Namespace", i );
            }
            else{
                namespaceScopes.pop_back();
            }

            i += 2;
            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( source[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=source[i];
            }
            if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
            {
                SetError(64,temporary,i );
            }

            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
            importedNamespaces.clear();
            continue;
        }

        else if( source[i] == 1 && source[i+1] == ESC_DELEGATE )
        {
            int nowLine = i;

            i += 2;
            if( !( source[i] == 1 && ( source[i+1] == ESC_SUB || source[i+1] == ESC_FUNCTION ) ) )
            {
                SetError(1,NULL,i);
                continue;
            }

            Procedure::Kind procKind = Procedure::Sub;
            if( source[i+1] == ESC_FUNCTION )
            {
                procKind = Procedure::Function;
            }
            i += 2;

            // 名前
            char name[VN_SIZE];
            GetIdentifierToken( name, source.GetBuffer(), i );

            if( source[i] != '(' )
            {
                SetError(1,NULL,nowLine);
                continue;
            }

            // パラメータ文字列
            char paramStr[8192];
            i += GetStringInPare( paramStr, source.GetBuffer() + i, true );

            // 戻り値の型の文字列
            char returnTypeName[VN_SIZE] = "";
            if( source[i] == 1 && source[i+1] == ESC_AS )
            {
                i += 2;
                GetCommandToken( returnTypeName, source.GetBuffer(), i );

                if( procKind != Procedure::Function )
                {
                    SetError(38,name,nowLine);
                }
            }
            else
            {
                if( procKind == Procedure::Function )
                {
                    SetError(-104,name,nowLine);
                    lstrcpy( returnTypeName, "Double" );
                }
            }

            this->Put( new Delegate( namespaceScopes, name, procKind, paramStr, returnTypeName, nowLine ) );
        }
    }
}

void Delegates::GenerateSourceCode( std::string &destSource )
{
    destSource = "";

    SourceTemplate sourceTemplate( "\\SubOperation\\templates\\delegate_class.tab" );

    this->Iterator_Reset();
    while( this->Iterator_HasNext() )
    {
        const Delegate &dg = *this->Iterator_GetNext();

        if( !dg.isTargetObjectModule )
        {
            // 静的リンクライブラリの場合は飛ばす（既にインスタンスが定義済みであるため）
            continue;
        }

        std::map<std::string,std::string> values;

        if( dg.GetNamespaceScopes().size() )
        {
            std::string namespaceScopesCommandStr = "";
            std::string endNamespaceScopesCommandStr = "";
            BOOST_FOREACH( const std::string &namespaceStr, dg.GetNamespaceScopes() )
            {
                if( namespaceScopesCommandStr.size() )
                {
                    namespaceScopesCommandStr += ":";
                    endNamespaceScopesCommandStr += ":";
                }
                namespaceScopesCommandStr += "Namespace " + namespaceStr;
                endNamespaceScopesCommandStr += "End Namespace";
            }

            values.insert( std::map<std::string,std::string>::value_type(
                "#namespace_begin#",
                namespaceScopesCommandStr
            ) );
            values.insert( std::map<std::string,std::string>::value_type(
                "#namespace_end#",
                endNamespaceScopesCommandStr
            ) );
        }
        else
        {
            values.insert( std::map<std::string,std::string>::value_type( "#namespace_begin#", "" ) );
            values.insert( std::map<std::string,std::string>::value_type( "#namespace_end#", "" ) );
        }

        values.insert( std::map<std::string,std::string>::value_type( "#name#", dg.GetName() ) );

        if( dg.IsFunction() )
        {
            values.insert( std::map<std::string,std::string>::value_type(
                "#call_method_begin#",
                (string)"Function Call(" + dg.paramStr + ") As " + dg.returnTypeName
            ) );

            values.insert( std::map<std::string,std::string>::value_type(
                "#call_method_end#",
                "End Function"
            ) );

            values.insert( std::map<std::string,std::string>::value_type( "#result#", "Call=" ) );
        }
        else
        {
            values.insert( std::map<std::string,std::string>::value_type(
                "#call_method_begin#",
                (string)"Sub Call(" + dg.paramStr + ")"
            ) );

            values.insert( std::map<std::string,std::string>::value_type(
                "#call_method_end#",
                "End Sub"
            ) );

            values.insert( std::map<std::string,std::string>::value_type( "#result#", "" ) );
        }

        values.insert( std::map<std::string,std::string>::value_type( "#params#", dg.paramStr ) );

        destSource += sourceTemplate.GetResult( values );
    }
/*
    ofstream ofs( ( Jenga::Common::Environment::GetAppDir() + "\\generated_delegate_code.log" ).c_str() );
    ofs << destSource;
    ofs.close();
    */
}

void Delegates::RefleshParameterAndReturnType()
{
    this->Iterator_Reset();
    while( this->Iterator_HasNext() )
    {
        Delegate &dg = *this->Iterator_GetNext();
        dg.RefleshParameterAndReturnType();
    }
}