source: dev/trunk/abdev/BasicCompiler_Common/include/Parameter.h@ 333

#pragma once

#include <string>
#include <vector>

#include <jenga/include/smoothie/BasicFixed.h>
#include <jenga/include/smoothie/LexicalAnalysis.h>

#include <option.h>
#include <Program.h>
#include <Type.h>

class Parameter : public Type
{
    std::string varName;
    bool isRef;
    bool isArray;
    Subscripts subscripts;

    std::string initValue;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - Parameter" );

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Type );
        ar & BOOST_SERIALIZATION_NVP( varName );
        ar & BOOST_SERIALIZATION_NVP( isRef );
        ar & BOOST_SERIALIZATION_NVP( isArray );
        ar & BOOST_SERIALIZATION_NVP( subscripts );
        ar & BOOST_SERIALIZATION_NVP( initValue );
    }

public:
    Parameter( const std::string &varName, const Type &type, bool isRef = false, const std::string initValue = "" ):
        Type( type ),
        varName( varName ),
        isRef( isRef ),
        isArray( false ),
        initValue( initValue )
    {
    }
    Parameter( const Parameter &param ):
        Type( param ),
        varName( param.varName ),
        isRef( param.isRef ),
        isArray( param.isArray ),
        subscripts( param.subscripts ),
        initValue( param.initValue )
    {
    }
    Parameter()
    {
    }
    ~Parameter(){}

    void SetArray( const Subscripts &subscripts ){
        isArray = true;
        this->subscripts = subscripts;
    }

    const std::string &GetVarName() const
    {
        return varName;
    }

    bool IsRef() const
    {
        return isRef;
    }
    bool IsArray(){
        return isArray;
    }
    const Subscripts &GetSubscripts() const
    {
        return subscripts;
    }

    const std::string &GetInitValue() const
    {
        return initValue;
    }

    bool Equals( const Parameter &param ) 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;
            }
        }

        return false;
    }
};

class Parameters : public std::vector<Parameter *>
{
    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - Parameters" );

        ar & boost::serialization::make_nvp("vector_Parameter", boost::serialization::base_object<std::vector<Parameter *>>(*this));
    }

public:

    bool Equals( const Parameters &params ) 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] ) ){
                return false;
            }
        }

        return true;
    }

    int GetMemorySize() const
    {
        return (int)this->size() * PTR_SIZE;
    }

    bool Analyze( const char *sourceOfParams, int nowLine );

    std::string GetString() const;
};