source: dev/trunk/ab5.0/abdev/ab_common/src/Lexical/Parameter.cpp@ 660

#include "stdafx.h"

Parameter::Parameter( const std::string &varName, const Type &type, bool isRef, const std::string initValue )
    : Type( type )
    , varName( varName )
    , isRef( isRef )
    , isArray( false )
    , initValue( initValue )
{
}

Parameter::Parameter( const Parameter &param, const Type &type )
    : Type( type )
    , varName( param.varName )
    , isRef( param.isRef )
    , isArray( param.isArray )
    , subscripts( param.subscripts )
    , initValue( param.initValue )
{
}

Parameter::Parameter( const Parameter &param )
    : Type( param )
    , varName( param.varName )
    , isRef( param.isRef )
    , isArray( param.isArray )
    , subscripts( param.subscripts )
    , initValue( param.initValue )
{
}

Parameter::Parameter()
{
}

Parameter::~Parameter()
{
}

bool Parameter::Equals( const Parameter &param, bool isContravariant ) const
{
    if( Type::Equals( param ) )
    {
        return true;
    }
    else
    {
        if( this->isRef && this->GetBasicType() == DEF_ANY &&
            param.isRef == false && param.IsPointer()
            ||
            this->isRef == false && this->IsPointer() &&
            param.isRef && param.GetBasicType() == DEF_ANY )
        {
            /* ByRef var As Any
                    と
                var As VoidPtr
                は同等
            */
            return true;
        }
    }

    if( isContravariant )
    {
        // 反変引数を許可する
        if( this->IsContravariant( param ) )
        {
            // 反変引数だったとき
            return true;
        }
    }

    return false;
}
bool Parameter::Equals( const Types &actualTypeParametersForThisProc, const Parameter &param, bool isContravariant ) const
{
    if( Equals( param, isContravariant ) )
    {
        return true;
    }
    
    if( this->IsTypeParameter() )
    {
        // 型パラメータだったとき
        if( actualTypeParametersForThisProc[this->GetFormalTypeIndex()].Equals( param ) )
        {
            // 戻り値が等しい
            return true;
        }
    }

    return false;
}

bool Parameters::Equals( const Parameters &params, bool isContravariant ) const
{
    if( this->size() != params.size() ){
        return false;
    }

    int max = (int)this->size();
    for( int i=0; i<max; i++ ){
        if( !(*this)[i]->Equals( *params[i], isContravariant ) ){
            return false;
        }
    }

    return true;
}
bool Parameters::Equals( const Types &actualTypeParametersForThisProc, const Parameters &params, bool isContravariant ) const
{
    if( this->size() != params.size() ){
        return false;
    }

    int max = (int)this->size();
    for( int i=0; i<max; i++ ){
        if( !(*this)[i]->Equals( actualTypeParametersForThisProc, *params[i], isContravariant ) ){
            return false;
        }
    }

    return true;
}