ctlnew.h

Go to the documentation of this file.

#ifndef CTLNEW_H
#define CTLNEW_H

#define ctl_malloc(ptr,size)            _ctlmalloc(     ppCastPtr(void**)&(ptr),(size)  ppDebugParam( ppFileLine("ctl_malloc") ) )

#define ctl_calloc(ptr, nelem, size)    _ctlcalloc(     ppCastPtr(void**)&(ptr),(nelem),(size)  ppDebugParam( ppFileLine("ctl_calloc") ) )

#define ctl_realloc(ptr,size)           _ctlrealloc(    ppCastPtr(void**)&(ptr),(size)  ppDebugParam( ppFileLine("ctl_realloc") ) )

#define ctl_free(ptr)                   _ctlfree(       ppCastPtr(void**)&(ptr)         ppDebugParam( ppFileLine("ctl_free") ) )

#define ctl_size(ptr)                   _ctlsize( (ptr)     ppDebugParam( ppFileLine("ctl_size") ) )

#define ctl_strdup(ptr,sz)              _ctlstrdup( (char**)&(ptr), (sz)            ppDebugParam( ppFileLine("ctl_strdup") ) )

#define ctl_wcsdup(ptr,sz)              _ctlwcsdup( (wchar_t**)&(ptr),  (sz)            ppDebugParam( ppFileLine("ctl_wcsdup") ) )

#define ctl_assertmem(ptr)              assert( _ctlvalidate( (ptr), ppFileLine("ctl_assertmem") ) )

#define ctl_alloctype(ptr,type)         ctl_malloc((ptr),sizeof(type))

#define ctl_alloc_array(ptr,type,count) ctl_malloc((ptr),sizeof(type)*(count))

#define ctl_calloctype(ptr,type)        ctl_calloc((ptr),sizeof(type))

#define ctl_calloc_array(ptr,type,count)    ctl_calloc((ptr),sizeof(type)*(count))

#define ctl_new(ptr,type)\
{\
    void** ppScr(pptr) = ppCastPtr(void**)&(ptr);\
    _ctlnew( (void**)ppScr(pptr), sizeof(type), ppCastPtr(void(*)(void*))ppConcat(type,_destroy)    ppDebugParam( ppFileLine("ctl_new") ) );\
    ppConcat(type,_init)((type*)*ppScr(pptr));\
}

#define ctl_new_array(type,ptr,count) \
{\
    if( ctl_malloc((ptr),sizeof(type)*(count)) );\
    {\
        type* ppScr2(newa,pcurr) = (ptr);\
        const type* ppScr2(newa,end) = ppScr2(newa,pcurr) + (count);\
        while( ppScr2(newa,pcurr)++ < ppScr2(newa,end) )\
            ppConcat(type,_init)(ppScr2(newa,pcurr));\
    }\
}

#define ctl_delete(ptr)     _ctldelete( ppCastPtr(void**)&(ptr) ppDebugParam( ppFileLine("ctl_delete") ) )

#define ctl_ref( ptr, fromptr )     _ctlref( ((ptr)=(fromptr))  ppDebugParam( ppFileLine("ctl_ref") ) )

#define ctl_deref( ptr )    _ctldelete( ppCastPtr(void**)&(ptr) ppDebugParam( ppFileLine("ctl_deref") ) )

#define ctl_refcount( ptr ) _ctlrefcount( (ptr) ppDebugParam( ppFileLine("ctl_refcount") ) )

#define ctl_delete_array(type,ptr,count) \
{\
    type* ppScr2(dela,pcurr) = (ptr) + (count);\
    const type* ppScr2(dela,end) = ppScr2(dela,pcurr);\
    while( ppScr2(dela,pcurr)-- > ppScr2(dela,end) )\
        ppConcat(type,_destroy)(ppScr2(dela,pcurr));\
    ctl_free(ptr);\
}

