source: dev/trunk/abdev/BasicCompiler_Common/include/Procedure.h@ 247

#pragma once

#include <jenga/include/smoothie/Source.h>

#include <Hashmap.h>
#include <option.h>
#include <Program.h>
#include <Class.h>
#include <Method.h>
#include <Procedure.h>
#include <Parameter.h>
#include <Variable.h>
#include <CodeGenerator.h>

class CClass;
class CMethod;

class Procedure : public Symbol
{
public:
    // 種類
    enum Kind{
        Sub,
        Function,
    };

private:
    Kind kind;

    bool isCdecl;
    mutable bool isUsing;

protected:

    // パラメータ
    Parameters params;

    // 戻り値の型
    Type returnType;

    // ソースコードの位置
    int codePos;

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

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Symbol );
        ar & BOOST_SERIALIZATION_NVP( kind );
        ar & BOOST_SERIALIZATION_NVP( isCdecl );
        ar & BOOST_SERIALIZATION_NVP( isUsing );
        ar & BOOST_SERIALIZATION_NVP( params );
        ar & BOOST_SERIALIZATION_NVP( returnType );
        ar & BOOST_SERIALIZATION_NVP( codePos );
    }

public:
    Procedure( const NamespaceScopes &namespaceScopes, const string &name, Kind kind, bool isCdecl )
        : Symbol( namespaceScopes, name )
        , kind( kind )
        , isCdecl( isCdecl )
        , isUsing( false )
        , codePos( -1 )
    {
    }
    Procedure()
    {
    }
    ~Procedure(){
        BOOST_FOREACH( Parameter *pParam, params ){
            delete pParam;
        }
    }

    bool IsSub() const
    {
        return ( kind == Sub );
    }
    bool IsFunction() const
    {
        return ( kind == Function );
    }

    bool IsCdecl() const
    {
        return isCdecl;
    }
    void Using() const
    {
        isUsing = true;
    }
    bool IsUsing() const
    {
        return isUsing;
    }

    int GetCodePos() const
    {
        return codePos;
    }

    const Parameters &Params() const
    {
        return params;
    }
    const Type &ReturnType() const
    {
        return returnType;
    }
};

class UserProc : public Procedure, public Jenga::Common::ObjectInHashmap<UserProc>
{
public:
    string _paramStr;

private:
    NamespaceScopesCollection importedNamespaces;

    // 親クラスと対応するメソッド
    const CClass *pParentClass;
    CMethod *pMethod;

    bool isMacro;

    // パラメータの追加情報
    int secondParmNum;
    Parameters realParams;
    int realSecondParmNum;

    // 各種フラグ
    bool isExport;
    mutable bool isSystem;
    mutable bool isAutoGeneration;
    mutable bool isCompiled;

    mutable DWORD beginOpAddress;
    mutable DWORD endOpAddress;

    // ローカル変数
    mutable Variables localVars;

    // 識別ID
    int id;

    // ネイティブコード
    NativeCode nativeCode;

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

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
        ar & BOOST_SERIALIZATION_NVP( _paramStr );
        ar & BOOST_SERIALIZATION_NVP( importedNamespaces );
        ar & boost::serialization::make_nvp("pParentClass", const_cast<CClass *&>(pParentClass) );
        ar & BOOST_SERIALIZATION_NVP( pMethod );
        ar & BOOST_SERIALIZATION_NVP( isMacro );
        ar & BOOST_SERIALIZATION_NVP( secondParmNum );
        ar & BOOST_SERIALIZATION_NVP( realParams );
        ar & BOOST_SERIALIZATION_NVP( realSecondParmNum );
        ar & BOOST_SERIALIZATION_NVP( isExport );
        ar & BOOST_SERIALIZATION_NVP( isSystem );
        ar & BOOST_SERIALIZATION_NVP( isAutoGeneration );
        ar & BOOST_SERIALIZATION_NVP( isCompiled );
        ar & BOOST_SERIALIZATION_NVP( beginOpAddress );
        ar & BOOST_SERIALIZATION_NVP( endOpAddress );
        ar & BOOST_SERIALIZATION_NVP( localVars );
        ar & BOOST_SERIALIZATION_NVP( id );
        ar & BOOST_SERIALIZATION_NVP( nativeCode );
    }

