XMemory.h

Go to the documentation of this file.

//! @file XMemory.h
//! @brief Set memory callbacks, memory leaks and low level allocation functions
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(CXMEMORY_INCLUDE_H)
#define CXMEMORY_INCLUDE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "XMemoryMacros.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
// if MOOTOOLS_USE_NEW_AND_DELETE is not defined, we use a specific callbackable malloc / realloc function
// Otherwise we use the standard c standard malloc / realloc...
#ifndef MOOTOOLS_USE_NEW_AND_DELETE
 
    //! @enum XAllocType
    //! @brief Defines the required allocation type provided through XMemoryCallback callback
    typedef enum XAllocType
    {
        XALLOC_UNDEFINED = 0, // Never sent
 
        // Information about the memory being allocated of freed
        XALLOC_MALLOC, //!< malloc C method
        XALLOC_CALLOC, //!< calloc C method. Do not forget to call something equivalent to calloc that set memory to 0
        XALLOC_FREE, //!< free C method
        XALLOC_NEW, //!< new C++
        XALLOC_DELETE, //!< delete C++
        XALLOC_MALLOC_ALIGNED, //!< Not used
        XALLOC_CALLOC_ALIGNED, //!< Not used
        XALLOC_NEW_ALIGNED, //!< Not used
    } XAllocType;
 
    // Memory callback types
#ifdef _DEBUG
    typedef void * (*mallocCallbackDbg)(size_t newSize, XAllocType type, LPCSTR file, int line); //!< Called by malloc / calloc / new operation
    typedef void * (*reallocCallbackDbg)(void *pointer, size_t newSize, LPCSTR file, int line); //!< Called by realloc operation
    typedef void (*freeCallbackDbg)(void *pointer, XAllocType type, LPCSTR file, int line); //!< Called by free / delete operation
#else
    typedef void * (*mallocCallback)(size_t newSize, XAllocType type); //!< Called by malloc / calloc / new operation
    typedef void * (*reallocCallback)(void *pointer, size_t newSize); //!< Called by realloc operation
    typedef void (*freeCallback)(void *pointer, XAllocType type); //!< Called by free / delete operation
#endif
 
    //! @struct XMemoryCallback
    //! @brief Defines a set of memory callback handlers that can be modified.
    //! @details memoryCallbackNotify is a global XMemoryCallback. If you modify it, you can replace default callbacks by your own one. 
    typedef struct XMemoryCallback
    {
#ifdef _DEBUG
        mallocCallbackDbg malloc;
        reallocCallbackDbg realloc;
        freeCallbackDbg free;
#else
        mallocCallback malloc;
        reallocCallback realloc;
        freeCallback free;
#endif
        XMemoryCallback()
        {
            malloc = NULL;
            realloc = NULL;
            free = NULL;
        }
    } XMemoryCallback;
 
    //! Use this memory callback object to receive notification on new, malloc, realloc, free, delete
    //! @note memoryCallbackNotify is initialized at startup.\n
    //! As the static order initialization is unknown, do not use these memory function to allocate static objects.\n
    //! Such objet might be allocated before XMemoryCallback constructors calls resulting in invalid callback pointer and potential crash.
    DLL_TOOLSFUNCTION extern XMemoryCallback memoryCallbackNotify;
 
    //! @name Main library allocators (superseed C standard allocators)
    //! @{
    DLL_TOOLSFUNCTION void *xmalloc(size_t nSize);
    DLL_TOOLSFUNCTION void xfree(void *p);
    DLL_TOOLSFUNCTION void *xrealloc(void *p, size_t newSize); // Can be called only if xmalloc has been used
    DLL_TOOLSFUNCTION void *xcalloc(size_t numElement, size_t elementSize);
    
    DLL_TOOLSFUNCTION void *xnew(size_t nSize); //!< Only used by macros xNew
    DLL_TOOLSFUNCTION void xdelete(void *p);  //!< Only used by macros xDelete
 
    //! @}
