source: dev/trunk/abdev/BasicCompiler_Common/src/Delegate.cpp@ 420

#include "stdafx.h"

#include <Delegate.h>

Delegate::Delegate( const NamespaceScopes &namespaceScopes, const std::string &name, Procedure::Kind procKind, const char *paramStr, const Type &returnType, int nowLine )
    : Procedure( namespaceScopes, name, procKind, false )
{
    this->returnType = returnType;
    params.Analyze( paramStr, nowLine );

    dynamicParams = params;
    dynamicParams.insert( dynamicParams.begin(), new Parameter( "_System_LocalThis", Type( DEF_PTR_VOID ) ) );
}

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 );

            char paramStr[8192];
            i += GetStringInPare( paramStr, source.GetBuffer() + i );

            // 戻り値
            Type returnType;
            if( source[i] == 1 && source[i+1] == ESC_AS )
            {
                i += 2;
                char typeName[VN_SIZE];
                GetCommandToken( typeName, source.GetBuffer(), i );
                compiler.StringToType( typeName, returnType );
            }

            this->Put( new Delegate( namespaceScopes, name, procKind, paramStr, returnType, 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();

        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() ) );

        std::string paramsStr = dg.Params().GetString();

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

            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(" + paramsStr + ")"
            ) );

            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#", paramsStr ) );

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