source: dev/trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp

#include "stdafx.h"
#include <jenga/include/jenga.h>
#include <abdev/ab_common/include/ab_common.h>


void Procedure::ResetRelationalObjectModuleIndex( const std::vector<int> &relationTable )
{
    RelationalObjectModuleItem::ResetRelationalObjectModuleIndex( relationTable );

    if( !this->sourceCodePosition.IsNothing() )
    {
        this->sourceCodePosition.SetRelationalObjectModuleIndex( relationTable[this->sourceCodePosition.GetRelationalObjectModuleIndex()] );
    }
}

bool Procedure::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    foreach( Parameter *pParameter, params )
    {
        pParameter->Resolve( resolver, resolveErrors );
    }

    returnType.Resolve( resolver, resolveErrors );

    return true;
}


void UserProc::ResetRelationalObjectModuleIndex( const std::vector<int> &relationTable )
{
    Procedure::ResetRelationalObjectModuleIndex( relationTable );

    this->GetNativeCode().ResetRelationalObjectModuleIndex( relationTable );
}

int id_base = 0;

UserProc::UserProc( const Symbol &symbol, const NamespaceScopesCollection &importedNamespaces, Kind kind, bool isMacro, bool isCdecl, bool isExport )
    : Procedure( symbol, kind, isCdecl )
    , importedNamespaces( importedNamespaces )
    , pParentClass( NULL )
    , pInterface( NULL )
    , pMethod( NULL )
    , isMacro( isMacro )
    , secondParmNum( 0 )
    , realSecondParmNum( 1 )
    , isExport( isExport )
    , isAutoGenerationSystem( false )
    , isAutoGeneration( false )
    , isCompiled( false )
    , beginOpAddress( 0 )
    , endOpAddress( 0 )
    , id( id_base ++ )
{
}

UserProc::UserProc( const UserProc &userProc, const CClass *pParentClass )
    : Procedure( userProc )
    , _paramStr( userProc._paramStr )
    , importedNamespaces( userProc.importedNamespaces )
    , pParentClass( pParentClass )
    , pInterface( NULL )
    , pMethod( NULL )
    , isMacro( userProc.isMacro )
    , secondParmNum( userProc.secondParmNum )
    , realParams( userProc.realParams )
    , realSecondParmNum( userProc.realSecondParmNum )
    , isExport( userProc.isExport )
    , isAutoGenerationSystem( userProc.isAutoGenerationSystem )
    , isAutoGeneration( userProc.isAutoGeneration )
    , isCompiled( false )
    , beginOpAddress( 0 )
    , endOpAddress( 0 )
    , localVars( Variables() )
    , id( id_base ++ )
    , nativeCode( NativeCode() )
{
}

UserProc::UserProc()
{
}

UserProc::~UserProc()
{
    foreach( Parameter *pParam, realParams ){
        delete pParam;
    }
}

bool UserProc::IsEqualForOverride( const Types &actualTypeParametersForThisProc, const UserProc *pUserProc ) const
{
    if( this->GetName() == pUserProc->GetName()                     // 名前空間及び名前が等しい
        && this->Params().Equals( actualTypeParametersForThisProc, pUserProc->Params() ) )          // パラメータが等しい
    {
        if( this->returnType.Equals( pUserProc->returnType ) )
        {
            // 戻り値が等しい
            return true;
        }
        else if( this->returnType.IsCovariant( pUserProc->returnType ) )
        {
            // 戻り値が共変
            return true;
        }
        else if( this->returnType.IsTypeParameter() )
        {
            // 型パラメータだったとき

            if( actualTypeParametersForThisProc[this->returnType.GetFormalTypeIndex()].Equals( pUserProc->returnType ) )
            {
                // 戻り値が等しい
                return true;
            }
            else if( actualTypeParametersForThisProc[this->returnType.GetFormalTypeIndex()].IsCovariant( pUserProc->returnType ) )
            {
                // 戻り値が共変
                return true;
            }
        }
    }
    return false;
}
    

std::string UserProc::GetFullName() const
{
    if( HasParentClass() ){
        return GetParentClass().GetName() + "." + GetName();
    }

    return GetName();
}
bool UserProc::IsCastOperator() const
{
    if( GetName()[0] == 1 && GetName()[1] == ESC_OPERATOR && GetName()[2] == CALC_AS )
    {
        return true;
    }
    return false;
}
bool UserProc::IsSystem() const
{
    // "_System_" を名前の先頭に含む関数
    if( memcmp( this->GetName().c_str(), "_System_", 8 ) == 0 )
    {
        return true;
    }

    // "_System_" を名前の先頭に含むクラスのメソッド
    if( this->HasParentClass() )
    {
        if( memcmp( this->GetParentClass().GetName().c_str(), "_System_", 8 ) == 0 )
        {
            return true;
        }
    }

    return false;
}
const NamespaceScopes &UserProc::GetNamespaceScopes() const
{
    if( HasParentClass() )
    {
        return GetParentClassPtr()->GetNamespaceScopes();
    }
    return Symbol::GetNamespaceScopes();
}
const NamespaceScopesCollection &UserProc::GetImportedNamespaces() const
{
    if( pParentClass )
    {
        return pParentClass->GetImportedNamespaces();
    }
    return importedNamespaces;
}
bool UserProc::IsVirtual() const
{
    if( pMethod == NULL ){
        return false;
    }
    return ( pMethod->IsVirtual() != 0 );
}
const CMethod &UserProc::GetMethod() const
{
    if( !HasParentClass() )
    {
        Jenga::Throw( "グローバル関数に対してUserProc::GetMethodメソッドが呼ばれた" );
    }
    return *pMethod;
}

bool UserProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    Procedure::Resolve( resolver, resolveErrors );

    if( this->pParentClass )
    {
        if( this->pParentClass->IsNeedResolve() )
        {
            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pParentClass );
            if( pTempClass )
            {
                this->pParentClass = pTempClass;
            }
            else
            {
                resolveErrors.Add( ResolveError( this->pParentClass->GetRelationalObjectModuleIndex(), this->pParentClass->GetFullName() ) );
            }
        }
    }

    if( pInterface )
    {
        const_cast<Interface *>(pInterface)->Resolve( resolver, resolveErrors );
    }

    if( pMethod )
    {
        pMethod->Resolve( resolver, resolveErrors );
    }

    foreach( Parameter *pParameter, realParams )
    {
        pParameter->Resolve( resolver, resolveErrors );
    }

    foreach( Variable *pLocalVar, localVars )
    {
        pLocalVar->Resolve( resolver, resolveErrors );
    }

    nativeCode.Resolve( resolver, resolveErrors );
    return true;
}

const UserProc *UserProc::pGlobalProc = NULL;


void UserProcs::EnumGlobalProcs( const char *simpleName, const Symbol &localSymbol, std::vector<const UserProc *> &subs )
{
    ///////////////////////////
    // グローバル関数を検索
    ///////////////////////////

    // ハッシュ値を取得
    foreach (auto pUserProc, GetHashArrayElement( simpleName ))
    {
        if( pUserProc->IsGlobalProcedure() ){
            if( pUserProc->IsEqualSymbol( localSymbol ) ){
                subs.push_back( pUserProc );
            }
        }
    }
}

bool DllProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    Procedure::Resolve( resolver, resolveErrors );
    return true;
}

bool ProcPointer::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
    Procedure::Resolve( resolver, resolveErrors );
    return true;
}

void ProcPointers::Clear()
{
    ProcPointers &procPointers = *this;
    foreach( ProcPointer *pProcPointer, procPointers ){
        delete pProcPointer;
    }
    this->clear();
}