DoRunTime.h

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder

#ifndef DORUNTIME_H
#define DORUNTIME_H

#ifndef DO_USE_RUNTIME
    #define DO_USE_RUNTIME 1
#endif

// %%DYNOBJ section general
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DORUNTIME
    #define DO_IMPLEMENTING     // If app has not defined it already
#endif
#include "dynobj/DynObj.h"

// --- Integer type ids for defined interfaces/classes ---
#define DORUNTIMEC_TYPE_ID 0xDCCF5000

// --- Forward class declarations ---
class DoRunTimeC;

// --- For each declared class, doTypeInfo template specializations ---
DO_DECL_TYPE_INFO(DoRunTimeC,DORUNTIMEC_TYPE_ID);

// %%DYNOBJ section end


#ifndef DO_MAIN
    #define DO_MAIN   // DoRunTime is always in the main module
#endif

#include "DoBaseI.h"
#include "DoError.h"

// Access global DoRunTimeI through this function

#include "DynObj.h"
#include "utils/ExpArr.hpp"
#include "utils/HashTable.hpp"
#include "utils/CharBuf.h"
#if DO_USE_TEMPLATES==1
    #include "DoBase.hpp"
#endif
#include "DortInternal.h"

#include "DynObjLib.h"
#include "DoNotifier.hpp"
#include "NamedRef.h"

//class DynObjLib;
struct DynObjError;
struct DOError;
class DynStr;
class DoVtblType;
class DynObjLibI;
class DoRunTimeC;

#if DO_USE_TEMPLATES==1
// This helps resolving ambigous DynI base class.
template<>
struct VBaseSelect<DoRunTimeC>{
    typedef DoRunTimeI type;
};
#endif


// For hashing on type ID - use ID from inside struct
template<>
class HashData<int,DynObjType*> {
public:
    HashData( ) : m_v(0) { }
    inline int GetKey(){ return m_v ? m_v->_type_id : 0; }
    inline void SetKey(int k){ }
    //Key       m_k;
    DynObjType* m_v;
    bool operator == (int k){ return m_v ? m_v->_type_id==k : false; }
};

// For hashing on type string - use name from inside struct
template<>
class HashData<const char*,DynObjType*> {
public:
    HashData( ) : m_v(0) { }
    inline const char* GetKey(){ return m_v ? m_v->_type : 0; }
    inline void SetKey(const char* k){ }
    //Key       m_k;
    DynObjType* m_v;
    bool operator == (const char* k){
        if( !m_v ) return !k; //false;
        // Also test for pointer equality, that works even after type object destruction
        if( k==m_v->_type ) return true;
        if( m_v->_type && k && !strcmp(m_v->_type,k) ) return true;
        return false;
    }
};

// Used when trying to register the VPTR for a type before the
// type itself is registered.
struct DelayedRegisterVTable {
    DelayedRegisterVTable( void** vtbl, DynObjType *pdt ) : m_vtbl(vtbl), m_pdt(pdt) { }
    void **m_vtbl;
    DynObjType *m_pdt;
    bool operator==(int id){ return m_pdt && m_pdt->_type_id==id; }
    bool operator==(void **vtbl){ return m_vtbl==vtbl; }
    bool operator==(DynObjType *pdt){ return m_pdt==pdt; }
};


// Good enough to have them just as forward decls here
class OwnedDynObjLib;