public:

    UserProc( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const string &name, Kind kind, bool isMacro, bool isCdecl, bool isExport, int id )
        : Procedure( namespaceScopes, name, kind, isCdecl )
        , importedNamespaces( importedNamespaces )
        , pParentClass( NULL )
        , pMethod( NULL )
        , isMacro( isMacro )
        , isExport( isExport )
        , isSystem( false )
        , isAutoGeneration( false )
        , isCompiled( false )
        , beginOpAddress( 0 )
        , endOpAddress( 0 )
        , id( id )
    {
    }
    UserProc()
    {
    }
    ~UserProc()
    {
        BOOST_FOREACH( Parameter *pParam, realParams ){
            delete pParam;
        }
    }

    virtual const std::string &GetKeyName() const
    {
        return GetName();
    }

    virtual bool IsDuplication( const UserProc *pUserProc ) const
    {
        if( this->GetParentClassPtr() == pUserProc->GetParentClassPtr()
            && pUserProc->IsEqualSymbol( *this )
            && this->Params().Equals( pUserProc->Params() ) )
        {
            return true;
        }
        return false;
    }

    bool IsMacro() const
    {
        return isMacro;
    }

    int GetSecondParmNum() const
    {
        return secondParmNum;
    }
    const Parameters &RealParams() const
    {
        return realParams;
    }
    int GetRealSecondParmNum() const
    {
        return realSecondParmNum;
    }

    void ExportOff(){
        isExport = false;
    }
    bool IsExport() const
    {
        return isExport;
    }
    void ThisIsSystemProc() const
    {
        isSystem = true;
    }
    bool IsSystem() const
    {
        return isSystem;
    }
    void ThisIsAutoGenerationProc() const
    {
        isAutoGeneration = true;
    }
    bool IsAutoGeneration() const
    {
        return isAutoGeneration;
    }
    void CompleteCompile() const
    {
        isCompiled = true;
    }
    void KillCompileStatus() const
    {
        isCompiled = false;
    }
    bool IsCompiled() const
    {
        return isCompiled;
    }
    bool IsDestructor() const
    {
        return ( GetName()[0] == '~' );
    }

    // バイナリコード位置とサイズ
    DWORD GetBeginOpAddress() const
    {
        return beginOpAddress;
    }
    void SetBeginOpAddress( DWORD beginOpAddress ) const
    {
        this->beginOpAddress = beginOpAddress;
    }
    DWORD GetEndOpAddress() const
    {
        return endOpAddress;
    }
    void SetEndOpAddress( DWORD endOpAddress ) const
    {
        this->endOpAddress = endOpAddress;
    }
    int GetCodeSize() const
    {
        return endOpAddress - beginOpAddress;
    }

    virtual const NamespaceScopes &GetNamespaceScopes() const;
    const NamespaceScopesCollection &GetImportedNamespaces() const;

    Variables &GetLocalVars() const
    {
        return localVars;
    }

    int GetId() const
    {
        return id;
    }

    NativeCode &GetNativeCode()
    {
        return nativeCode;
    }

    std::string GetFullName() const;

    bool IsVirtual() const;

    void SetParentClass( const CClass *pParentClass ){
        this->pParentClass = pParentClass;
    }
    const CClass *GetParentClassPtr() const
    {
        return pParentClass;
    }
    const CClass &GetParentClass() const
    {
        return *pParentClass;
    }
    bool HasParentClass() const
    {
        return ( pParentClass != NULL );
    }
    bool IsGlobalProcedure() const
    {
        return ( pParentClass == NULL );
    }
    void SetMethod( CMethod *pMethod ){
        this->pMethod = pMethod;
    }

    bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic );



    /////////////////////////////////////////////////////////////////
    // コンパイル中の関数を管理
    /////////////////////////////////////////////////////////////////
