source: dev/trunk/jenga/include/smoothie/Class.h@ 203

#pragma once

#include <jenga/include/common/BoostXmlSupport.h>

#include "Prototype.h"
#include "Member.h"
#include "Method.h"
#include "LexicalAnalysis.h"

class InheritedInterface
{
    CClass *pInterfaceClass;
    int vtblOffset;
public:
    InheritedInterface( CClass *pInterfaceClass, int vtblOffset )
        : pInterfaceClass( pInterfaceClass )
        , vtblOffset( vtblOffset )
    {
    }

    CClass &GetInterfaceClass() const{
        return *pInterfaceClass;
    }
    int GetVtblOffset() const
    {
        return vtblOffset;
    }
};
typedef vector<InheritedInterface> Interfaces;

class CClass : public Prototype
{
public:
    // メンバの参照方法
    enum RefType{
        Non = 0,        // no reference member
        Dot,            // obj.member
        Pointer,        // obj->member
    };

    // 型の種類
    enum ClassType{
        Class,
        Interface,
        Enum,
        Delegate,
        Structure,
    };

protected:
    ClassType classType;

    // importされている名前空間
    NamespaceScopesCollection importedNamespaces;

    // 実装するインターフェイス
    Interfaces interfaces;
    
    // 継承クラス
    const CClass *pSuperClass;

    // Blittable型情報
    Type blittableType;

    // 動的メンバ
    Members dynamicMembers;

    // 静的メンバ
    Members staticMembers;

    // 動的メソッド
    Methods methods;
    int ConstructorMemberSubIndex;
    int DestructorMemberSubIndex;
    int vtblNum;                    // 仮想関数の数

    // 静的メソッド
    Methods staticMethods;


    // XMLシリアライズ用
    // TODO: xml実装
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Prototype );
        ar & BOOST_SERIALIZATION_NVP( classType );
        ar & BOOST_SERIALIZATION_NVP( importedNamespaces );
        //ar & BOOST_SERIALIZATION_NVP( interfaces );
        ar & boost::serialization::make_nvp( "pSuperClass", const_cast<CClass *&>(pSuperClass) );
        ar & BOOST_SERIALIZATION_NVP( blittableType );
        //ar & BOOST_SERIALIZATION_NVP( dynamicMembers );
        //ar & BOOST_SERIALIZATION_NVP( staticMembers );
        //ar & BOOST_SERIALIZATION_NVP( methods );
        ar & BOOST_SERIALIZATION_NVP( ConstructorMemberSubIndex );
        ar & BOOST_SERIALIZATION_NVP( DestructorMemberSubIndex );
        ar & BOOST_SERIALIZATION_NVP( vtblNum );
        //ar & BOOST_SERIALIZATION_NVP( staticMethods );
    }


    bool isReady;