#ifdef _DEBUG
    void DebugCheckAllocator();
    void EnableMemoryLeaksChecking(bool enable); //!< Enable memory leak checking which can requires a lot of memory for big 3d scene (disabled by default)
 
    // Replace std c memory function by equivalent debug function
    #define xmalloc(nSize) xmalloc_dbg(nSize, __FILE__, __DATE__, __LINE__) // Can also use xAllocate
    #define xfree(nSize) xfree_dbg(nSize, __FILE__, __DATE__, __LINE__) // Can also use xDeallocate
    #define xrealloc(p, nSize) xrealloc_dbg(p, nSize, __FILE__, __DATE__, __LINE__) // 
    #define xcalloc(num, nSize) xcalloc_dbg(num, nSize, __FILE__, __DATE__, __LINE__)
    #define xmalloc_array(nSize, nCount) xmalloc_dbg((nSize)*(nCount), __FILE__, __DATE__, __LINE__) // Can also use xAllocateArray
    #define xfree_array(p, nCount) xfree_dbg(p, __FILE__, __DATE__, __LINE__) // Can also use xDeallocateArray
 
    #define xnew(nSize) xnew_dbg(nSize, __FILE__, __DATE__, __LINE__) // use xNew. This one only handles the memory allocation.
    #define xdelete(p) xdelete_dbg(p, __FILE__, __DATE__, __LINE__) // use xDelete. This one only handles the memory deletion.
    #define xnew_array(nSize, nCount) xnew_array_dbg(nSize, nCount, __FILE__, __DATE__, __LINE__) // use xNewArray. This one only handles the memory allocation.
    #define xdelete_array(p, nCount) xdelete_array_dbg(p, nCount, __FILE__, __DATE__, __LINE__) // use xDeleteArray. This one only handles the memory deletion.
 
    // Declare debug memory functions
    DLL_TOOLSFUNCTION void *xmalloc_dbg(size_t nSize, LPCSTR lpszFileName, LPCSTR lpszFileDate, int nLine);
    DLL_TOOLSFUNCTION void xfree_dbg(void *p, LPCSTR lpszFileName, LPCSTR lpszFileDate, int nLine);
    DLL_TOOLSFUNCTION void *xrealloc_dbg(void *p, size_t nSize, LPCSTR lpszFileName, LPCSTR lpszFileDate, int nLine);
    DLL_TOOLSFUNCTION void *xcalloc_dbg(size_t num, size_t nSize, LPCSTR lpszFileName, LPCSTR lpszFileDate, int nLine);
 
    DLL_TOOLSFUNCTION void *xnew_dbg(size_t nSize, LPCSTR lpszFileName, LPCSTR lpszFileDate, int line);
    DLL_TOOLSFUNCTION void xdelete_dbg(void* p, LPCSTR lpszFileName, LPCSTR lpszFileDate, int line);
    DLL_TOOLSFUNCTION void *xnew_array_dbg(size_t nSize, size_t nCount, LPCSTR lpszFileName, LPCSTR lpszFileDate, int line); // This allow to verify if we destroy the correct number of elements
    DLL_TOOLSFUNCTION void xdelete_array_dbg(void* p, size_t nCount, LPCSTR lpszFileName, LPCSTR lpszFileDate, int line);
#else
    #define xmalloc_array(nSize, nCount) xmalloc((nSize)*(nCount))
    #define xfree_array(p, nCount) xfree(p)
    #define xnew_array(nSize, nCount) xnew((nSize)*(nCount))
    #define xdelete_array(p, nCount) xdelete(p)
#endif
#else // MOOTOOLS_USE_NEW_AND_DELETE
    #define DisableMemoryLeaksChecking() {}
    #define xmalloc malloc
    #define xmalloc_array malloc
    #define xfree free
    #define xrealloc realloc
    #define xcalloc calloc
 
    // xnew and xdelete should only be used by xNew and xDelete which don't use them when MOOTOOLS_USE_NEW_AND_DELETE defined
#endif
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(CXMEMORY_INCLUDE_H)