typedef void (*ctl_newhandler)( const char* sz, size_t needed );
ctl_newhandler ctl_set_new_handler( ctl_newhandler handler );
bool _ctlmalloc(    void** ptr, size_t size         ppDebugParam(const char* szFileLine) );
bool _ctlcalloc(    void** ptr, size_t size         ppDebugParam(const char* szFileLine) );
bool _ctlrealloc(   void** ptr, size_t size         ppDebugParam(const char* szFileLine) );
void _ctlfree(      void** ptr                      ppDebugParam(const char* szFileLine) );
size_t _ctlsize( void* ptr                          ppDebugParam(const char* szFileLine) );
bool _ctlstrdup(    char** ptr, const char* sz      ppDebugParam(const char* szFileLine) );
bool _ctlwcsdup(    wchar_t** ptr, const wchar_t*sz ppDebugParam(const char* szFileLine) );
bool _ctlnew( void** ptr, size_t size, void (*destruct)(void*)  ppDebugParam(const char* szFileLine) );
int  _ctldelete( void** ptr                         ppDebugParam(const char* szFileLine) );
int  _ctlref( void* ptr                             ppDebugParam(const char* szFileLine) );
int  _ctlrefcount( void* ptr                        ppDebugParam(const char* szFileLine) );
#ifdef NDEBUG
#define ctl_memory_dump( logmask ) 0
#else

size_t ctl_memory_dump( uint32 logmask );
bool _ctlvalidate(  void* ptr                       ppDebugParam(const char* szFileLine) );
#endif

#define ctl_pool(type)                      ctl_pool_base

#define ctl_pool_auto(type,pool,delta)      ctl_pool_base_auto(sizeof(type),delta,pool)

#define ctl_pool_init(type,pool,delta)      ctl_pool_base_init(pool,sizeof(type),delta,#pool)

#define ctl_pool_grow(type,pool,size)       ctl_pool_base_grow(pool,size)

#define ctl_pool_destroy(type,pool)         ctl_pool_base_destroy(pool)

#define ctl_pool_alloc(type,pool, ptr)      { (ptr) = (type*)ctl_pool_base_alloc(pool); }

#define ctl_pool_free(type,pool, ptr)       { ctl_pool_base_free(pool, (ptr) ); (ptr) = NULL; }

#define ctl_pool_free_count(pool)           ((pool)->cFree)

#define ctl_pool_alloc_count(pool)          ((pool)->cAlloc)

#define ctl_pool_count(pool)                ((pool)->cAlloc+(pool)->cFree)

struct ctl_pool_base_node;
struct ctl_pool_base_block;
typedef struct ctl_pool_base
{
    struct ctl_pool_base_node*  freelist;   
    struct ctl_pool_base_block* blocks;     
    struct ctl_pool_base*       poolList;   
    const char*                 name;       
    size_t                      unit;       
    size_t                      delta;      
    size_t                      cFree;      
    size_t                      cAlloc;     
} ctl_pool_base;

#define ctl_pool_base_entry( unitSize, delta, label )   { NULL, NULL, NULL, #label, (unitSize), (delta), 0,0 }

#define ctl_pool_base_auto( unitSize, delta, label )    ctl_pool_base label = ctl_pool_base_entry( unitSize, delta, label )

void ctl_pool_base_init( ctl_pool_base* pool, size_t unitSize, size_t delta, const char* name );

void ctl_pool_base_grow( ctl_pool_base* pool, size_t size );

void ctl_pool_base_destroy( ctl_pool_base* pool );

void* ctl_pool_base_alloc( ctl_pool_base* pool );

void ctl_pool_base_free( ctl_pool_base* pool, void* ptr );

#ifdef NDEBUG
#define ctl_pool_dump(logmask) 0
#define ctl_destroy_all_pools()
#else
size_t ctl_pool_dump( uint32 logmask );
void ctl_destroy_all_pools( void );
#endif

#endif /* CTLNEW_H */