private:
    static const UserProc *pCompilingUserProc;
public:
    static void CompileStartForGlobalArea(){
        pCompilingUserProc = NULL;
    }
    static void CompileStartForUserProc( const UserProc *pUserProc ){
        pCompilingUserProc = pUserProc;
    }
    static bool IsGlobalAreaCompiling(){
        return ( pCompilingUserProc == NULL );
    }
    static bool IsLocalAreaCompiling(){
        return ( pCompilingUserProc != NULL );
    }
    static const UserProc &CompilingUserProc(){
        return *pCompilingUserProc;
    }
};

class UserProcs : public Jenga::Common::Hashmap<UserProc>
{
    std::vector<std::string> macroNames;

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

        ar & boost::serialization::make_nvp("Hashmap_UserProcImpl",
            boost::serialization::base_object<Jenga::Common::Hashmap<UserProc>>(*this));
        ar & BOOST_SERIALIZATION_NVP( macroNames );
    }


public:
    UserProcs()
    {
    }
    ~UserProcs()
    {
    }

    bool Insert( UserProc *pUserProc, int nowLine );

    UserProc *Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,bool isVirtual,CClass *pobj_c, bool isStatic);

    void EnumGlobalProcs( const char *simpleName, const char *localName, std::vector<const UserProc *> &subs );
};

class DllProc : public Procedure, public Jenga::Common::ObjectInHashmap<DllProc>
{
    string dllFileName;
    string alias;
    int lookupAddress;

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

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
        ar & BOOST_SERIALIZATION_NVP( dllFileName );
        ar & BOOST_SERIALIZATION_NVP( alias );
        ar & BOOST_SERIALIZATION_NVP( lookupAddress );
    }

public:
    // ハッシュリスト用
    DllProc *pNextData;

    DllProc( const NamespaceScopes &namespaceScopes, const string &name, Kind kind, bool isCdecl, const string &dllFileName, const string &alias )
        : Procedure( namespaceScopes, name, kind, isCdecl )
        , dllFileName( dllFileName )
        , alias( alias )
        , lookupAddress( 0 )
        , pNextData( NULL )
    {
    }
    DllProc()
    {
    }
    ~DllProc()
    {
    }

    virtual const std::string &GetKeyName() const
    {
        return GetName();
    }

    virtual bool IsDuplication( const DllProc *pDllProc ) const
    {
        if( pDllProc->IsEqualSymbol( *this )
            && this->Params().Equals( pDllProc->Params() ) )
        {
            return true;
        }
        return false;
    }

    const string &GetDllFileName() const
    {
        return dllFileName;
    }
    const string &GetAlias() const
    {
        return alias;
    }

    void SetLookupAddress( int lookupAddress ){
        this->lookupAddress = lookupAddress;
    }
    int GetLookupAddress() const
    {
        return lookupAddress;
    }

    bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
};
class DllProcs : public Jenga::Common::Hashmap<DllProc>
{
    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - DllProcs" );

        ar & boost::serialization::make_nvp("Hashmap_DllProc",
            boost::serialization::base_object<Jenga::Common::Hashmap<DllProc>>(*this));
    }

public:
    void Add(const NamespaceScopes &namespaceScopes, char *buffer,int nowLine);
};

void CollectProcedures( const BasicSource &source, UserProcs &userProcs, DllProcs &dllProcs );

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

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
    }

public:
    ProcPointer( Kind kind )
        : Procedure( NamespaceScopes(), std::string(), kind, false )
    {
    }
    ProcPointer()
    {
    }
    ~ProcPointer(){}

    virtual bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
};

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

        ar & boost::serialization::make_nvp("vector_ProcPointer",
            boost::serialization::base_object<vector<ProcPointer *>>(*this));
    }

public:
    ProcPointers()
    {
    }
    ~ProcPointers()
    {
        Clear();
    }

    virtual int Add( const string &typeExpression );
    virtual void Clear();
};