source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/Procedure.cpp@ 573

#include "stdafx.h"

#include <Compiler.h>
#include <Procedure.h>

#include "../common.h"
#ifdef _AMD64_
#include "../../compiler_x64/opcode.h"
#else
#include "../../compiler_x86/opcode.h"
#endif

using namespace ActiveBasic::Compiler;


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

const UserProc *UserProc::pGlobalProc = NULL;


bool UserProcs::Insert( UserProc *pUserProc, int nowLine )
{
    /////////////////////////////////
    // ハッシュデータに追加
    /////////////////////////////////

    if( !Put( pUserProc ) )
    {
        // 重複しているため、失敗
        compiler.errorMessenger.Output(15,pUserProc->GetName().c_str(),nowLine);
        return false;
    }

    return true;
}

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

    // ハッシュ値を取得
    UserProc *pUserProc = GetHashArrayElement( simpleName );
    while(pUserProc){
        if( pUserProc->IsGlobalProcedure() ){
            if( pUserProc->IsEqualSymbol( LexicalAnalyzer::FullNameToSymbol( localName ) ) ){
                subs.push_back( pUserProc );
            }
        }

        pUserProc=pUserProc->GetChainNext();
    }
}

int ProcPointers::Add( const std::string &typeExpression )
{
    DWORD dwProcType = (DWORD)typeExpression[2];
    const std::string &paramStr = typeExpression.substr( 3 );

    Procedure::Kind kind = Procedure::Sub;
    if( dwProcType == ESC_FUNCTION ){
        kind = Procedure::Function;
    }

    ProcPointer *pProcPointer = new ProcPointer( kind );

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

    this->push_back( pProcPointer );

    return (int)this->size()-1;
}

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