public:

    //アラインメント値
    int iAlign;

    CClass( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const string &name )
        : isReady( false )
        , Prototype( namespaceScopes, name )
        , importedNamespaces( importedNamespaces )
        , ConstructorMemberSubIndex( -1 )
        , DestructorMemberSubIndex( -1 )
        , classType( Class )
        , pSuperClass( NULL )
        , vtblNum( 0 )
        , iAlign( 0 )
        , vtbl_offset( -1 )
        , isCompilingConstructor( false )
        , isCompilingDestructor( false )
        , pobj_NextClass( NULL )
    {
    }
    CClass()
        : isReady( false )
        , Prototype()
        , importedNamespaces()
        , ConstructorMemberSubIndex( -1 )
        , DestructorMemberSubIndex( -1 )
        , classType()
        , pSuperClass( NULL )
        , vtblNum( 0 )
        , iAlign( 0 )
        , vtbl_offset( -1 )
        , isCompilingConstructor( false )
        , isCompilingDestructor( false )
        , pobj_NextClass( NULL )
    {
    }
    ~CClass();

    void Readed(){
        isReady = true;
    }
    bool IsReady() const{
        return isReady;
    }

    const NamespaceScopesCollection &GetImportedNamespaces() const
    {
        return importedNamespaces;
    }

    // インターフェイス
    bool HasInterfaces() const
    {
        return ( interfaces.size() != 0 );
    }
    bool IsInheritsInterface( const CClass *pInterfaceClass ) const;

    // 継承元クラス
    bool HasSuperClass() const
    {
        return ( pSuperClass != NULL );
    }
    const CClass &GetSuperClass() const
    {
        return *pSuperClass;
    }
    void SetSuperClass( const CClass *pSuperClass )
    {
        this->pSuperClass = pSuperClass;
    }

    // Blittable型
    bool IsBlittableType() const
    {
        return !blittableType.IsNull();
    }
    const Type &GetBlittableType() const
    {
        return blittableType;
    }
    void SetBlittableType( const Type &type ){
        blittableType = type;
    }

    bool IsClass() const;
    bool IsInterface() const;
    bool IsEnum() const;
    bool IsDelegate() const;
    bool IsStructure() const;
    void SetClassType( ClassType classType )
    {
        this->classType = classType;
    }

    // 継承させる
    virtual bool Inherits( const char *inheritNames, int nowLine ) = 0;
    virtual bool InheritsClass( const CClass &inheritsClass, int nowLine ) = 0;
    virtual bool InheritsInterface( const CClass &inheritsClass, int nowLine ) = 0;

    virtual void AddMember( Prototype::Accessibility accessibility, bool idConst, bool isRef, char *buffer, int nowLine ) = 0;
    virtual void AddStaticMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ) = 0;

    virtual void AddMethod(CClass *pobj_c, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
        bool isVirtual, bool isOverride, char *buffer, int nowLine) = 0;

    //重複チェック
    BOOL DupliCheckAll(const char *name);
    BOOL DupliCheckMember(const char *name);

    const Members &GetDynamicMembers() const
    {
        return dynamicMembers;
    }
    const Members &GetStaticMembers() const
    {
        return staticMembers;
    }
    Members &GetDynamicMembers()
    {
        return dynamicMembers;
    }
    Members &GetStaticMembers()
    {
        return staticMembers;
    }

    const Methods &GetMethods() const
    {
        return methods;
    }
    const Methods &GetStaticMethods() const
    {
        return staticMethods;
    }
    Methods &GetMethods()
    {
        return methods;
    }
    Methods &GetStaticMethods()
    {
        return staticMethods;
    }

    //デフォルト コンストラクタ
    const CMethod *GetConstructorMethod() const;
    void SetConstructorMemberSubIndex( int constructorMemberSubIndex )
    {
        this->ConstructorMemberSubIndex = constructorMemberSubIndex;
    }

    //デストラクタ メソッドを取得
    const CMethod *GetDestructorMethod() const;
    void SetDestructorMemberSubIndex( int destructorMemberSubIndex )
    {
        this->DestructorMemberSubIndex = destructorMemberSubIndex;
    }

    // vtblに存在する仮想関数の数
    int GetVtblNum() const
    {
        return vtblNum;
    }
    void SetVtblNum( int vtblNum )
    {
        this->vtblNum = vtblNum;
    }
    void AddVtblNum( int vtblNum )
    {
        this->vtblNum += vtblNum;
    }
    bool IsExistVirtualFunctions() const
    {
        return ( vtblNum > 0 );
    }

    // メンバの総合サイズを取得
    int GetSize() const;

    // メンバのオフセットを取得
    int GetMemberOffset( const char *memberName, int *pMemberNum = NULL ) const;

private:
    // アラインメント値を取得
    int GetAlignment() const;


    //vtbl
protected:
    mutable long vtbl_offset;
public:
    int GetFuncNumInVtbl( const UserProc *pUserProc ) const;
    virtual LONG_PTR GetVtblGlobalOffset(void) const = 0;
    virtual void ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection) = 0;
    bool IsAbstract() const;


    //コンストラクタをコンパイルしているかどうかのチェックフラグ
private:
    mutable bool isCompilingConstructor;
