DortInternal.h

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

#ifndef DORT_INT_H
#define DORT_INT_H

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

// --- Forward class declarations ---
class DoModuleC;
struct DortInternalI;

// --- For each declared class, doTypeInfo template specializations ---
DO_DECL_TYPE_INFO(DoModuleC,DOMODULEC_TYPE_ID);
DO_DECL_TYPE_INFO(DortInternalI,DORTINTERNALI_TYPE_ID);

// %%DYNOBJ section end

// Event ID for tracking DynObj:s
#define NOT_EVT_ON_DYNOBJ_DESTROY   (NOT_EVT_MAIN_APP_FIRST+0)


class DynObjLibI;

// %%DYNOBJ class(DynI) flags(NoTypeId) 
class DoModuleC : public DynI {
public:
    DoModuleC() : m_plib(0), m_pmod_data(0), m_plib_base((const char*)-1) { }
    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
    
    virtual DynObjType* docall FindTypeFromVPTR( void** vtbl ){ return NULL; }
    virtual DynObjType* docall FindTypeFromName( const char *type, const char *header=NULL ){ return NULL; }
    virtual DynObjType* docall FindTypeFromId( int type_id ){ return NULL; }
    
    DynObjLibI   *m_plib;
    doModuleData *m_pmod_data;
    const char   *m_plib_base;  // Base address of library

    // Help, lookup DynIbjLibI => DoModuleC
    bool operator == (DynObjLibI* plib){ return m_plib==+plib; } 
};

// %% DYNOBJ class(vobj) flags(notypeid)
struct DortInternalI {
    virtual void docall OnObjectCreate( DynObj *pdo, DoModuleC *pmod ) = 0;
    virtual void docall OnObjectDestroy( DynObj *pdo, DoModuleC *pmod ) = 0;
    virtual void docall TempDisableCreate( bool disable ) = 0;
    
    virtual bool docall RegisterModule( DoModuleC *pmi ) = 0;
    virtual bool docall UnRegisterModule( DoModuleC *pmi ) = 0;
    virtual DoModuleC* docall GetModuleByIndex( int ix ) = 0;

    // Manage types based on VTable pointer
    virtual bool docall RegisterTypeVTable( void **vtbl, DynObjType *pdt ) = 0;
    virtual bool docall UnRegisterTypeVTable( void **vtbl ) = 0;
    
    // Merge a whole list (library) of types
    virtual int docall MergeTypes( doModuleData *pmod_data ) = 0;
    virtual bool docall UnMergeTypes( doModuleData *pmod_data ) = 0;

    // Check if valid type 
    virtual bool docall IsValidType( DynObjType *pdt ) = 0;

    // Address => Module resolution
    virtual DoModuleC* docall GetModuleByAddr( const void* paddr ) = 0;
    virtual DoModuleC* docall GetModuleForType( DoModuleC* pmod_caller, int type_id ) = 0;

    // Temporary permissions for a module, used during load time
    virtual void docall SetModuleTempPermissions( DynObjLibI *plib, const void* paddr, int flags ) = 0; 
    virtual void docall ResetModuleTempPermissions( ) = 0;

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

    // Return a custom type id to be used by derived custom DoTypeItems
    // Returns: 128...255 on success, -1 on failure
    virtual int docall AllocTypeItemTypeId( ) = 0;

    // Alloc from main, free at shutdown or earlier
    virtual void* docall MainAlloc( int size ) = 0;
    virtual bool  docall MainFree( void* pmem ) = 0;



    // Cannot get address of PMF, so use a plain inline function for that.
    static inline int GetCurrentModule_Helper(){ return 1; } 

    // Returns current module, must be inline!
    inline DoModuleC* GetCurrentModule( ){ 
        //const void* paddr = reinterpret_cast<const void*>( GetCurrentModule_Helper );
        int (*pf)() = &GetCurrentModule_Helper;
        const void *paddr = *(void**)&pf;
        return GetModuleByAddr( paddr );
    } 


};

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

// Generate type information that auto-registers on module load
DynObjType g_do_vtype_DoModuleC("DoModuleC","DynI",DOMODULEC_TYPE_ID,0,sizeof(DoModuleC),NULL,NULL,__FILE__);
DynObjType* DoModuleC::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DoModuleC;
}
DynObjType g_do_vtype_DortInternalI("DortInternalI","VObj",DORTINTERNALI_TYPE_ID,0,sizeof(DortInternalI),NULL,NULL,__FILE__);
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif // DORT_INT_H 

---