// %%DYNOBJ class(dyni) bases(DoRunTimeI,NotifierI,NamedRefI,DortInternalI)
class DoRunTimeC : public DoRunTimeI, public Notifier, public NamedRef,
                   public DortInternalI {
    friend class OwnedDynObjLib;
public:
    DoRunTimeC();
    ~DoRunTimeC(){ Dtor(); }
    void Dtor();

    static DoRunTimeC &GetInstance( bool do_get=true );


    // Base DynObj functions
    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
    virtual void*       docall doQueryI( const char *type );
    virtual void        docall doDestroy( ){ delete this; }


    virtual MallocI* docall  GetMalloc() const { return m_pmalloc; }
    virtual TextIoI* docall  GetTextIo() const { return m_ptio; }

    virtual DynObj*    docall  Create( const char *lib, const char *type, int type_id, const DynI* pdi_init=NULL );


    virtual int         docall GetLastErrCode( int thid=-1 );
    virtual bool        docall GetLastErrStr( DynStr& ds, int thid=-1 );
    virtual bool        docall SetLastError( int err_code, const char *err_msg );
    virtual int         docall GetThreadId( );

    virtual DynI* docall LoadLib( const char *lib_name, DynI* pdi_init );
    virtual bool docall UnloadLib( const char *lib_name );
    virtual DynObjLibI* docall GetLib( const char *lib );
    virtual const char* docall GetLoadError( ){ return m_cb_load_err; }


    virtual DynObjType* docall GetTypeOf( void **vtbl );
    virtual DynObjType* docall FindTypeFromName( const char *type, const char *header=NULL );
    virtual DynObjType* docall FindTypeFromId( int type_id );

    virtual int         docall GenerateTypeId();



    // Takes ownership of the library
    bool AddDOLib( DynObjLib *pdol );
    //bool RemoveDOLib( const DynObjLib *pdol );

    const char* LoadLib( const char *lib_name );

    DynI* LoadLib( const char *lib_name, DynI* pdi_init, int mod_flags );

    enum { MU_Ok=0, MU_LibNotFound, MU_CallerNotFound, Mu_ModuleNotFound, MU_NoPerm, MU_NotOwned, MU_HasInstances, MU_DanglingOk, MU_DanglingReject };
    int MayUnload( const char* lib_name );

    bool UnloadDanglingLib( const char* lib_name );

    DynObjLib *GetMainLib( );


    // Does not take ownership for these objects. They are assumed
    // to be static objects.

    bool SetMalloc( MallocI *pmi );

    void SetTextIo( TextIoI *ptio ){ m_ptio=ptio; }

    bool IsOk();

    bool PrepareShutdown( );

#if DO_USE_TEMPLATES==1

    template<class T>
    T* Create( doTypeWrapper<T>, const char *lib, const DynI* pdi_init=NULL ) {
        if( !IsOk() || m_tmp_disable<0 ) return NULL;

        int type_id = doTypeInfo<T>::Id();
        const char* type = doTypeInfo<T>::Name();

        DynObjType *pdt_create = NULL;
        DynObj *pdo = CreateGetType( lib, type, type_id, pdi_init, &pdt_create );
        if( pdo )
            // We have to cast here, since T may not be derived from DynObj
            return (T*)::doGetObj( (void*)pdo, type_id, pdt_create );
        else
            return NULL;
    }
#endif // DO_USE_TEMPLATES==1


    // Others (internal use)
    virtual bool        docall RegisterModule( DoModuleC *pmi );
    virtual bool        docall UnRegisterModule( DoModuleC *pmi );
    virtual DoModuleC*  docall GetModuleByIndex( int ix );

    virtual bool        docall RegisterTypeVTable( void **vtbl, DynObjType *pdt );
    virtual bool        docall UnRegisterTypeVTable( void **vtbl );
    virtual int         docall MergeTypes( doModuleData *pmod_data );
    virtual bool        docall UnMergeTypes( doModuleData *pmod_data );
    virtual bool        docall IsValidType( DynObjType *pdt );
    virtual DoModuleC*  docall GetModuleByAddr( const void* paddr );
    virtual DoModuleC*  docall GetModuleForType( DoModuleC* pmod_caller, int type_id );

    virtual bool docall SetObjectError( const void *pvo, const char *err_str, int err_code );
    virtual bool docall ClearObjectError( const void *pvo );
    virtual const char* docall GetObjectError( const void *pvo, int *perr_code );

    virtual void docall OnObjectCreate( DynObj *pdo, DoModuleC *pmod );
    virtual void docall OnObjectDestroy( DynObj *pdo, DoModuleC *pmod );
    virtual void docall TempDisableCreate( bool disable );

    virtual void docall SetModuleTempPermissions( DynObjLibI* plib, const void* base, int flags );
    virtual void docall ResetModuleTempPermissions( );

    virtual bool docall TrackDynObj( DynObj *pdo, NotifiableI *pni, bool begin_track, DynObjType *pdt );

    virtual int  docall AllocTypeItemTypeId( );

    virtual void* docall MainAlloc( int size );
    virtual bool  docall MainFree( void* pmem );

protected:

    // Internal type handling
    bool HasType( DynObjType *pdt );
    bool AddType( DynObjType *pdt );
    bool RemoveType( DynObjType *pdt );
    DynObjType* FindTypeFromNameAndId( const char* type, int type_id );

    DynObj* CreateGetType( const char *lib, const char *type, int type_id, const DynI* pdi_init, DynObjType **ppdt );

    bool GetUserTypes( ExpArrP<DynObjType*>&arr,
                       DynObjType **types, int length );
    bool SortOutInstantiateTypes( ExpArrP<DynObjType*>&arr,
                                  DynObjType **types, int length,
                                  const char* instantiate_types );

    int GetLibFlags( const char* paddr );
    DynObjLibI*  docall GetLibraryAt( const void* paddr );
    bool LibHasType( DynObjLibI *plib, int type_id );

    int GetCallerLib( OwnedDynObjLib *&polib, const char* pcaller_addr );
    OwnedDynObjLib* GetOwnedLib( const char* lib_name );
    int MayUnload( OwnedDynObjLib *polib, OwnedDynObjLib *polib_caller );
    bool UnloadLib( const char *lib_name, OwnedDynObjLib *polib_caller );
    DynI* SetLoadError( const char* error );

    void FreeTrackers( );

    MutexI   *m_pmut;       // No point in changing this one during execution
    MallocI  *m_pmalloc;
    TextIoI  *m_ptio;

    DynObjLib *m_lib_last;
    ExpArrP<OwnedDynObjLib*>    m_libs;     // Libraries with 1+ owners
    ExpArrPOwn<DynObjLib*>      m_libs_dangling; // Libraries with no owner but with dangling instances.

    ExpArrP<DoModuleC*>     m_modules;
    int m_type_id_nxt;
    int m_typeitem_typeid;

    // Allow setting library permissions early (while it's starting to load)
    int         m_tmp_load_cnt;
    DynObjLibI* m_tmp_load_lib;
    const char* m_tmp_load_base;
    int         m_tmp_load_flags;
    CharBuf     m_cb_load_err;

    // All registered types, associated with VTable pointers
    HashTable<void**,DynObjType*> m_vptr2type;
    HashTable<int,DynObjType*> m_id2type;
    HashTable<const char*,DynObjType*> m_name2type;
    ExpArrP<DynObjType*> m_types;

    ExpArrPOwn<DelayedRegisterVTable*> m_delayed_vptrs;
    ExpArrP<DoBaseNode*> m_bases_unresolved;

    HashTable<DynObj*,NotifiableI*> m_trackers;

    // Global errors
    ExpArrP<DOError*>    m_errors;

    // Per object error handling
    HashTable<const void*,DOError*> m_obj_errors;
    ExpArrPOwn<DOError*> m_oe_allocated;
    ExpArrP<DOError*> m_oe_avail;

    ExpArrP<char*> m_allocs;

    int m_tmp_disable;
};