public:
    void NotifyStartConstructorCompile() const;
    void NotifyFinishConstructorCompile() const;
    bool IsCompilingConstructor() const;

    //デストラクタをコンパイルしているかどうかのチェックフラグ
private:
    mutable bool isCompilingDestructor;
public:
    void NotifyStartDestructorCompile() const;
    void NotifyFinishDestructorCompile() const;
    bool IsCompilingDestructor() const;


    //自身の派生クラスかどうかを確認
    bool IsSubClass( const CClass *pClass ) const;

    //自身と等しいまたは派生クラスかどうかを確認
    bool IsEqualsOrSubClass( const CClass *pClass ) const;

    // 自身と等しいまたは派生クラス、基底クラスかどうかを確認
    bool IsEqualsOrSubClassOrSuperClass( const CClass &objClass ) const;


    //線形リスト用
    CClass *pobj_NextClass;


public:
    static bool SplitName( const char *desc, char *object, char *member, CClass::RefType &refType ){
        int lastIndex = -1;
        for( int i=0; desc[i]; i++ ){
            if( desc[i] == '(' ){
                i=JumpStringInPare(desc,i+1);
                continue;
            }
            else if( desc[i] == '[' ){
                i=JumpStringInBracket(desc,i+1);
                continue;
            }
            else if(desc[i]=='.'||(desc[i]==1&&desc[i+1]==ESC_PSMEM)){
                lastIndex = i;
            }
        }
        if( lastIndex == -1 ){
            lstrcpy( member, desc );
            return false;
        }

        if(desc[lastIndex]=='.'){
            lstrcpy(member,desc+lastIndex+1);
            refType = CClass::Dot;
        }
        else{
            lstrcpy(member,desc+lastIndex+2);
            refType = CClass::Pointer;
        }

        if( object ){
            lstrcpy( object, desc );
            object[lastIndex]=0;
        }

        return true;
    }
    static bool SplitName( const char *desc, char *object, char *member ){
        CClass::RefType dummyRefType;
        return SplitName( desc, object, member, dummyRefType );
    }
};

#define MAX_CLASS_HASH 65535
class Classes
{
protected:
    int GetHashCode(const char *name) const;
    void DestroyClass(CClass *pobj_c);
public:
    CClass *pobj_ClassHash[MAX_CLASS_HASH];

    Classes();
    ~Classes();
    void Clear();

    const CClass *Find( const string &fullName ) const;
    virtual const CClass *Find( const NamespaceScopes &namespaceScopes, const string &name ) const = 0;

    virtual CClass *Create( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name) = 0;
    bool Insert( CClass *pClass );
    CClass *Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name,int nowLine);

    void ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection);

public:

    // 実体収集
    virtual void CollectClassesForNameOnly( const BasicSource &source ) = 0;
    virtual void GetClass_recur(const char *lpszInheritsClass) = 0;
    virtual void GetAllClassInfo() = 0;
    virtual void Compile_System_InitializeUserTypes() = 0;
    virtual void InitStaticMember() = 0;


    /////////////////////////////
    // 特殊クラス
    /////////////////////////////
    CClass *pStringClass;
    CClass *pObjectClass;
    CClass *GetStringClassPtr() const;
    CClass *GetObjectClassPtr() const;


    /////////////////////////////
    // 現在コンパイル中の情報
    /////////////////////////////
private:
    const CClass *pCompilingClass;
    const CMethod *pCompilingMethod;
public:
    //コンパイル開始の通知を受け取るメソッド
    void StartCompile( UserProc *pUserProc );

    //現在コンパイル中のメソッド情報を取得
    const CClass *GetNowCompilingClass() const;
    const CMethod *GetNowCompilingMethodInfo();


    /////////////////////
    // イテレータ
    /////////////////////
private:
    mutable CClass **ppobj_IteClass;
    mutable int iIteMaxNum;
    mutable int iIteNextNum;
public:
    void Iterator_Init() const;
    void Iterator_Reset() const;
    BOOL Iterator_HasNext() const;
    CClass *Iterator_GetNext() const;
    int Iterator_GetMaxCount() const;
};