source: dev/trunk/abdev/BasicCompiler_Common/Procedure.h@ 163

#pragma once

#include <Namespace.h>
#include "Parameter.h"
#include "Variable.h"

class CClass;
class CMethod;

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

private:
    const string name;                      // プロシージャ名

    Kind kind;

    bool isCdecl;
    bool isUsing;

protected:

    // パラメータ
    Parameters params;

    // 戻り値の型
    Type returnType;

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

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

    const string &GetName() const
    {
        return name;
    }

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

    bool IsCdecl() const
    {
        return isCdecl;
    }
    void Using(){
        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:
    string _paramStr;

private:
    bool isMacro;

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

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

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

public:

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

    string GetFullName() const;

    bool IsMacro() const
    {
        return isMacro;
    }

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

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

    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 );
    }
    void SetMethod( CMethod *pMethod ){
        this->pMethod = pMethod;
    }

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

    // バイナリコードの位置
    DWORD beginOpAddress;
    DWORD endOpAddress;
    int GetCodeSize() const
    {
        return endOpAddress - beginOpAddress;
    }

    virtual const NamespaceScopes &GetNamespaceScopes() const;
    virtual const NamespaceScopesCollection &GetImportedNamespaces() const;
    virtual bool IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const;

    // ローカル変数
    Variables localVars;

    // TODO: 適切なコードへ直す
    long id;


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

class GlobalProc : public UserProc
{
    const NamespaceScopes namespaceScopes;
    const NamespaceScopesCollection importedNamespaces;
public:
    // ハッシュリスト用
    GlobalProc *pNextData;

    GlobalProc( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const string &name, Kind kind, bool isMacro, bool isCdecl, bool isExport ):
      UserProc( name, kind, isMacro, isCdecl, isExport ),
      namespaceScopes( namespaceScopes ),
      importedNamespaces( importedNamespaces ),
      pNextData( NULL )
    {}
    ~GlobalProc(){}
/*
    GlobalProc *Create( const NamespaceScopes &namespaceScopes, char *buffer,int nowLine );
    bool AddGlobalProc( const NamespaceScopes &namespaceScopes, char *buffer,int nowLine );
*/
    virtual const NamespaceScopes &GetNamespaceScopes() const;
    virtual const NamespaceScopesCollection &GetImportedNamespaces() const
    {
        return importedNamespaces;
    }

    virtual bool IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const;
    virtual bool IsEqualSymbol( const GlobalProc &globalProc ) const;
    virtual bool IsEqualSymbol( const string &name ) const;
};

class DllProc : public Procedure
{
    const NamespaceScopes namespaceScopes;

    const string dllFileName;
    const string alias;
    int lookupAddress;

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

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

    bool IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const;
    bool IsEqualSymbol( const string &name ) const;

    const NamespaceScopes &GetNamespaceScopes() const
    {
        return namespaceScopes;
    }

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

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

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

};

class ProcPointer : public Procedure
{
public:
    ProcPointer( Kind kind ):
      Procedure( "", kind, false )
    {
    }
    ~ProcPointer(){}

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