// A global error, per thread
struct DOError {
    DOError(int thid, int err_code, const char *err_str) :
        m_thid(thid), m_err_code(err_code), m_err_str(err_str) { }
    bool operator == (int thid) { return m_thid==thid; }

    int     m_thid;
    int     m_err_code;
    CharBuf m_err_str;
};


// Always main here!
#if DO_USE_TEMPLATES==1

// Solve different ways of handling args in do_new
// Parallel implementation in DynObjLib.h
template<class T,class A, bool dyni_arg>
struct DoCreator;

template<class T,class A>
struct DoCreator<T,A,false> {
    static T *Create( A arg ){
        // Wrap arg
        DynData dd(arg);
        return DoRunTimeC::GetInstance().Create( doTypeWrapper<T>(), NULL, &dd );
    }
    static T *Create( const char* lib_name, A arg ){
        DynObjLibI *plib = DoRunTimeC::GetInstance().GetLib( lib_name );
        if( !plib ) return NULL;
        // Wrap arg
        DynData dd(arg);
        return plib->Create<T>( &dd );
    }
};

template<class T,class A>
struct DoCreator<T,A*,true> {
    static T *Create( A* parg ){
        // Arg is already DynI
        return DoRunTimeC::GetInstance().Create( doTypeWrapper<T>(), NULL, parg );
    }
    static T *Create( const char* lib_name, A* parg ){
        DynObjLibI *plib = DoRunTimeC::GetInstance().GetLib( lib_name );
        if( !plib ) return NULL;
        return plib->Create<T>( parg );
    }
};

template<class T,class A>
struct DoCreator<T,A&,true> {
    static T *Create( A& arg ){
        // Arg is already DynI
        return DoRunTimeC::GetInstance().Create( doTypeWrapper<T>(), NULL, &arg );
    }
    static T *Create( const char* lib_name, A& arg ){
        DynObjLibI *plib = DoRunTimeC::GetInstance().GetLib( lib_name );
        if( !plib ) return NULL;
        return plib->Create<T>( &arg );
    }
};



template <class T, class A>
T *do_new( A arg ){
    return DoCreator<T,A,DoIsTypeA<A,DynI>::v>::Create( arg );
}

template <class T, class A>
T *do_new( const char* lib_name, A arg ){
    return DoCreator<T,A,DoIsTypeA<A,DynI>::v>::Create( lib_name, arg );
}

template <class T>
T *do_new( ){
    return DoCreator<T,DynI*,true>::Create( (DynI*)NULL );
}

#else

#endif // DO_USE_TEMPLATES==1


// %%DYNOBJ section implement
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DORUNTIME

// Generate type information that auto-registers on module load
DynObjType g_do_vtype_DoRunTimeC("DoRunTimeC","DoRunTimeI",DORUNTIMEC_TYPE_ID,0,sizeof(DoRunTimeC),NULL,NULL,__FILE__);
SideBaseDecl g_do_vtype_sbd_DoRunTimeC_1("DoRunTimeC","NotifierI",sizeof(NotifierI),sidebase_offset<DoRunTimeC,NotifierI>(),NULL,-1,NULL);
SideBaseDecl g_do_vtype_sbd_DoRunTimeC_2("DoRunTimeC","NamedRefI",sizeof(NamedRefI),sidebase_offset<DoRunTimeC,NamedRefI>(),NULL,-1,NULL);
SideBaseDecl g_do_vtype_sbd_DoRunTimeC_3("DoRunTimeC","DortInternalI",sizeof(DortInternalI),sidebase_offset<DoRunTimeC,DortInternalI>(),NULL,-1,NULL);
DynObjType* DoRunTimeC::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DoRunTimeC;
}
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif // DORUNTIME_H

---